content
stringlengths 12
392k
| id
int64 0
1.08k
|
|---|---|
unsafe
fn
atomic_compare_exchange_weak
<
T
>
(
dst
:
*
mut
T
mut
current
:
T
new
:
T
)
-
>
Result
<
T
T
>
where
T
:
Copy
+
Eq
{
atomic
!
{
T
a
{
a
=
&
*
(
dst
as
*
const
_
as
*
const
_
)
;
let
mut
current_raw
=
mem
:
:
transmute_copy
(
&
current
)
;
let
new_raw
=
mem
:
:
transmute_copy
(
&
new
)
;
loop
{
match
a
.
compare_exchange_weak
(
current_raw
new_raw
Ordering
:
:
AcqRel
Ordering
:
:
Acquire
)
{
Ok
(
_
)
=
>
break
Ok
(
current
)
Err
(
previous_raw
)
=
>
{
let
previous
=
mem
:
:
transmute_copy
(
&
previous_raw
)
;
if
!
T
:
:
eq
(
&
previous
&
current
)
{
break
Err
(
previous
)
;
}
/
/
The
compare
-
exchange
operation
has
failed
and
didn
'
t
store
new
.
The
/
/
failure
is
either
spurious
or
previous
was
semantically
equal
to
/
/
current
but
not
byte
-
equal
.
Let
'
s
retry
with
previous
as
the
new
/
/
current
.
current
=
previous
;
current_raw
=
previous_raw
;
}
}
}
}
{
let
guard
=
lock
(
dst
as
usize
)
.
write
(
)
;
if
T
:
:
eq
(
&
*
dst
&
current
)
{
Ok
(
ptr
:
:
replace
(
dst
new
)
)
}
else
{
let
val
=
ptr
:
:
read
(
dst
)
;
/
/
The
value
hasn
'
t
been
changed
.
Drop
the
guard
without
incrementing
the
stamp
.
guard
.
abort
(
)
;
Err
(
val
)
}
}
}
}
| 100
|
pub extern "x86-interrupt" fn double_fault() { CommonExceptionHandler( 8); }
| 101
|
pub fn test_op_rvc_srai_crash_32() {
let buffer = fs::read("tests/programs/op_rvc_srai_crash_32")
.unwrap()
.into();
let result = run::<u32, SparseMemory<u32>>(&buffer, &vec!["op_rvc_srai_crash_32".into()]);
assert!(result.is_ok());
}
| 102
|
fn file_age(path:&Path) -> Result<time::Duration> {
let metadata = try!(fs::metadata(path));
let accessed = try!(metadata.accessed());
Ok(try!(accessed.elapsed()))
}
| 103
|
fn from_command_line() {
let config_file = env::args().nth(1).expect("config file");
println!("config file: {}", config_file);
let mut file = File::open(config_file).expect("Unable to open config file");
let mut contents = String::new();
file.read_to_string(&mut contents)
.expect("Unable to read file");
let config: Config = serde_json::from_str(&contents).unwrap();
run_with_config(config);
}
| 104
|
fn build_user(email: String, username: String) -> User{
User{
// Using the Field Init Shorthand when Variables and Fields Have the Same Name
email,
username,
active: true,
sign_in_count: 1
}
}
| 105
|
fn show(store: &MemoryStore) -> String {
let mut writer = std::io::Cursor::new(Vec::<u8>::new());
store
.dump_dataset(&mut writer, DatasetFormat::NQuads)
.unwrap();
String::from_utf8(writer.into_inner()).unwrap()
}
| 106
|
pub fn task_set_cpool(target: CAddr, cpool: CAddr) {
system_call(SystemCall::TaskSetCPool {
request: (target, cpool),
});
}
| 107
|
fn generate_binaries_data(settings: &Settings) -> crate::Result<Vec<Binary>> {
let mut binaries = Vec::new();
let regex = Regex::new(r"[^\w\d\.]")?;
let cwd = std::env::current_dir()?;
for src in settings.external_binaries() {
let src = src?;
let filename = src
.file_name()
.expect("failed to extract external binary filename")
.to_os_string()
.into_string()
.expect("failed to convert external binary filename to string");
let guid = generate_guid(filename.as_bytes()).to_string();
binaries.push(Binary {
guid,
path: cwd
.join(src)
.into_os_string()
.into_string()
.expect("failed to read external binary path"),
id: regex.replace_all(&filename, "").to_string(),
});
}
for bin in settings.binaries() {
let filename = bin.name();
let guid = generate_guid(filename.as_bytes()).to_string();
if !bin.main() {
binaries.push(Binary {
guid,
path: settings
.binary_path(bin)
.into_os_string()
.into_string()
.expect("failed to read binary path"),
id: regex.replace_all(&filename, "").to_string(),
})
}
}
Ok(binaries)
}
| 108
|
fn bench_micro(c: &mut Criterion, bench_name: &'static str) {
let mut group = c.benchmark_group(format!("{}/{}", bench_name, "micro"));
// https://github.com/timberio/vector/runs/1746002475
group.noise_threshold(0.05);
group.bench_function("bare_counter", |b| {
b.iter(|| {
counter!("test", 1);
});
});
group.bench_function("bare_counter_with_static_labels", |b| {
b.iter(|| {
counter!("test", 1, "my key" => "my value");
});
});
group.bench_function("bare_counter_with_dynamic_labels", |b| {
b.iter_batched(
|| "my value".to_owned(),
|my_value| {
counter!("test", 1, "my key" => my_value);
},
BatchSize::SmallInput,
);
});
// A span that's not even entered.
group.bench_function("ununsed_span", |b| {
b.iter_batched_ref(
|| span!(Level::ERROR, "my span"),
|_span| {
counter!("test", 1);
},
BatchSize::SmallInput,
);
});
// A span that's entered but without a counter invocation.
group.bench_function("span_enter_without_counter", |b| {
b.iter_batched_ref(
|| span!(Level::ERROR, "my span"),
|span| {
let _enter = span.enter();
},
BatchSize::SmallInput,
);
});
group.bench_function("span_no_labels", |b| {
b.iter_batched_ref(
|| span!(Level::ERROR, "my span"),
|span| {
let _enter = span.enter();
counter!("test", 1);
},
BatchSize::SmallInput,
);
});
group.bench_function("span_with_1_static_label", |b| {
b.iter_batched_ref(
|| span!(Level::ERROR, "my span", "my key" = "my value"),
|span| {
let _enter = span.enter();
counter!("test", 1);
},
BatchSize::SmallInput,
);
});
group.bench_function("span_with_2_static_labels", |b| {
b.iter_batched_ref(
|| {
span!(
Level::ERROR,
"my span",
"my key 1" = "my value 1",
"my key 2" = "my value 2"
)
},
|span| {
let _enter = span.enter();
counter!("test", 1);
},
BatchSize::SmallInput,
);
});
group.bench_function("span_with_1_dynamic_label", |b| {
b.iter_batched_ref(
|| {
let my_value = "my value".to_owned();
span!(Level::ERROR, "my span", "my key" = %my_value)
},
|span| {
let _enter = span.enter();
counter!("test", 1);
},
BatchSize::SmallInput,
);
});
group.bench_function("span_with_2_dynamic_labels", |b| {
b.iter_batched_ref(
|| {
let my_value_1 = "my value 1".to_owned();
let my_value_2 = "my value 2".to_owned();
span!(
Level::ERROR,
"my span",
"my key 1" = %my_value_1,
"my key 2" = %my_value_2
)
},
|span| {
let _enter = span.enter();
counter!("test", 1);
},
BatchSize::SmallInput,
);
});
group.finish();
}
| 109
|
fn get_common_chars(box_one: &String, box_two: &String) -> String {
box_one.chars()
.zip(box_two.chars())
.filter(|ch| ch.0 == ch.1)
.map(|ch| ch.0)
.collect()
}
| 110
|
pub(super) fn lint<'tcx>(
cx: &LateContext<'tcx>,
expr: &'tcx hir::Expr<'_>,
args: &'tcx [hir::Expr<'_>],
allow_variant_calls: bool,
simplify_using: &str,
) {
let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
if is_option || is_result {
if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
let body = cx.tcx.hir().body(eid);
let ex = &body.value;
let params = &body.params;
if can_simplify(ex, params, allow_variant_calls) {
let msg = if is_option {
"unnecessary closure used to substitute value for `Option::None`"
} else {
"unnecessary closure used to substitute value for `Result::Err`"
};
span_lint_and_sugg(
cx,
UNNECESSARY_LAZY_EVALUATIONS,
expr.span,
msg,
&format!("Use `{}` instead", simplify_using),
format!(
"{0}.{1}({2})",
snippet(cx, args[0].span, ".."),
simplify_using,
snippet(cx, ex.span, ".."),
),
Applicability::MachineApplicable,
);
}
}
}
}
| 111
|
fn main() {
let mut game = Session::new("Hello World", 5);
match game.guess('c') {
Err(e) => std::panic::panic_any(e),
Ok(_) => {}
};
game.test_display();
}
| 112
|
fn test_invalid_variable_5() {
let parsed_data =
common::get_file_content_parsed(PARENT_FOLDER, "invalid_variable_with_object.ura");
assert!(parsed_data
.unwrap_err()
.downcast_ref::<ParseError>()
.is_some());
}
| 113
|
pub fn test_misaligned_jump64() {
let buffer = fs::read("tests/programs/misaligned_jump64").unwrap().into();
let result = run::<u64, SparseMemory<u64>>(&buffer, &vec!["misaligned_jump64".into()]);
assert!(result.is_ok());
}
| 114
|
fn main() {
dotenv::dotenv().ok();
env_logger::init();
let config = config::config_from_environment().expect("Can't load configuration.");
debug!("{:?}", &config);
let system = actix::System::new("Translator");
/*
let storer = database::TradeHistoryStorer::new(config.database_url());
let storer_addr = storer.start();
*/
let db_url = config.database_url().to_owned();
let storer_addr = SyncArbiter::start(config.database_connections() as usize, move || {
database::TradeHistoryStorer::new(db_url.as_str())
});
let kraken_filter = filter::KrakenTradeHistory::new(storer_addr.clone());
let kf_addr = kraken_filter.start();
let binance_filter = filter::BinanceTradeHistory::new(storer_addr);
let bf_addr = binance_filter.start();
let rest_state = lib::restful::State::new(kf_addr, bf_addr);
HttpServer::new(move || {
App::with_state(rest_state.clone())
.middleware(Logger::default())
.scope("/trade_history", |scope| {
scope
.resource("", |r| {
r.method(Method::GET).f(restful::trade_match_root)
})
.resource("/{left_asset}", |r| {
r.method(Method::GET).f(restful::trade_match_left_asset)
})
.resource("/{left_asset}/{right_asset}", |r| {
r.method(Method::GET).f(restful::trade_match_asset_pair)
})
.resource("/{left_asset}/{right_asset}/{exchange}", |r| {
r.method(Method::PUT).f(restful::trade_match_put)
})
})
})
.bind(config.listen())
.expect("Can't bind address.")
.start();
system.run();
}
| 115
|
pub fn sobel_optimized(frame : ImageBuffer<Luma<u8>, Vec<u8>>) -> ImageBuffer<Luma<u8>, Vec<u8>> {
let mut result = ImageBuffer::new(640, 480);
let mut i = 1;
while i < 638 {
let mut j = 1;
while j < 479 {
let north_west = frame[(i-1, j-1)].channels()[0] as i32;
let north = frame[(i, j-1)].channels()[0] as i32;
let north_east = frame[(i+1, j-1)].channels()[0] as i32;
let north_east2 = frame[(i+2, j-1)].channels()[0] as i32;
let west = frame[(i-1, j)].channels()[0] as i32;
let west2 = frame[(i, j)].channels()[0] as i32;
let east = frame[(i+1, j)].channels()[0] as i32;
let east2 = frame[(i+2, j)].channels()[0] as i32;
let south_west = frame[(i-1, j+1)].channels()[0] as i32;
let south = frame[(i, j+1)].channels()[0] as i32;
let south_east = frame[(i+1, j+1)].channels()[0] as i32;
let south_east2 = frame[(i+2, j+1)].channels()[0] as i32;
let gx : i32 = north_west + south_west + (west << 1) - north_east - south_east - (east << 1);
let gy : i32 = north_west + north_east + (north << 1) - south_west - south_east - (south << 1);
let gx2 : i32 = north + (west2 << 1) + south - north_east2 - (east2 << 1) - south_east2;
let gy2 : i32 = north + (north_east << 1) + north_east2 - south - (south_east << 1) - south_east2;
let root : u8 = (((gx.abs() + gy.abs()) >> 1) as f32 * 1.414216) as u8;
let root2 : u8 = (((gx2.abs() + gy2.abs()) >> 1) as f32 * 1.414216) as u8;
result.put_pixel(i, j, Luma([root]));
result.put_pixel(i + 1, j, Luma([root2]));
j += 1;
}
i += 2;
}
return result;
}
| 116
|
pub const fn create_default_audio_stream(stream_type: AudioStreamType) -> AudioStream {
AudioStream {
stream_type: stream_type,
source: AudioSettingSource::User,
user_volume_level: DEFAULT_VOLUME_LEVEL,
user_volume_muted: DEFAULT_VOLUME_MUTED,
}
}
| 117
|
pub fn dat_op(_inputs: OpInputs) -> EmulatorResult<()> {
// Do nothing past operand evaluation
// Queue no further values to the process queue
Ok(())
}
| 118
|
fn list() {
let project = project("add").with_fuzz().build();
// Create some targets.
project.cargo_fuzz().arg("add").arg("c").assert().success();
project.cargo_fuzz().arg("add").arg("b").assert().success();
project.cargo_fuzz().arg("add").arg("a").assert().success();
// Make sure that we can list our targets, and that they're always sorted.
project
.cargo_fuzz()
.arg("list")
.assert()
.stdout("a\nb\nc\n")
.success();
}
| 119
|
fn parse_prefix_command(rom: &[u8]) -> Option<Box<dyn Instruction>> {
let opcode = rom[0];
match opcode {
/* RLC r */
0x00...0x07 => unimplemented!("RLC r"),
/* RRC r */
0x08...0x0F => unimplemented!("RRC r"),
/* RL B */
0x10 => cmd!(alu::RotateRegisterLeft(r8!(B))),
/* RL C */
0x11 => cmd!(alu::RotateRegisterLeft(r8!(C))),
/* RL D */
0x12 => cmd!(alu::RotateRegisterLeft(r8!(D))),
/* RL E */
0x13 => cmd!(alu::RotateRegisterLeft(r8!(E))),
/* RL H */
0x14 => cmd!(alu::RotateRegisterLeft(r8!(H))),
/* RL L */
0x15 => cmd!(alu::RotateRegisterLeft(r8!(L))),
/* RL A */
0x17 => cmd!(alu::RotateRegisterLeft(r8!(A))),
/* RL (HL) */
0x16 => unimplemented!("RL (HL)"),
/* RR r */
0x17...0x1F => unimplemented!("RR r"),
/* SLA r */
0x20...0x27 => unimplemented!("SLA r"),
/* SRA r */
0x27...0x2F => unimplemented!("SRA r"),
/* BIT 0,r */
0x40...0x47 => unimplemented!("BIT 0,r"),
/* BIT 1,r */
0x47...0x4F => unimplemented!("BIT 1,r"),
/* BIT 7,r */
0x78...0x7F => {
let bit: u8 = 0b1000_0000;
let register = match opcode {
0x78 => Register8::B,
0x79 => Register8::C,
0x7A => Register8::D,
0x7B => Register8::E,
0x7C => Register8::H,
0x7D => Register8::L,
// 0x7E => TargetRegister::HL,
0x7F => Register8::A,
_ => unreachable!()
};
cmd!(alu::Bit {
bit,
register
})
},
_ => None
}
}
| 120
|
pub fn fill_buffer_default<T: Default> (b: &mut [T]) {
fill_buffer_with(b, T::default)
}
| 121
|
pub fn ranged_attack(
ecs: &mut World,
map: &mut Map,
attacker: Entity,
victim: Entity,
ranged_power: i32,
) {
let mut attacker_pos = None;
let mut victim_pos = None;
// Find positions for the start and end
if let Ok(ae) = ecs.entry_ref(attacker) {
if let Ok(pos) = ae.get_component::<Position>() {
attacker_pos = Some(pos.clone());
}
}
if let Ok(ae) = ecs.entry_ref(victim) {
if let Ok(pos) = ae.get_component::<Position>() {
victim_pos = Some(pos.clone());
}
}
if attacker_pos.is_none() || victim_pos.is_none() {
return;
}
let attacker_pos = attacker_pos.unwrap();
let victim_pos = victim_pos.unwrap();
// Set state for the projectile path
let mut power = ranged_power;
let mut range = 0;
let mut projectile_path = Vec::new();
let mut splatter = None;
let mut commands = CommandBuffer::new(ecs);
let current_layer = attacker_pos.layer;
// Map of entity locations. Rebuilt every time because it might change.
let pos_map = <(&Position, &Health)>::query()
.iter(ecs)
.map(|(pos, _)| pos.pt)
.collect::<HashSet<Point>>();
// Plot the initial trajectory
line2d_bresenham(attacker_pos.pt, victim_pos.pt)
.iter()
.skip(1)
.for_each(|pt| {
projectile_path.push(*pt);
if pos_map.contains(&pt) {
power -=
hit_tile_contents(ecs, *pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(*pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
}
}
});
// The trajectory can continue if we have power left
use ultraviolet::Vec2;
let mut projectile_pos: Vec2 = Vec2::new(victim_pos.pt.x as f32, victim_pos.pt.y as f32);
let slope = (projectile_pos - Vec2::new(attacker_pos.pt.x as f32, attacker_pos.pt.y as f32))
.normalized();
while range < 25 && power > 0 {
projectile_pos += slope;
let pt = Point::new(projectile_pos.x as i32, projectile_pos.y as i32);
projectile_path.push(pt);
if pos_map.contains(&pt) {
power -= hit_tile_contents(ecs, pt, current_layer, &mut commands, &mut splatter, power);
if power < 1 {
power = 1;
range += 200;
}
}
if let Some(bsplatter) = &mut splatter {
let idx = map.get_current().point2d_to_index(pt);
map.get_current_mut().tiles[idx].color.fg = bsplatter.to_rgba(1.0);
bsplatter.r = f32::max(0.0, bsplatter.r - 0.1);
bsplatter.g = f32::max(0.0, bsplatter.g - 0.1);
bsplatter.b = f32::max(0.0, bsplatter.b - 0.1);
if bsplatter.r + bsplatter.g + bsplatter.b < 0.1 {
splatter = None;
}
}
let idx = map.get_current().point2d_to_index(pt);
if map.get_current().tiles[idx].tile_type == TileType::Wall {
range += 100;
power = 0;
}
range += 1;
if range > 5 {
power -= 1;
if power < 1 {
power = 1;
range += 100;
}
}
}
commands.push((
Projectile {
path: projectile_path,
layer: current_layer as usize,
},
Glyph {
glyph: to_cp437('*'),
color: ColorPair::new(RED, BLACK),
},
));
commands.flush(ecs);
}
| 122
|
fn check_layout(layout: Layout) -> Result<(), AllocErr> {
if layout.size() > LARGEST_POWER_OF_TWO {
return Err(AllocErr::Unsupported { details: "Bigger than largest power of two" });
}
debug_assert!(layout.size() > 0);
Ok(())
}
| 123
|
fn update(path: &Path, contents: &str, mode: Mode) -> Result<()> {
match fs2::read_to_string(path) {
Ok(ref old_contents) if normalize(old_contents) == normalize(contents) => {
return Ok(());
}
_ => (),
}
if mode == Mode::Verify {
anyhow::bail!("`{}` is not up-to-date", path.display());
}
eprintln!("updating {}", path.display());
fs2::write(path, contents)?;
return Ok(());
fn normalize(s: &str) -> String {
s.replace("\r\n", "\n")
}
}
| 124
|
pub fn success() {
exit_qemu(0x10);
}
| 125
|
async fn main() -> tide::Result<()> {
let contents = get_config("~/data/british-english").await?;
let mut app = tide::new();
app.at("/orders/shoes").post(order_shoes);
app.listen("127.0.0.1:8080").await?;
Ok(())
}
| 126
|
fn ident(url: &Url) -> String {
let url = canonicalize_url(url);
let ident = url.path_segments().and_then(|mut s| s.next_back()).unwrap_or("");
let ident = if ident == "" { "_empty" } else { ident };
format!("{}-{}", ident, short_hash(&url))
}
| 127
|
pub fn charset(charset: &CharsetType) -> Vec<char> {
match charset {
CharsetType::Lowercase => {
"abcdefghijklmnopqrstuvwxyz".chars().collect()
},
CharsetType::Uppercase => {
"ABCDEFGHIJKLMNQRSTUVWXYZ".chars().collect()
},
CharsetType::Symbols => {
"_*&|!?@$#=%".chars().collect()
},
CharsetType::Numbers => {
"0123456789".chars().collect()
}
CharsetType::Special => {
r###"!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"###.chars().collect()
}
}
}
| 128
|
fn read_chars() -> Vec<char> {
let stdin = stdin();
let mut buf = String::new();
let _bytes = stdin.read_line(&mut buf).unwrap();
return buf.trim().chars().collect();
}
| 129
|
fn yield_spin_loop(use_yield: bool) {
const NUM_THREADS: usize = 4;
let scheduler = PctScheduler::new(1, 100);
let mut config = Config::new();
config.max_steps = MaxSteps::FailAfter(50);
let runner = Runner::new(scheduler, config);
runner.run(move || {
let count = Arc::new(AtomicUsize::new(0usize));
let _thds = (0..NUM_THREADS)
.map(|_| {
let count = count.clone();
thread::spawn(move || {
count.fetch_add(1, Ordering::SeqCst);
})
})
.collect::<Vec<_>>();
while count.load(Ordering::SeqCst) < NUM_THREADS {
if use_yield {
thread::yield_now();
} else {
thread::sleep(Duration::from_millis(1));
}
}
});
}
| 130
|
pub(crate) fn run(args: &ArgMatches) -> AppResult<()> {
let tap_info = create_tap()?;
let data_sock = create_data_sock()?;
let is_auto = args.is_present("auto");
// init peers from args
let init_peers = match args.value_of("peers") {
Some(peers_str) => parse_peers_str(peers_str)?,
None => Vec::new(),
};
let state = Arc::new(AppState {
name: env::var("HOSTNAME")
.or_else(|_| env::var("HOST"))
.unwrap_or("peer-01".to_owned()),
data_sock,
tap_dev: tap_info.tap_dev,
hw_addr: tap_info.hw_addr,
peers: RwLock::new(init_peers),
});
// heartbeats thread
{
let state = state.clone();
heartbeats_thread(state);
}
// discovery thread
if is_auto {
let state = state.clone();
discovery_thread(state);
}
// control thread
{
let state = state.clone();
control_thread(state);
}
// init peers hw addr
{
let state = state.clone();
let is_empty = { state.peers.read().unwrap().is_empty() };
if !is_empty {
init_peers_hw_addr(state);
}
}
// dispatch from peers
{
let state = state.clone();
std::thread::spawn(move || dispatch_from_peers(state));
}
let mut buff = vec![0; 1500];
let dispatch_routine = DispatchRoutine(state.clone());
loop {
let mut tap_dev = &state.tap_dev;
let size = tap_dev.read(&mut buff);
if size.is_err() {
continue;
}
let mut dst_mac = [0; 6];
dst_mac.copy_from_slice(&buff[0..6]);
let mut src_mac = [0; 6];
src_mac.copy_from_slice(&buff[6..12]);
let mut proto_type = [0; 2];
proto_type.copy_from_slice(&buff[12..14]);
let eth = EthV2 {
dst_mac,
src_mac,
proto_type: u16::from_be_bytes(proto_type),
data: &buff,
};
let result = dispatch_routine.dispatch_to_peers(eth);
match result {
Err(e) => error!("error dispatch to peers, {:?}", e),
_ => {}
}
}
}
| 131
|
fn position_to_pos(file: &SourceFile, pos: &protocol::Position) -> Pos {
if let Some(mut span) = file.line_spans().nth(pos.line as usize) {
let begin = span.begin().to_usize();
let end = span.end().to_usize();
let mut k = pos.character as usize;
match file.data() {
SourceSlice::U8(s) => {
// locate k-th non-continuation byte in s where k is the 0-based column index.
//
// this code seems to be overly complicated. this is necessary because
// we need to detect the end of the line, and a plain .nth(k) cannot determine
// if the line has k exact scalar values or k is just out of bound.
let iter = span.zip(s[begin..end].iter());
for (p, _) in iter.filter(|&(_, &b)| b & 0b1100_0000 != 0b1000_0000) {
if k == 0 { return p; }
k -= 1;
}
if k == 0 { return span.end(); }
Pos::dummy()
},
SourceSlice::U16(_) => {
// same here, but the logic is much simpler
if span.len() == k {
span.end()
} else if let Some(p) = span.nth(k) {
p
} else {
Pos::dummy()
}
},
}
} else {
Pos::dummy()
}
}
| 132
|
pub fn challenge_3() {
let input = hex::decode("1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736").unwrap();
let (key, conf) = crypto::find_single_xor(&input);
println!("{} {} {}", key, String::from_utf8(crypto::xor_repeating(&input, &vec![key])).unwrap(), conf);
}
| 133
|
pub fn write_str<W>(wr: &mut W, data: &str) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_str_len(wr, data.len() as u32));
wr.write_all(data.as_bytes()).map_err(|err| ValueWriteError::InvalidDataWrite(WriteError(err)))
}
| 134
|
pub fn compstmt(nodes: Node) -> Node {
if let Node::Nodes(extracted_nodes) = nodes {
match extracted_nodes.len() {
0 => { return Node::Null; }
1 => { return extracted_nodes.get(0).unwrap().clone(); }
// TODO collection_map
_ => { return Node::Begin(extracted_nodes); }
}
} else {
panic!("compstmt: should pass in a Node::Nodes")
}
}
| 135
|
fn test_normal() {
let parsed_data = common::get_file_content_parsed(PARENT_FOLDER, "normal.ura").unwrap();
assert_eq!(parsed_data, get_expected());
}
| 136
|
pub fn test_outofcycles_in_syscall() {
let buffer = fs::read("tests/programs/syscall64").unwrap().into();
let core_machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::new(ISA_IMC, VERSION0, 20);
let mut machine = DefaultMachineBuilder::new(core_machine)
.instruction_cycle_func(Box::new(constant_cycles))
.syscall(Box::new(OutOfCyclesSyscall {}))
.build();
machine
.load_program(&buffer, &vec!["syscall".into()])
.unwrap();
let result = machine.run();
assert!(result.is_err());
assert_eq!(result.unwrap_err(), Error::CyclesExceeded);
assert_eq!(machine.cycles(), 108);
assert_eq!(machine.registers()[A0], 39);
}
| 137
|
pub fn fail() {
exit_qemu(0x11);
}
| 138
|
fn test_dec_bin_compat<D, I>(dec: D, expected_dec: &[u16], expected_comp: I)
where
D: Fn(I) -> Option<Vec<u16>>,
{
let decompressed = dec(expected_comp).expect("Valid Decompress");
assert_eq!(decompressed, expected_dec);
}
| 139
|
pub extern "x86-interrupt" fn ISR41() { CommonInterruptHandler(41); }
| 140
|
pub fn check_board(board: &str) -> bool {
let board = Board::from_str(board);
if let Ok(board) = board {
is_board_valid(&board)
}
else {
false
}
}
| 141
|
pub fn write_uint64(buf: &mut Vec<u8>, u: u64) -> usize {
let mut size = 0;
size += write_uint32(buf, (u & 0xffffffff) as u32);
size += write_uint32(buf, ((u >> 32) & 0xffffffff) as u32);
size
}
| 142
|
fn cmin() {
let corpus = Path::new("fuzz").join("corpus").join("foo");
let project = project("cmin")
.with_fuzz()
.fuzz_target(
"foo",
r#"
#![no_main]
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: &[u8]| {
let _ = data;
});
"#,
)
.file(corpus.join("0"), "")
.file(corpus.join("1"), "a")
.file(corpus.join("2"), "ab")
.file(corpus.join("3"), "abc")
.file(corpus.join("4"), "abcd")
.build();
let corpus_count = || {
fs::read_dir(project.root().join("fuzz").join("corpus").join("foo"))
.unwrap()
.count()
};
assert_eq!(corpus_count(), 5);
project
.cargo_fuzz()
.arg("cmin")
.arg("foo")
.assert()
.success();
assert_eq!(corpus_count(), 1);
}
| 143
|
fn parse_aliases(attributes: &[Attribute]) -> Option<Punctuated<AliasSchema, Comma>> {
attributes
.iter()
.find(|attribute| attribute.path().is_ident("aliases"))
.map(|aliases| {
aliases
.parse_args_with(Punctuated::<AliasSchema, Comma>::parse_terminated)
.unwrap_or_abort()
})
}
| 144
|
pub async fn client_async_with_config<'a, R, S>(
request: R,
stream: S,
config: Option<WebSocketConfig>,
) -> Result<(WebSocketStream<TokioAdapter<S>>, Response), Error>
where
R: IntoClientRequest + Unpin,
S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
{
crate::client_async_with_config(request, TokioAdapter(stream), config).await
}
| 145
|
fn pool() -> &'static Pool<ConnectionManager<PgConnection>> {
POOL.get_or_init(|| {
dotenv().ok();
let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
let manager = ConnectionManager::<PgConnection>::new(database_url);
Pool::builder()
.max_size(*pool_connection_number() as u32)
.build(manager)
.unwrap()
})
}
| 146
|
pub fn store(write: &Writer, path: &Path, data_path: &Path) {
let mut files = Vec::new();
for e in WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
if e.metadata().unwrap().is_file() {
let path = e.path();
let extension = path.extension().unwrap();
if extension == "aac" || extension == "mp3" || extension == "wav" || extension == "ogg" {
files.push(path.to_path_buf());
}
}
}
for file in files {
println!("Converting file {:?}", file.to_str());
let tag = Tag::read_from_path(&file);
// convert to pcm file
let mut cmd = Command::new("ffmpeg")
.arg("-y")
.arg("-hide_banner")
//.arg("-loglevel").arg("panic")
.arg("-i").arg(&file)
.arg("-ar").arg("48000")
.arg("-ac").arg("2")
.arg("-f").arg("s16le")
.arg("/tmp/hex-cli-audio")
.spawn()
.expect("Failed to spawn ffmpeg!");
cmd.wait().unwrap();
let mut audio_file = File::open("/tmp/hex-cli-audio").unwrap();
let mut data = Vec::new();
audio_file.read_to_end(&mut data).unwrap();
let data: &[i16] = unsafe {
slice::from_raw_parts(
data.as_ptr() as *const i16,
data.len() / 2
)
};
println!("Finished converting with {} samples", data.len());
let fingerprint = hex_database::utils::get_fingerprint(2, &data).unwrap();
let mut track = Track::empty(
fingerprint,
data.len() as f64 / 48000.0 / 2.0
);
if let Ok(tag) = tag {
if let Some(title) = tag.title().map(|x| x.to_string()) {
track.title = Some(title);
} else {
track.title = Some(file.file_stem().unwrap().to_str().unwrap().into());
}
track.album = tag.album().map(|x| x.to_string());
track.interpret = tag.artist().map(|x| x.to_string());
track.composer = tag.artist().map(|x| x.to_string());
} else {
track.title = Some(file.file_stem().unwrap().to_str().unwrap().into());
}
// store with music container
let file = File::create(data_path.join(track.key.to_path())).unwrap();
Container::save_pcm(Configuration::Stereo, data.to_vec(), file, None).unwrap();
println!("Add track with key {}", track.key.to_string());
write.add_track(track).unwrap();
}
}
| 147
|
fn parseFromFile(file: &File) {
let mut reader = BufReader::new(file);
let mut buf = String::from("");
let line_index = 0;
let mut models: Vec<Model> = Vec::new();
let mut lights: Vec<Model> = Vec::new();
while (reader.read_line(&mut buf) != 0) {
if lien_index == 0 {
if line == 'm' {
//now we read the model data
reader.read_line(&mut buf);
let model_count = buf.trim().parse().expect("it's not a number");
let mut model_index = 0;
while model_index < model_count {
parseModelInfo(&mut reader, &mut buf, &mut models)
model_index += 1;
}
}
if line == 'l' {
reader.read_line(&mut buf);
let light_count = buf.trim().parse().expect("it's not a number");
let mut light_index = 0;
while light_index < light_count {
parseModelInfo(&mut reader, &mut buf, &mut models)
model_index += 1;
}
}
}
}
}
| 148
|
pub fn hex_to_vec(hex: &str) -> Option<Vec<u8>> {
let mut out = Vec::with_capacity(hex.len() / 2);
let mut b = 0;
for (idx, c) in hex.as_bytes().iter().enumerate() {
b <<= 4;
match *c {
b'A'..=b'F' => b |= c - b'A' + 10,
b'a'..=b'f' => b |= c - b'a' + 10,
b'0'..=b'9' => b |= c - b'0',
_ => return None,
}
if (idx & 1) == 1 {
out.push(b);
b = 0;
}
}
Some(out)
}
| 149
|
fn broker(table: &mut Table, ntransfers: u32) {
let mut rng = thread_rng();
let mut ract = Range::new(0, 100);
let mut ramt = Range::new(0, 1000);
let mut nstale = 0;
for _ in 0..ntransfers {
let a1 = ract.sample(&mut rng);
let mut a2 = ract.sample(&mut rng);
while a2 == a1 {
a2 = ract.sample(&mut rng);
}
let n = ramt.sample(&mut rng);
let rt = table.time();
let mut vs = [Value::default(); 2];
table.read(rt, &[a1, a2], &mut vs);
let r1 = Row { k: a1, v: vs[0].v - n };
let r2 = Row { k: a2, v: vs[1].v + n };
match table.write(rt, &[r1, r2]) {
WriteResult::Stale { .. } => nstale += 1,
_ => ()
}
}
assert!(nstale < ntransfers / 2);
}
| 150
|
pub async fn run(host: Arc<String>) -> Result<HashSet<String>> {
let mut tasks = Vec::new();
let mut results: HashSet<String> = HashSet::new();
let resp = next_page(&host, None).await;
// insert subdomains from first page.
resp.subdomains()
.into_iter()
.map(|s| results.insert(s))
.for_each(drop);
let mut page = resp.page;
loop {
let host = host.clone();
if page > 0 && page * resp.pagesize >= resp.total {
break;
}
page += 1;
tasks.push(task::spawn(
async move { next_page(&host, Some(page)).await },
));
}
for t in tasks {
t.await
.subdomains()
.into_iter()
.map(|s| results.insert(s))
.for_each(drop);
}
Ok(results)
}
| 151
|
fn inc_25() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(RSI)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 255, 198], OperandSize::Qword)
}
| 152
|
pub fn create_default_modified_timestamps() -> ModifiedTimestamps {
let mut timestamps = HashMap::new();
let stream_types = [
AudioStreamType::Background,
AudioStreamType::Media,
AudioStreamType::Interruption,
AudioStreamType::SystemAgent,
AudioStreamType::Communication,
];
for stream_type in stream_types.iter() {
timestamps.insert(*stream_type, default_time().to_string());
}
timestamps
}
| 153
|
pub fn debug_test_fail() {
system_call(SystemCall::DebugTestFail);
loop {}
}
| 154
|
fn assemble(path: String) -> std::io::Result<()> {
let mem = assembler::parse_file(&path)?;
let out_path = path.replace(".tat", ".rom");
mem.save_program(&out_path)?;
mem.print_program();
Ok(())
}
| 155
|
async fn save_metric_entry(mut database: &Database, hostname: &str, timestamp: &DateTime<Utc>, entry: DockerContainerMetricEntry) -> Result<(), MetricSaveError> {
sqlx::query!(
"insert into metric_docker_containers (hostname, timestamp, name, state, cpu_usage, memory_usage, memory_cache, network_tx, network_rx) values ($1, $2, $3, $4, $5, $6, $7, $8, $9) returning name",
hostname.to_string(), *timestamp, entry.name, entry.state, entry.cpu_usage, entry.memory_usage as i64, entry.memory_cache as i64, entry.network_tx, entry.network_rx
).fetch_one(&mut database).await?;
Ok(())
}
| 156
|
fn loadImageFromMaterial(model: &mut Model, materialPath: &str) {
model.albedo_map = materialPath + "_albedo.png";
model.normal_map = materialPath + "_normal.png";
model.ambient_ligth = materialPath + "_ao.png";
model.roughness_map = materialPath + "_rough.png"
}
| 157
|
fn main() {
let matches = App::new(crate_name!())
.version(crate_version!())
.about("build git branches from merge requests")
.template(TEMPLATE)
.arg(
Arg::with_name("config")
.short("c")
.long("config")
.value_name("FILE")
.required(true)
.help("config file to use")
.takes_value(true),
)
.arg(
Arg::with_name("auto")
.long("auto")
.help("do not run in interactive mode"),
)
.get_matches();
let merger = Merger::from_config_file(matches.value_of("config").unwrap())
.unwrap_or_else(|e| die(e));
merger
.run(matches.is_present("auto"))
.unwrap_or_else(|e| die(e));
}
| 158
|
pub fn alignment_size(desired: usize) -> usize {
desired + (BLOCK_SIZE - PAGE_SIZE)
}
| 159
|
pub fn write_nil<W>(wr: &mut W) -> Result<(), FixedValueWriteError>
where W: Write
{
write_fixval(wr, Marker::Null)
}
| 160
|
pub fn assert_variadic_arguments<D: Display>(
name: D,
actual: usize,
expected: (usize, usize),
) -> Result<()> {
if actual < expected.0 || actual > expected.1 {
return Err(ErrorCode::NumberArgumentsNotMatch(format!(
"{} expect to have [{}, {}] arguments, but got {}",
name, expected.0, expected.1, actual
)));
}
Ok(())
}
| 161
|
fn config() -> Criterion {
let mut c = Criterion::default();
c.without_plots();
c
}
| 162
|
fn add() {
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());
assert!(project.fuzz_cargo_toml().is_file());
let cargo_toml = fs::read_to_string(project.fuzz_cargo_toml()).unwrap();
let expected_bin_attrs = "test = false\ndoc = false";
assert!(cargo_toml.contains(expected_bin_attrs));
project
.cargo_fuzz()
.arg("run")
.arg("new_fuzz_target")
.arg("--")
.arg("-runs=1")
.assert()
.success();
}
| 163
|
pub fn jmp_op(inputs: OpInputs) -> EmulatorResult<()> {
// jmp unconditionally adds the b pointer to the process queue
inputs.pq.push_back(inputs.regs.a.idx, inputs.warrior_id)?;
Ok(())
}
| 164
|
pub fn challenge_6() {
let mut file = File::open("data/6good.txt").unwrap();
let mut all_file = String::new();
file.read_to_string(&mut all_file).unwrap();
let data = base64::decode(&all_file).unwrap();
let key = crypto::break_xor(&data);
let cleartext = crypto::xor_repeating(&data, &key);
let cleartext_string = String::from_utf8(cleartext).unwrap();
println!("{}", cleartext_string);
println!("{}", hex::encode(&cleartext_string[0..32]));
}
| 165
|
pub fn make_buffer_default<T: Default> (len: usize) -> Box<[T]> {
make_buffer_with(len, T::default)
}
| 166
|
fn no_plots(c: &mut Criterion) {
c.bench_function("dummy", |b| b.iter(|| {10}));
let has_svg = !WalkDir::new(".criterion/dummy").into_iter().any(|entry| {
let entry = entry.ok();
entry
.as_ref()
.and_then(|entry| entry.path().extension())
.and_then(|ext| ext.to_str()) == Some("svg")
});
assert!(has_svg)
}
| 167
|
pub fn debug_test_succeed() {
system_call(SystemCall::DebugTestSucceed);
loop {}
}
| 168
|
async fn get_config(path: &str) -> Result<String, Error> {
fs::read_to_string(path).await
}
| 169
|
fn test_invalid_variable_3() {
let parsed_data = parse(&"$invalid: null");
assert!(parsed_data
.unwrap_err()
.downcast_ref::<ParseError>()
.is_some());
}
| 170
|
pub fn clamp<T: Ord> (x: T, a: T, b: T) -> T {
match (x.cmp(&a), x.cmp(&b)) {
(Ordering::Less, _) => a,
(_, Ordering::Greater) => b,
_ => x,
}
}
| 171
|
pub async fn handle_command(ctx: Arc<Context>, mut command: InteractionCommand) {
let name = mem::take(&mut command.data.name);
EventKind::InteractionCommand
.log(&ctx, &command, &name)
.await;
let Some(cmd) = InteractionCommands::get().command(&name) else {
return error!(name, "Unknown interaction command");
};
match process_command(ctx, command, cmd).await {
Ok(ProcessResult::Success) => info!(%name, "Processed interaction command"),
Ok(reason) => info!(?reason, "Interaction command `{name}` was not processed"),
Err(err) => error!(name, ?err, "Failed to process interaction command"),
}
}
| 172
|
pub fn open_devtools(window: Window) {
window.open_devtools()
}
| 173
|
fn cargo_fuzz() -> Command {
Command::cargo_bin("cargo-fuzz").unwrap()
}
| 174
|
pub fn write_slice(buf: &mut Vec<u8>, u: &[u8]) -> usize {
buf.extend_from_slice(u);
u.len()
}
| 175
|
fn read_private_key(path: &str) -> Result<rustls::PrivateKey, String> {
let key_pem = match fs::File::open(path) {
Ok(v) => v,
Err(err) => return Err(err.to_string()),
};
let mut reader = io::BufReader::new(key_pem);
let keys = match rustls::internal::pemfile::rsa_private_keys(&mut reader) {
Ok(keys) => keys,
Err(_) => return Err("failed to read key".to_string()),
};
Ok(keys[0].clone())
}
| 176
|
fn is_aligned(value: usize, alignment: usize) -> bool {
(value & (alignment - 1)) == 0
}
| 177
|
pub fn i_le8(x: u64, y: u64) -> u64 {
(((y | H8) - (x & !H8)) ^ x ^ y) & H8
}
| 178
|
pub fn run() {
let rules = BufReader::new(File::open("d21_input.txt").unwrap()).lines().filter_map(|l| l.ok())
.flat_map(|l| to_rules(&l).into_iter())
.collect::<HashMap<_, _>>();
let init = Matrix::square_from_vec(vec![false, true, false, false, false, true, true, true, true]);
// todo use itertools.iterate() when this actually works
let mut iter = iterate(init, |s| enhance(s, &rules));
println!("part 1: {}", iter.nth(5).unwrap().as_ref().iter().filter(|b| **b).count());
// another 12 to get the 18th iteration
println!("part 2: {}", iter.nth(12).unwrap().as_ref().iter().filter(|b| **b).count());
}
| 179
|
fn main() {
println!("Hello, friend!");
// ARRAYS
// ======
// Declare arrays
let a1 = [1, 2, 3]; // a1: [i32; 3]
let a2 = [1, 2, 3, 4]; // a2: [i32; 4]
let a3 = [0; 20]; // a3: [i32; 20] declare a array with 20 elements and all initilized with 0
// Get the length of the array
println!("Length of array a1 {}", a1.len());
println!("Length of array a2 {}", a2.len());
println!("Length of array a3 {}", a3.len());
let names = ["max", "mike", "baxter"];
// Access elements
println!("Print second array {}", names[1]);
// SLICES
// ======
let a4 = [1, 2, 3, 4, 5]; // normal array declaretion
let s1 = &a4[..]; // slice over the hole section of the array
let s2 = &a4[1..3]; // slice from index 1 to 3
println!("Slice 1 length {}", s1.len());
println!("Slice 2 length {}", s2.len());
}
| 180
|
fn main() {
let input1 = vec![1,2,5];
let sol = Solution::coin_change(input1, 11);
println!("Result: {}, Expected: 3", sol);
}
| 181
|
fn bench(f: fn()) {
let t0 = time::Instant::now();
let ret = f();
println!("time used {:?}", time::Instant::now().duration_since(t0));
ret
}
| 182
|
pub fn write_varuint7(buf: &mut Vec<u8>, u: u8) -> usize {
write_uint8(buf, u)
}
| 183
|
fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
match expr.kind {
// Closures returning literals can be unconditionally simplified
hir::ExprKind::Lit(_) => true,
hir::ExprKind::Index(ref object, ref index) => {
// arguments are not being indexed into
if expr_uses_argument(object, params) {
false
} else {
// arguments are not used as index
!expr_uses_argument(index, params)
}
},
// Reading fields can be simplified if the object is not an argument of the closure
hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
// Paths can be simplified if the root is not the argument, this also covers None
hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
// Calls to Some, Ok, Err can be considered literals if they don't derive an argument
hir::ExprKind::Call(ref func, ref args) => if_chain! {
if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
if let hir::ExprKind::Path(ref path) = func.kind;
if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
then {
// Recursively check all arguments
args.iter().all(|arg| can_simplify(arg, params, variant_calls))
} else {
false
}
},
// For anything more complex than the above, a closure is probably the right solution,
// or the case is handled by an other lint
_ => false,
}
}
| 184
|
fn inc_18() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(IndirectScaledDisplaced(RSI, Eight, 498480708, Some(OperandSize::Word), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 255, 4, 245, 68, 54, 182, 29], OperandSize::Qword)
}
| 185
|
fn main() {
// Initialize the environment logger only once.
// This should be the first thing to happen.
if let Err(e) = env_logger::init() {
error!("Failed to initialise environment logger because {}", e);
}
const VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION");
const DESC: Option<&'static str> = option_env!("CARGO_PKG_DESCRIPTION");
let mut app = App::new("Rumo")
.version(VERSION.unwrap_or("unknown"))
.about(DESC.unwrap_or("--"))
.arg(
Arg::with_name("project-dir")
.long("project-dir")
.short("d")
.help(
"Override the default project directory provided by `cargo locate-project`",
)
.takes_value(true),
)
.arg(
Arg::with_name("ndk-toolchain-root")
.long("ndk-toolchain-root")
.help(
"Root directory where individual standalone NDK toolchains \
are placed during a One-Time install at build. \n\n\
For each architecture targeted, a standalone NDK toolchain \
will be created in this directory. \n\n\
Default = <project_root>/target\n",
),
)
.arg(
Arg::with_name("ignore-linker-config")
.long("ignore-linker-config")
.help(
"Ignore Linker configuration inside .cargo/config. \n\n\
By default, Rumo will update the linker config for each \
ABI inside the .cargo/config.\n\
Use this flag to tell Rumo not to alter those settings.\n\n\
",
),
)
.subcommand(
SubCommand::with_name("build")
.about("Create APK(s) from Project")
.arg(Arg::with_name("all").short("a").long("all"))
.arg(Arg::with_name("release").long("release").help(
"Build with cargo `release` mode optimizations",
))
.arg(Arg::with_name("clean").long("clean").help(
"Clean build artifacts for a fresh compilation",
))
.arg(Arg::with_name("arm").long("arm").help("build arm target"))
.arg(Arg::with_name("arm64").long("arm64"))
.arg(Arg::with_name("x86").long("x86"))
.arg(Arg::with_name("x86_64").long("x86_64"))
.arg(Arg::with_name("mips").long("mips"))
.arg(Arg::with_name("mips64").long("mips64")),
)
.subcommand(
SubCommand::with_name("install")
.about("Install build onto device\n")
.arg(Arg::with_name("android").long("--android"))
.arg(Arg::with_name("ios").long("--ios")),
);
///////////////////////////////////////////////////////////////////
let matches = app.clone().get_matches();
// Fetching the configuration for the build.
let mut config = config::load(&match matches.value_of("project-dir") {
Some(p) => PathBuf::from(p),
None => current_manifest_path().unwrap(),
});
// Control Release / debug build mode
config.release = matches.is_present("release");
// Allow overriding default ndk standalone toolchain root directory.
// Default is <project_root>/target
match matches.value_of("ndk-toolchain-root") {
Some(p) => {
config.toolchain_target_dir = match fs::canonicalize(p.to_owned()) {
Ok(path) => path.to_str().unwrap().to_owned(),
Err(e) => {
panic!(
"Failed to get canonical path of: {} \n
Error reason: {}",
p,
e
)
}
}
}
None => (),
};
// Allow user to ignore linker config modifications
// (only if you are sure you know what your doing!)
config.ignore_linker_config = matches.is_present("ignore-linker-config");
///////////////////////////////////////////////////////////////////
// Every thing looks good, let's execute the users cli switches.
if let Some(bm) = matches.subcommand_matches("build") {
// Build vector of architectures
if bm.is_present("all") {
config.build_targets = Arch::all();
} else {
if bm.is_present("arm") {
config.build_targets.push(Arch::ARM);
}
if bm.is_present("arm64") {
config.build_targets.push(Arch::ARM64);
}
if bm.is_present("x86") {
config.build_targets.push(Arch::X86);
}
if bm.is_present("x86_64") {
config.build_targets.push(Arch::X86_64);
}
if bm.is_present("mips") {
config.build_targets.push(Arch::MIPS);
}
if bm.is_present("mips64") {
config.build_targets.push(Arch::MIPS64);
}
// Build fallback to x86 if no archs specified
if config.build_targets.is_empty() {
config.build_targets.push(Arch::X86);
// config.buildc_targets.push(Arch::ARM);
}
}
// Provide a way to clean the shells
bm.is_present("clean") && shell::clean(&config);
// Check to see if we have the project shell embedded
// Noticeably, this is done after clean has a chance to run.
shell::embed_if_not_present(&config);
commands::assets(&config);
// Scribe correct project data upon the turtle shell
scribe::turtle_shell(&config);
// Ensure we have access to Standalone NDK toolchains
// for each ABI we wish to target
ndk::install_standalone(&config);
// Check to see if .cargo/config is properly setup.
// Will install or patch existing config if necessary
cargo::install_config(&config);
commands::build(&config);
} else if let Some(_) = matches.subcommand_matches("install") {
commands::install(&config);
}
// If we have not matched any sub command at this point,
// fallback to application help screen.
else {
if let Err(e) = app.print_help() {
error!("Failed to print application help because {}", e);
}
}
}
| 186
|
fn main() {
let name = std::env::args().nth(1).unwrap();
let _ = std::fs::remove_dir_all(format!("tests/data/fixtures/{name}"));
std::fs::create_dir_all(format!("tests/data/fixtures/{name}")).unwrap();
let inputs =
std::fs::File::open(format!("tests/data/fixtures/{name}.in"))
.unwrap();
let inputs = std::io::BufReader::new(inputs);
let mut i = 1;
let mut prev_input = vec![];
for line in inputs.lines() {
let line = line.unwrap();
let input = helpers::unhex(line.as_bytes());
let mut input_file = std::fs::File::create(format!(
"tests/data/fixtures/{name}/{i}.typescript"
))
.unwrap();
input_file.write_all(&input).unwrap();
prev_input.extend(input);
let mut term = vt100::Parser::default();
term.process(&prev_input);
let screen = helpers::FixtureScreen::from_screen(term.screen());
let output_file = std::fs::File::create(format!(
"tests/data/fixtures/{name}/{i}.json"
))
.unwrap();
serde_json::to_writer_pretty(output_file, &screen).unwrap();
i += 1;
}
}
| 187
|
pub fn retype_cpool(source: CAddr, target: CAddr) {
system_call(SystemCall::RetypeCPool {
request: (source, target),
});
}
| 188
|
pub fn decode(codepoint: u16) -> Option<char> {
match codepoint {
0x2121 => Some(unsafe { transmute(0x3000u32) }),
0x2122 => Some(unsafe { transmute(0x3001u32) }),
0x2123 => Some(unsafe { transmute(0x3002u32) }),
0x2124 => Some(unsafe { transmute(0xff0cu32) }),
0x2125 => Some(unsafe { transmute(0xff0eu32) }),
0x2126 => Some(unsafe { transmute(0x30fbu32) }),
0x2127 => Some(unsafe { transmute(0xff1au32) }),
0x2128 => Some(unsafe { transmute(0xff1bu32) }),
0x2129 => Some(unsafe { transmute(0xff1fu32) }),
0x212a => Some(unsafe { transmute(0xff01u32) }),
0x212b => Some(unsafe { transmute(0x309bu32) }),
0x212c => Some(unsafe { transmute(0x309cu32) }),
0x212d => Some(unsafe { transmute(0x00b4u32) }),
0x212e => Some(unsafe { transmute(0xff40u32) }),
0x212f => Some(unsafe { transmute(0x00a8u32) }),
0x2130 => Some(unsafe { transmute(0xff3eu32) }),
0x2131 => Some(unsafe { transmute(0xffe3u32) }),
0x2132 => Some(unsafe { transmute(0xff3fu32) }),
0x2133 => Some(unsafe { transmute(0x30fdu32) }),
0x2134 => Some(unsafe { transmute(0x30feu32) }),
0x2135 => Some(unsafe { transmute(0x309du32) }),
0x2136 => Some(unsafe { transmute(0x309eu32) }),
0x2137 => Some(unsafe { transmute(0x3003u32) }),
0x2138 => Some(unsafe { transmute(0x4eddu32) }),
0x2139 => Some(unsafe { transmute(0x3005u32) }),
0x213a => Some(unsafe { transmute(0x3006u32) }),
0x213b => Some(unsafe { transmute(0x3007u32) }),
0x213c => Some(unsafe { transmute(0x30fcu32) }),
0x213d => Some(unsafe { transmute(0x2015u32) }),
0x213e => Some(unsafe { transmute(0x2010u32) }),
0x213f => Some(unsafe { transmute(0xff0fu32) }),
0x2140 => Some(unsafe { transmute(0x005cu32) }),
0x2141 => Some(unsafe { transmute(0x301cu32) }),
0x2142 => Some(unsafe { transmute(0x2016u32) }),
0x2143 => Some(unsafe { transmute(0xff5cu32) }),
0x2144 => Some(unsafe { transmute(0x2026u32) }),
0x2145 => Some(unsafe { transmute(0x2025u32) }),
0x2146 => Some(unsafe { transmute(0x2018u32) }),
0x2147 => Some(unsafe { transmute(0x2019u32) }),
0x2148 => Some(unsafe { transmute(0x201cu32) }),
0x2149 => Some(unsafe { transmute(0x201du32) }),
0x214a => Some(unsafe { transmute(0xff08u32) }),
0x214b => Some(unsafe { transmute(0xff09u32) }),
0x214c => Some(unsafe { transmute(0x3014u32) }),
0x214d => Some(unsafe { transmute(0x3015u32) }),
0x214e => Some(unsafe { transmute(0xff3bu32) }),
0x214f => Some(unsafe { transmute(0xff3du32) }),
0x2150 => Some(unsafe { transmute(0xff5bu32) }),
0x2151 => Some(unsafe { transmute(0xff5du32) }),
0x2152 => Some(unsafe { transmute(0x3008u32) }),
0x2153 => Some(unsafe { transmute(0x3009u32) }),
0x2154 => Some(unsafe { transmute(0x300au32) }),
0x2155 => Some(unsafe { transmute(0x300bu32) }),
0x2156 => Some(unsafe { transmute(0x300cu32) }),
0x2157 => Some(unsafe { transmute(0x300du32) }),
0x2158 => Some(unsafe { transmute(0x300eu32) }),
0x2159 => Some(unsafe { transmute(0x300fu32) }),
0x215a => Some(unsafe { transmute(0x3010u32) }),
0x215b => Some(unsafe { transmute(0x3011u32) }),
0x215c => Some(unsafe { transmute(0xff0bu32) }),
0x215d => Some(unsafe { transmute(0x2212u32) }),
0x215e => Some(unsafe { transmute(0x00b1u32) }),
0x215f => Some(unsafe { transmute(0x00d7u32) }),
0x2160 => Some(unsafe { transmute(0x00f7u32) }),
0x2161 => Some(unsafe { transmute(0xff1du32) }),
0x2162 => Some(unsafe { transmute(0x2260u32) }),
0x2163 => Some(unsafe { transmute(0xff1cu32) }),
0x2164 => Some(unsafe { transmute(0xff1eu32) }),
0x2165 => Some(unsafe { transmute(0x2266u32) }),
0x2166 => Some(unsafe { transmute(0x2267u32) }),
0x2167 => Some(unsafe { transmute(0x221eu32) }),
0x2168 => Some(unsafe { transmute(0x2234u32) }),
0x2169 => Some(unsafe { transmute(0x2642u32) }),
0x216a => Some(unsafe { transmute(0x2640u32) }),
0x216b => Some(unsafe { transmute(0x00b0u32) }),
0x216c => Some(unsafe { transmute(0x2032u32) }),
0x216d => Some(unsafe { transmute(0x2033u32) }),
0x216e => Some(unsafe { transmute(0x2103u32) }),
0x216f => Some(unsafe { transmute(0xffe5u32) }),
0x2170 => Some(unsafe { transmute(0xff04u32) }),
0x2171 => Some(unsafe { transmute(0x00a2u32) }),
0x2172 => Some(unsafe { transmute(0x00a3u32) }),
0x2173 => Some(unsafe { transmute(0xff05u32) }),
0x2174 => Some(unsafe { transmute(0xff03u32) }),
0x2175 => Some(unsafe { transmute(0xff06u32) }),
0x2176 => Some(unsafe { transmute(0xff0au32) }),
0x2177 => Some(unsafe { transmute(0xff20u32) }),
0x2178 => Some(unsafe { transmute(0x00a7u32) }),
0x2179 => Some(unsafe { transmute(0x2606u32) }),
0x217a => Some(unsafe { transmute(0x2605u32) }),
0x217b => Some(unsafe { transmute(0x25cbu32) }),
0x217c => Some(unsafe { transmute(0x25cfu32) }),
0x217d => Some(unsafe { transmute(0x25ceu32) }),
0x217e => Some(unsafe { transmute(0x25c7u32) }),
0x2221 => Some(unsafe { transmute(0x25c6u32) }),
0x2222 => Some(unsafe { transmute(0x25a1u32) }),
0x2223 => Some(unsafe { transmute(0x25a0u32) }),
0x2224 => Some(unsafe { transmute(0x25b3u32) }),
0x2225 => Some(unsafe { transmute(0x25b2u32) }),
0x2226 => Some(unsafe { transmute(0x25bdu32) }),
0x2227 => Some(unsafe { transmute(0x25bcu32) }),
0x2228 => Some(unsafe { transmute(0x203bu32) }),
0x2229 => Some(unsafe { transmute(0x3012u32) }),
0x222a => Some(unsafe { transmute(0x2192u32) }),
0x222b => Some(unsafe { transmute(0x2190u32) }),
0x222c => Some(unsafe { transmute(0x2191u32) }),
0x222d => Some(unsafe { transmute(0x2193u32) }),
0x222e => Some(unsafe { transmute(0x3013u32) }),
0x223a => Some(unsafe { transmute(0x2208u32) }),
0x223b => Some(unsafe { transmute(0x220bu32) }),
0x223c => Some(unsafe { transmute(0x2286u32) }),
0x223d => Some(unsafe { transmute(0x2287u32) }),
0x223e => Some(unsafe { transmute(0x2282u32) }),
0x223f => Some(unsafe { transmute(0x2283u32) }),
0x2240 => Some(unsafe { transmute(0x222au32) }),
0x2241 => Some(unsafe { transmute(0x2229u32) }),
0x224a => Some(unsafe { transmute(0x2227u32) }),
0x224b => Some(unsafe { transmute(0x2228u32) }),
0x224c => Some(unsafe { transmute(0x00acu32) }),
0x224d => Some(unsafe { transmute(0x21d2u32) }),
0x224e => Some(unsafe { transmute(0x21d4u32) }),
0x224f => Some(unsafe { transmute(0x2200u32) }),
0x2250 => Some(unsafe { transmute(0x2203u32) }),
0x225c => Some(unsafe { transmute(0x2220u32) }),
0x225d => Some(unsafe { transmute(0x22a5u32) }),
0x225e => Some(unsafe { transmute(0x2312u32) }),
0x225f => Some(unsafe { transmute(0x2202u32) }),
0x2260 => Some(unsafe { transmute(0x2207u32) }),
0x2261 => Some(unsafe { transmute(0x2261u32) }),
0x2262 => Some(unsafe { transmute(0x2252u32) }),
0x2263 => Some(unsafe { transmute(0x226au32) }),
0x2264 => Some(unsafe { transmute(0x226bu32) }),
0x2265 => Some(unsafe { transmute(0x221au32) }),
0x2266 => Some(unsafe { transmute(0x223du32) }),
0x2267 => Some(unsafe { transmute(0x221du32) }),
0x2268 => Some(unsafe { transmute(0x2235u32) }),
0x2269 => Some(unsafe { transmute(0x222bu32) }),
0x226a => Some(unsafe { transmute(0x222cu32) }),
0x2272 => Some(unsafe { transmute(0x212bu32) }),
0x2273 => Some(unsafe { transmute(0x2030u32) }),
0x2274 => Some(unsafe { transmute(0x266fu32) }),
0x2275 => Some(unsafe { transmute(0x266du32) }),
0x2276 => Some(unsafe { transmute(0x266au32) }),
0x2277 => Some(unsafe { transmute(0x2020u32) }),
0x2278 => Some(unsafe { transmute(0x2021u32) }),
0x2279 => Some(unsafe { transmute(0x00b6u32) }),
0x227e => Some(unsafe { transmute(0x25efu32) }),
0x2330 => Some(unsafe { transmute(0xff10u32) }),
0x2331 => Some(unsafe { transmute(0xff11u32) }),
0x2332 => Some(unsafe { transmute(0xff12u32) }),
0x2333 => Some(unsafe { transmute(0xff13u32) }),
0x2334 => Some(unsafe { transmute(0xff14u32) }),
0x2335 => Some(unsafe { transmute(0xff15u32) }),
0x2336 => Some(unsafe { transmute(0xff16u32) }),
0x2337 => Some(unsafe { transmute(0xff17u32) }),
0x2338 => Some(unsafe { transmute(0xff18u32) }),
0x2339 => Some(unsafe { transmute(0xff19u32) }),
0x2341 => Some(unsafe { transmute(0xff21u32) }),
0x2342 => Some(unsafe { transmute(0xff22u32) }),
0x2343 => Some(unsafe { transmute(0xff23u32) }),
0x2344 => Some(unsafe { transmute(0xff24u32) }),
0x2345 => Some(unsafe { transmute(0xff25u32) }),
0x2346 => Some(unsafe { transmute(0xff26u32) }),
0x2347 => Some(unsafe { transmute(0xff27u32) }),
0x2348 => Some(unsafe { transmute(0xff28u32) }),
0x2349 => Some(unsafe { transmute(0xff29u32) }),
0x234a => Some(unsafe { transmute(0xff2au32) }),
0x234b => Some(unsafe { transmute(0xff2bu32) }),
0x234c => Some(unsafe { transmute(0xff2cu32) }),
0x234d => Some(unsafe { transmute(0xff2du32) }),
0x234e => Some(unsafe { transmute(0xff2eu32) }),
0x234f => Some(unsafe { transmute(0xff2fu32) }),
0x2350 => Some(unsafe { transmute(0xff30u32) }),
0x2351 => Some(unsafe { transmute(0xff31u32) }),
0x2352 => Some(unsafe { transmute(0xff32u32) }),
0x2353 => Some(unsafe { transmute(0xff33u32) }),
0x2354 => Some(unsafe { transmute(0xff34u32) }),
0x2355 => Some(unsafe { transmute(0xff35u32) }),
0x2356 => Some(unsafe { transmute(0xff36u32) }),
0x2357 => Some(unsafe { transmute(0xff37u32) }),
0x2358 => Some(unsafe { transmute(0xff38u32) }),
0x2359 => Some(unsafe { transmute(0xff39u32) }),
0x235a => Some(unsafe { transmute(0xff3au32) }),
0x2361 => Some(unsafe { transmute(0xff41u32) }),
0x2362 => Some(unsafe { transmute(0xff42u32) }),
0x2363 => Some(unsafe { transmute(0xff43u32) }),
0x2364 => Some(unsafe { transmute(0xff44u32) }),
0x2365 => Some(unsafe { transmute(0xff45u32) }),
0x2366 => Some(unsafe { transmute(0xff46u32) }),
0x2367 => Some(unsafe { transmute(0xff47u32) }),
0x2368 => Some(unsafe { transmute(0xff48u32) }),
0x2369 => Some(unsafe { transmute(0xff49u32) }),
0x236a => Some(unsafe { transmute(0xff4au32) }),
0x236b => Some(unsafe { transmute(0xff4bu32) }),
0x236c => Some(unsafe { transmute(0xff4cu32) }),
0x236d => Some(unsafe { transmute(0xff4du32) }),
0x236e => Some(unsafe { transmute(0xff4eu32) }),
0x236f => Some(unsafe { transmute(0xff4fu32) }),
0x2370 => Some(unsafe { transmute(0xff50u32) }),
0x2371 => Some(unsafe { transmute(0xff51u32) }),
0x2372 => Some(unsafe { transmute(0xff52u32) }),
0x2373 => Some(unsafe { transmute(0xff53u32) }),
0x2374 => Some(unsafe { transmute(0xff54u32) }),
0x2375 => Some(unsafe { transmute(0xff55u32) }),
0x2376 => Some(unsafe { transmute(0xff56u32) }),
0x2377 => Some(unsafe { transmute(0xff57u32) }),
0x2378 => Some(unsafe { transmute(0xff58u32) }),
0x2379 => Some(unsafe { transmute(0xff59u32) }),
0x237a => Some(unsafe { transmute(0xff5au32) }),
0x2421 => Some(unsafe { transmute(0x3041u32) }),
0x2422 => Some(unsafe { transmute(0x3042u32) }),
0x2423 => Some(unsafe { transmute(0x3043u32) }),
0x2424 => Some(unsafe { transmute(0x3044u32) }),
0x2425 => Some(unsafe { transmute(0x3045u32) }),
0x2426 => Some(unsafe { transmute(0x3046u32) }),
0x2427 => Some(unsafe { transmute(0x3047u32) }),
0x2428 => Some(unsafe { transmute(0x3048u32) }),
0x2429 => Some(unsafe { transmute(0x3049u32) }),
0x242a => Some(unsafe { transmute(0x304au32) }),
0x242b => Some(unsafe { transmute(0x304bu32) }),
0x242c => Some(unsafe { transmute(0x304cu32) }),
0x242d => Some(unsafe { transmute(0x304du32) }),
0x242e => Some(unsafe { transmute(0x304eu32) }),
0x242f => Some(unsafe { transmute(0x304fu32) }),
0x2430 => Some(unsafe { transmute(0x3050u32) }),
0x2431 => Some(unsafe { transmute(0x3051u32) }),
0x2432 => Some(unsafe { transmute(0x3052u32) }),
0x2433 => Some(unsafe { transmute(0x3053u32) }),
0x2434 => Some(unsafe { transmute(0x3054u32) }),
0x2435 => Some(unsafe { transmute(0x3055u32) }),
0x2436 => Some(unsafe { transmute(0x3056u32) }),
0x2437 => Some(unsafe { transmute(0x3057u32) }),
0x2438 => Some(unsafe { transmute(0x3058u32) }),
0x2439 => Some(unsafe { transmute(0x3059u32) }),
0x243a => Some(unsafe { transmute(0x305au32) }),
0x243b => Some(unsafe { transmute(0x305bu32) }),
0x243c => Some(unsafe { transmute(0x305cu32) }),
0x243d => Some(unsafe { transmute(0x305du32) }),
0x243e => Some(unsafe { transmute(0x305eu32) }),
0x243f => Some(unsafe { transmute(0x305fu32) }),
0x2440 => Some(unsafe { transmute(0x3060u32) }),
0x2441 => Some(unsafe { transmute(0x3061u32) }),
0x2442 => Some(unsafe { transmute(0x3062u32) }),
0x2443 => Some(unsafe { transmute(0x3063u32) }),
0x2444 => Some(unsafe { transmute(0x3064u32) }),
0x2445 => Some(unsafe { transmute(0x3065u32) }),
0x2446 => Some(unsafe { transmute(0x3066u32) }),
0x2447 => Some(unsafe { transmute(0x3067u32) }),
0x2448 => Some(unsafe { transmute(0x3068u32) }),
0x2449 => Some(unsafe { transmute(0x3069u32) }),
0x244a => Some(unsafe { transmute(0x306au32) }),
0x244b => Some(unsafe { transmute(0x306bu32) }),
0x244c => Some(unsafe { transmute(0x306cu32) }),
0x244d => Some(unsafe { transmute(0x306du32) }),
0x244e => Some(unsafe { transmute(0x306eu32) }),
0x244f => Some(unsafe { transmute(0x306fu32) }),
0x2450 => Some(unsafe { transmute(0x3070u32) }),
0x2451 => Some(unsafe { transmute(0x3071u32) }),
0x2452 => Some(unsafe { transmute(0x3072u32) }),
0x2453 => Some(unsafe { transmute(0x3073u32) }),
0x2454 => Some(unsafe { transmute(0x3074u32) }),
0x2455 => Some(unsafe { transmute(0x3075u32) }),
0x2456 => Some(unsafe { transmute(0x3076u32) }),
0x2457 => Some(unsafe { transmute(0x3077u32) }),
0x2458 => Some(unsafe { transmute(0x3078u32) }),
0x2459 => Some(unsafe { transmute(0x3079u32) }),
0x245a => Some(unsafe { transmute(0x307au32) }),
0x245b => Some(unsafe { transmute(0x307bu32) }),
0x245c => Some(unsafe { transmute(0x307cu32) }),
0x245d => Some(unsafe { transmute(0x307du32) }),
0x245e => Some(unsafe { transmute(0x307eu32) }),
0x245f => Some(unsafe { transmute(0x307fu32) }),
0x2460 => Some(unsafe { transmute(0x3080u32) }),
0x2461 => Some(unsafe { transmute(0x3081u32) }),
0x2462 => Some(unsafe { transmute(0x3082u32) }),
0x2463 => Some(unsafe { transmute(0x3083u32) }),
0x2464 => Some(unsafe { transmute(0x3084u32) }),
0x2465 => Some(unsafe { transmute(0x3085u32) }),
0x2466 => Some(unsafe { transmute(0x3086u32) }),
0x2467 => Some(unsafe { transmute(0x3087u32) }),
0x2468 => Some(unsafe { transmute(0x3088u32) }),
0x2469 => Some(unsafe { transmute(0x3089u32) }),
0x246a => Some(unsafe { transmute(0x308au32) }),
0x246b => Some(unsafe { transmute(0x308bu32) }),
0x246c => Some(unsafe { transmute(0x308cu32) }),
0x246d => Some(unsafe { transmute(0x308du32) }),
0x246e => Some(unsafe { transmute(0x308eu32) }),
0x246f => Some(unsafe { transmute(0x308fu32) }),
0x2470 => Some(unsafe { transmute(0x3090u32) }),
0x2471 => Some(unsafe { transmute(0x3091u32) }),
0x2472 => Some(unsafe { transmute(0x3092u32) }),
0x2473 => Some(unsafe { transmute(0x3093u32) }),
0x2521 => Some(unsafe { transmute(0x30a1u32) }),
0x2522 => Some(unsafe { transmute(0x30a2u32) }),
0x2523 => Some(unsafe { transmute(0x30a3u32) }),
0x2524 => Some(unsafe { transmute(0x30a4u32) }),
0x2525 => Some(unsafe { transmute(0x30a5u32) }),
0x2526 => Some(unsafe { transmute(0x30a6u32) }),
0x2527 => Some(unsafe { transmute(0x30a7u32) }),
0x2528 => Some(unsafe { transmute(0x30a8u32) }),
0x2529 => Some(unsafe { transmute(0x30a9u32) }),
0x252a => Some(unsafe { transmute(0x30aau32) }),
0x252b => Some(unsafe { transmute(0x30abu32) }),
0x252c => Some(unsafe { transmute(0x30acu32) }),
0x252d => Some(unsafe { transmute(0x30adu32) }),
0x252e => Some(unsafe { transmute(0x30aeu32) }),
0x252f => Some(unsafe { transmute(0x30afu32) }),
0x2530 => Some(unsafe { transmute(0x30b0u32) }),
0x2531 => Some(unsafe { transmute(0x30b1u32) }),
0x2532 => Some(unsafe { transmute(0x30b2u32) }),
0x2533 => Some(unsafe { transmute(0x30b3u32) }),
0x2534 => Some(unsafe { transmute(0x30b4u32) }),
0x2535 => Some(unsafe { transmute(0x30b5u32) }),
0x2536 => Some(unsafe { transmute(0x30b6u32) }),
0x2537 => Some(unsafe { transmute(0x30b7u32) }),
0x2538 => Some(unsafe { transmute(0x30b8u32) }),
0x2539 => Some(unsafe { transmute(0x30b9u32) }),
0x253a => Some(unsafe { transmute(0x30bau32) }),
0x253b => Some(unsafe { transmute(0x30bbu32) }),
0x253c => Some(unsafe { transmute(0x30bcu32) }),
0x253d => Some(unsafe { transmute(0x30bdu32) }),
0x253e => Some(unsafe { transmute(0x30beu32) }),
0x253f => Some(unsafe { transmute(0x30bfu32) }),
0x2540 => Some(unsafe { transmute(0x30c0u32) }),
0x2541 => Some(unsafe { transmute(0x30c1u32) }),
0x2542 => Some(unsafe { transmute(0x30c2u32) }),
0x2543 => Some(unsafe { transmute(0x30c3u32) }),
0x2544 => Some(unsafe { transmute(0x30c4u32) }),
0x2545 => Some(unsafe { transmute(0x30c5u32) }),
0x2546 => Some(unsafe { transmute(0x30c6u32) }),
0x2547 => Some(unsafe { transmute(0x30c7u32) }),
0x2548 => Some(unsafe { transmute(0x30c8u32) }),
0x2549 => Some(unsafe { transmute(0x30c9u32) }),
0x254a => Some(unsafe { transmute(0x30cau32) }),
0x254b => Some(unsafe { transmute(0x30cbu32) }),
0x254c => Some(unsafe { transmute(0x30ccu32) }),
0x254d => Some(unsafe { transmute(0x30cdu32) }),
0x254e => Some(unsafe { transmute(0x30ceu32) }),
0x254f => Some(unsafe { transmute(0x30cfu32) }),
0x2550 => Some(unsafe { transmute(0x30d0u32) }),
0x2551 => Some(unsafe { transmute(0x30d1u32) }),
0x2552 => Some(unsafe { transmute(0x30d2u32) }),
0x2553 => Some(unsafe { transmute(0x30d3u32) }),
0x2554 => Some(unsafe { transmute(0x30d4u32) }),
0x2555 => Some(unsafe { transmute(0x30d5u32) }),
0x2556 => Some(unsafe { transmute(0x30d6u32) }),
0x2557 => Some(unsafe { transmute(0x30d7u32) }),
0x2558 => Some(unsafe { transmute(0x30d8u32) }),
0x2559 => Some(unsafe { transmute(0x30d9u32) }),
0x255a => Some(unsafe { transmute(0x30dau32) }),
0x255b => Some(unsafe { transmute(0x30dbu32) }),
0x255c => Some(unsafe { transmute(0x30dcu32) }),
0x255d => Some(unsafe { transmute(0x30ddu32) }),
0x255e => Some(unsafe { transmute(0x30deu32) }),
0x255f => Some(unsafe { transmute(0x30dfu32) }),
0x2560 => Some(unsafe { transmute(0x30e0u32) }),
0x2561 => Some(unsafe { transmute(0x30e1u32) }),
0x2562 => Some(unsafe { transmute(0x30e2u32) }),
0x2563 => Some(unsafe { transmute(0x30e3u32) }),
0x2564 => Some(unsafe { transmute(0x30e4u32) }),
0x2565 => Some(unsafe { transmute(0x30e5u32) }),
0x2566 => Some(unsafe { transmute(0x30e6u32) }),
0x2567 => Some(unsafe { transmute(0x30e7u32) }),
0x2568 => Some(unsafe { transmute(0x30e8u32) }),
0x2569 => Some(unsafe { transmute(0x30e9u32) }),
0x256a => Some(unsafe { transmute(0x30eau32) }),
0x256b => Some(unsafe { transmute(0x30ebu32) }),
0x256c => Some(unsafe { transmute(0x30ecu32) }),
0x256d => Some(unsafe { transmute(0x30edu32) }),
0x256e => Some(unsafe { transmute(0x30eeu32) }),
0x256f => Some(unsafe { transmute(0x30efu32) }),
0x2570 => Some(unsafe { transmute(0x30f0u32) }),
0x2571 => Some(unsafe { transmute(0x30f1u32) }),
0x2572 => Some(unsafe { transmute(0x30f2u32) }),
0x2573 => Some(unsafe { transmute(0x30f3u32) }),
0x2574 => Some(unsafe { transmute(0x30f4u32) }),
0x2575 => Some(unsafe { transmute(0x30f5u32) }),
0x2576 => Some(unsafe { transmute(0x30f6u32) }),
0x2621 => Some(unsafe { transmute(0x0391u32) }),
0x2622 => Some(unsafe { transmute(0x0392u32) }),
0x2623 => Some(unsafe { transmute(0x0393u32) }),
0x2624 => Some(unsafe { transmute(0x0394u32) }),
0x2625 => Some(unsafe { transmute(0x0395u32) }),
0x2626 => Some(unsafe { transmute(0x0396u32) }),
0x2627 => Some(unsafe { transmute(0x0397u32) }),
0x2628 => Some(unsafe { transmute(0x0398u32) }),
0x2629 => Some(unsafe { transmute(0x0399u32) }),
0x262a => Some(unsafe { transmute(0x039au32) }),
0x262b => Some(unsafe { transmute(0x039bu32) }),
0x262c => Some(unsafe { transmute(0x039cu32) }),
0x262d => Some(unsafe { transmute(0x039du32) }),
0x262e => Some(unsafe { transmute(0x039eu32) }),
0x262f => Some(unsafe { transmute(0x039fu32) }),
0x2630 => Some(unsafe { transmute(0x03a0u32) }),
0x2631 => Some(unsafe { transmute(0x03a1u32) }),
0x2632 => Some(unsafe { transmute(0x03a3u32) }),
0x2633 => Some(unsafe { transmute(0x03a4u32) }),
0x2634 => Some(unsafe { transmute(0x03a5u32) }),
0x2635 => Some(unsafe { transmute(0x03a6u32) }),
0x2636 => Some(unsafe { transmute(0x03a7u32) }),
0x2637 => Some(unsafe { transmute(0x03a8u32) }),
0x2638 => Some(unsafe { transmute(0x03a9u32) }),
0x2641 => Some(unsafe { transmute(0x03b1u32) }),
0x2642 => Some(unsafe { transmute(0x03b2u32) }),
0x2643 => Some(unsafe { transmute(0x03b3u32) }),
0x2644 => Some(unsafe { transmute(0x03b4u32) }),
0x2645 => Some(unsafe { transmute(0x03b5u32) }),
0x2646 => Some(unsafe { transmute(0x03b6u32) }),
0x2647 => Some(unsafe { transmute(0x03b7u32) }),
0x2648 => Some(unsafe { transmute(0x03b8u32) }),
0x2649 => Some(unsafe { transmute(0x03b9u32) }),
0x264a => Some(unsafe { transmute(0x03bau32) }),
0x264b => Some(unsafe { transmute(0x03bbu32) }),
0x264c => Some(unsafe { transmute(0x03bcu32) }),
0x264d => Some(unsafe { transmute(0x03bdu32) }),
0x264e => Some(unsafe { transmute(0x03beu32) }),
0x264f => Some(unsafe { transmute(0x03bfu32) }),
0x2650 => Some(unsafe { transmute(0x03c0u32) }),
0x2651 => Some(unsafe { transmute(0x03c1u32) }),
0x2652 => Some(unsafe { transmute(0x03c3u32) }),
0x2653 => Some(unsafe { transmute(0x03c4u32) }),
0x2654 => Some(unsafe { transmute(0x03c5u32) }),
0x2655 => Some(unsafe { transmute(0x03c6u32) }),
0x2656 => Some(unsafe { transmute(0x03c7u32) }),
0x2657 => Some(unsafe { transmute(0x03c8u32) }),
0x2658 => Some(unsafe { transmute(0x03c9u32) }),
0x2721 => Some(unsafe { transmute(0x0410u32) }),
0x2722 => Some(unsafe { transmute(0x0411u32) }),
0x2723 => Some(unsafe { transmute(0x0412u32) }),
0x2724 => Some(unsafe { transmute(0x0413u32) }),
0x2725 => Some(unsafe { transmute(0x0414u32) }),
0x2726 => Some(unsafe { transmute(0x0415u32) }),
0x2727 => Some(unsafe { transmute(0x0401u32) }),
0x2728 => Some(unsafe { transmute(0x0416u32) }),
0x2729 => Some(unsafe { transmute(0x0417u32) }),
0x272a => Some(unsafe { transmute(0x0418u32) }),
0x272b => Some(unsafe { transmute(0x0419u32) }),
0x272c => Some(unsafe { transmute(0x041au32) }),
0x272d => Some(unsafe { transmute(0x041bu32) }),
0x272e => Some(unsafe { transmute(0x041cu32) }),
0x272f => Some(unsafe { transmute(0x041du32) }),
0x2730 => Some(unsafe { transmute(0x041eu32) }),
0x2731 => Some(unsafe { transmute(0x041fu32) }),
0x2732 => Some(unsafe { transmute(0x0420u32) }),
0x2733 => Some(unsafe { transmute(0x0421u32) }),
0x2734 => Some(unsafe { transmute(0x0422u32) }),
0x2735 => Some(unsafe { transmute(0x0423u32) }),
0x2736 => Some(unsafe { transmute(0x0424u32) }),
0x2737 => Some(unsafe { transmute(0x0425u32) }),
0x2738 => Some(unsafe { transmute(0x0426u32) }),
0x2739 => Some(unsafe { transmute(0x0427u32) }),
0x273a => Some(unsafe { transmute(0x0428u32) }),
0x273b => Some(unsafe { transmute(0x0429u32) }),
0x273c => Some(unsafe { transmute(0x042au32) }),
0x273d => Some(unsafe { transmute(0x042bu32) }),
0x273e => Some(unsafe { transmute(0x042cu32) }),
0x273f => Some(unsafe { transmute(0x042du32) }),
0x2740 => Some(unsafe { transmute(0x042eu32) }),
0x2741 => Some(unsafe { transmute(0x042fu32) }),
0x2751 => Some(unsafe { transmute(0x0430u32) }),
0x2752 => Some(unsafe { transmute(0x0431u32) }),
0x2753 => Some(unsafe { transmute(0x0432u32) }),
0x2754 => Some(unsafe { transmute(0x0433u32) }),
0x2755 => Some(unsafe { transmute(0x0434u32) }),
0x2756 => Some(unsafe { transmute(0x0435u32) }),
0x2757 => Some(unsafe { transmute(0x0451u32) }),
0x2758 => Some(unsafe { transmute(0x0436u32) }),
0x2759 => Some(unsafe { transmute(0x0437u32) }),
0x275a => Some(unsafe { transmute(0x0438u32) }),
0x275b => Some(unsafe { transmute(0x0439u32) }),
0x275c => Some(unsafe { transmute(0x043au32) }),
0x275d => Some(unsafe { transmute(0x043bu32) }),
0x275e => Some(unsafe { transmute(0x043cu32) }),
0x275f => Some(unsafe { transmute(0x043du32) }),
0x2760 => Some(unsafe { transmute(0x043eu32) }),
0x2761 => Some(unsafe { transmute(0x043fu32) }),
0x2762 => Some(unsafe { transmute(0x0440u32) }),
0x2763 => Some(unsafe { transmute(0x0441u32) }),
0x2764 => Some(unsafe { transmute(0x0442u32) }),
0x2765 => Some(unsafe { transmute(0x0443u32) }),
0x2766 => Some(unsafe { transmute(0x0444u32) }),
0x2767 => Some(unsafe { transmute(0x0445u32) }),
0x2768 => Some(unsafe { transmute(0x0446u32) }),
0x2769 => Some(unsafe { transmute(0x0447u32) }),
0x276a => Some(unsafe { transmute(0x0448u32) }),
0x276b => Some(unsafe { transmute(0x0449u32) }),
0x276c => Some(unsafe { transmute(0x044au32) }),
0x276d => Some(unsafe { transmute(0x044bu32) }),
0x276e => Some(unsafe { transmute(0x044cu32) }),
0x276f => Some(unsafe { transmute(0x044du32) }),
0x2770 => Some(unsafe { transmute(0x044eu32) }),
0x2771 => Some(unsafe { transmute(0x044fu32) }),
0x2821 => Some(unsafe { transmute(0x2500u32) }),
0x2822 => Some(unsafe { transmute(0x2502u32) }),
0x2823 => Some(unsafe { transmute(0x250cu32) }),
0x2824 => Some(unsafe { transmute(0x2510u32) }),
0x2825 => Some(unsafe { transmute(0x2518u32) }),
0x2826 => Some(unsafe { transmute(0x2514u32) }),
0x2827 => Some(unsafe { transmute(0x251cu32) }),
0x2828 => Some(unsafe { transmute(0x252cu32) }),
0x2829 => Some(unsafe { transmute(0x2524u32) }),
0x282a => Some(unsafe { transmute(0x2534u32) }),
0x282b => Some(unsafe { transmute(0x253cu32) }),
0x282c => Some(unsafe { transmute(0x2501u32) }),
0x282d => Some(unsafe { transmute(0x2503u32) }),
0x282e => Some(unsafe { transmute(0x250fu32) }),
0x282f => Some(unsafe { transmute(0x2513u32) }),
0x2830 => Some(unsafe { transmute(0x251bu32) }),
0x2831 => Some(unsafe { transmute(0x2517u32) }),
0x2832 => Some(unsafe { transmute(0x2523u32) }),
0x2833 => Some(unsafe { transmute(0x2533u32) }),
0x2834 => Some(unsafe { transmute(0x252bu32) }),
0x2835 => Some(unsafe { transmute(0x253bu32) }),
0x2836 => Some(unsafe { transmute(0x254bu32) }),
0x2837 => Some(unsafe { transmute(0x2520u32) }),
0x2838 => Some(unsafe { transmute(0x252fu32) }),
0x2839 => Some(unsafe { transmute(0x2528u32) }),
0x283a => Some(unsafe { transmute(0x2537u32) }),
0x283b => Some(unsafe { transmute(0x253fu32) }),
0x283c => Some(unsafe { transmute(0x251du32) }),
0x283d => Some(unsafe { transmute(0x2530u32) }),
0x283e => Some(unsafe { transmute(0x2525u32) }),
0x283f => Some(unsafe { transmute(0x2538u32) }),
0x2840 => Some(unsafe { transmute(0x2542u32) }),
0x3021 => Some(unsafe { transmute(0x4e9cu32) }),
0x3022 => Some(unsafe { transmute(0x5516u32) }),
0x3023 => Some(unsafe { transmute(0x5a03u32) }),
0x3024 => Some(unsafe { transmute(0x963fu32) }),
0x3025 => Some(unsafe { transmute(0x54c0u32) }),
0x3026 => Some(unsafe { transmute(0x611bu32) }),
0x3027 => Some(unsafe { transmute(0x6328u32) }),
0x3028 => Some(unsafe { transmute(0x59f6u32) }),
0x3029 => Some(unsafe { transmute(0x9022u32) }),
0x302a => Some(unsafe { transmute(0x8475u32) }),
0x302b => Some(unsafe { transmute(0x831cu32) }),
0x302c => Some(unsafe { transmute(0x7a50u32) }),
0x302d => Some(unsafe { transmute(0x60aau32) }),
0x302e => Some(unsafe { transmute(0x63e1u32) }),
0x302f => Some(unsafe { transmute(0x6e25u32) }),
0x3030 => Some(unsafe { transmute(0x65edu32) }),
0x3031 => Some(unsafe { transmute(0x8466u32) }),
0x3032 => Some(unsafe { transmute(0x82a6u32) }),
0x3033 => Some(unsafe { transmute(0x9bf5u32) }),
0x3034 => Some(unsafe { transmute(0x6893u32) }),
0x3035 => Some(unsafe { transmute(0x5727u32) }),
0x3036 => Some(unsafe { transmute(0x65a1u32) }),
0x3037 => Some(unsafe { transmute(0x6271u32) }),
0x3038 => Some(unsafe { transmute(0x5b9bu32) }),
0x3039 => Some(unsafe { transmute(0x59d0u32) }),
0x303a => Some(unsafe { transmute(0x867bu32) }),
0x303b => Some(unsafe { transmute(0x98f4u32) }),
0x303c => Some(unsafe { transmute(0x7d62u32) }),
0x303d => Some(unsafe { transmute(0x7dbeu32) }),
0x303e => Some(unsafe { transmute(0x9b8eu32) }),
0x303f => Some(unsafe { transmute(0x6216u32) }),
0x3040 => Some(unsafe { transmute(0x7c9fu32) }),
0x3041 => Some(unsafe { transmute(0x88b7u32) }),
0x3042 => Some(unsafe { transmute(0x5b89u32) }),
0x3043 => Some(unsafe { transmute(0x5eb5u32) }),
0x3044 => Some(unsafe { transmute(0x6309u32) }),
0x3045 => Some(unsafe { transmute(0x6697u32) }),
0x3046 => Some(unsafe { transmute(0x6848u32) }),
0x3047 => Some(unsafe { transmute(0x95c7u32) }),
0x3048 => Some(unsafe { transmute(0x978du32) }),
0x3049 => Some(unsafe { transmute(0x674fu32) }),
0x304a => Some(unsafe { transmute(0x4ee5u32) }),
0x304b => Some(unsafe { transmute(0x4f0au32) }),
0x304c => Some(unsafe { transmute(0x4f4du32) }),
0x304d => Some(unsafe { transmute(0x4f9du32) }),
0x304e => Some(unsafe { transmute(0x5049u32) }),
0x304f => Some(unsafe { transmute(0x56f2u32) }),
0x3050 => Some(unsafe { transmute(0x5937u32) }),
0x3051 => Some(unsafe { transmute(0x59d4u32) }),
0x3052 => Some(unsafe { transmute(0x5a01u32) }),
0x3053 => Some(unsafe { transmute(0x5c09u32) }),
0x3054 => Some(unsafe { transmute(0x60dfu32) }),
0x3055 => Some(unsafe { transmute(0x610fu32) }),
0x3056 => Some(unsafe { transmute(0x6170u32) }),
0x3057 => Some(unsafe { transmute(0x6613u32) }),
0x3058 => Some(unsafe { transmute(0x6905u32) }),
0x3059 => Some(unsafe { transmute(0x70bau32) }),
0x305a => Some(unsafe { transmute(0x754fu32) }),
0x305b => Some(unsafe { transmute(0x7570u32) }),
0x305c => Some(unsafe { transmute(0x79fbu32) }),
0x305d => Some(unsafe { transmute(0x7dadu32) }),
0x305e => Some(unsafe { transmute(0x7defu32) }),
0x305f => Some(unsafe { transmute(0x80c3u32) }),
0x3060 => Some(unsafe { transmute(0x840eu32) }),
0x3061 => Some(unsafe { transmute(0x8863u32) }),
0x3062 => Some(unsafe { transmute(0x8b02u32) }),
0x3063 => Some(unsafe { transmute(0x9055u32) }),
0x3064 => Some(unsafe { transmute(0x907au32) }),
0x3065 => Some(unsafe { transmute(0x533bu32) }),
0x3066 => Some(unsafe { transmute(0x4e95u32) }),
0x3067 => Some(unsafe { transmute(0x4ea5u32) }),
0x3068 => Some(unsafe { transmute(0x57dfu32) }),
0x3069 => Some(unsafe { transmute(0x80b2u32) }),
0x306a => Some(unsafe { transmute(0x90c1u32) }),
0x306b => Some(unsafe { transmute(0x78efu32) }),
0x306c => Some(unsafe { transmute(0x4e00u32) }),
0x306d => Some(unsafe { transmute(0x58f1u32) }),
0x306e => Some(unsafe { transmute(0x6ea2u32) }),
0x306f => Some(unsafe { transmute(0x9038u32) }),
0x3070 => Some(unsafe { transmute(0x7a32u32) }),
0x3071 => Some(unsafe { transmute(0x8328u32) }),
0x3072 => Some(unsafe { transmute(0x828bu32) }),
0x3073 => Some(unsafe { transmute(0x9c2fu32) }),
0x3074 => Some(unsafe { transmute(0x5141u32) }),
0x3075 => Some(unsafe { transmute(0x5370u32) }),
0x3076 => Some(unsafe { transmute(0x54bdu32) }),
0x3077 => Some(unsafe { transmute(0x54e1u32) }),
0x3078 => Some(unsafe { transmute(0x56e0u32) }),
0x3079 => Some(unsafe { transmute(0x59fbu32) }),
0x307a => Some(unsafe { transmute(0x5f15u32) }),
0x307b => Some(unsafe { transmute(0x98f2u32) }),
0x307c => Some(unsafe { transmute(0x6debu32) }),
0x307d => Some(unsafe { transmute(0x80e4u32) }),
0x307e => Some(unsafe { transmute(0x852du32) }),
0x3121 => Some(unsafe { transmute(0x9662u32) }),
0x3122 => Some(unsafe { transmute(0x9670u32) }),
0x3123 => Some(unsafe { transmute(0x96a0u32) }),
0x3124 => Some(unsafe { transmute(0x97fbu32) }),
0x3125 => Some(unsafe { transmute(0x540bu32) }),
0x3126 => Some(unsafe { transmute(0x53f3u32) }),
0x3127 => Some(unsafe { transmute(0x5b87u32) }),
0x3128 => Some(unsafe { transmute(0x70cfu32) }),
0x3129 => Some(unsafe { transmute(0x7fbdu32) }),
0x312a => Some(unsafe { transmute(0x8fc2u32) }),
0x312b => Some(unsafe { transmute(0x96e8u32) }),
0x312c => Some(unsafe { transmute(0x536fu32) }),
0x312d => Some(unsafe { transmute(0x9d5cu32) }),
0x312e => Some(unsafe { transmute(0x7abau32) }),
0x312f => Some(unsafe { transmute(0x4e11u32) }),
0x3130 => Some(unsafe { transmute(0x7893u32) }),
0x3131 => Some(unsafe { transmute(0x81fcu32) }),
0x3132 => Some(unsafe { transmute(0x6e26u32) }),
0x3133 => Some(unsafe { transmute(0x5618u32) }),
0x3134 => Some(unsafe { transmute(0x5504u32) }),
0x3135 => Some(unsafe { transmute(0x6b1du32) }),
0x3136 => Some(unsafe { transmute(0x851au32) }),
0x3137 => Some(unsafe { transmute(0x9c3bu32) }),
0x3138 => Some(unsafe { transmute(0x59e5u32) }),
0x3139 => Some(unsafe { transmute(0x53a9u32) }),
0x313a => Some(unsafe { transmute(0x6d66u32) }),
0x313b => Some(unsafe { transmute(0x74dcu32) }),
0x313c => Some(unsafe { transmute(0x958fu32) }),
0x313d => Some(unsafe { transmute(0x5642u32) }),
0x313e => Some(unsafe { transmute(0x4e91u32) }),
0x313f => Some(unsafe { transmute(0x904bu32) }),
0x3140 => Some(unsafe { transmute(0x96f2u32) }),
0x3141 => Some(unsafe { transmute(0x834fu32) }),
0x3142 => Some(unsafe { transmute(0x990cu32) }),
0x3143 => Some(unsafe { transmute(0x53e1u32) }),
0x3144 => Some(unsafe { transmute(0x55b6u32) }),
0x3145 => Some(unsafe { transmute(0x5b30u32) }),
0x3146 => Some(unsafe { transmute(0x5f71u32) }),
0x3147 => Some(unsafe { transmute(0x6620u32) }),
0x3148 => Some(unsafe { transmute(0x66f3u32) }),
0x3149 => Some(unsafe { transmute(0x6804u32) }),
0x314a => Some(unsafe { transmute(0x6c38u32) }),
0x314b => Some(unsafe { transmute(0x6cf3u32) }),
0x314c => Some(unsafe { transmute(0x6d29u32) }),
0x314d => Some(unsafe { transmute(0x745bu32) }),
0x314e => Some(unsafe { transmute(0x76c8u32) }),
0x314f => Some(unsafe { transmute(0x7a4eu32) }),
0x3150 => Some(unsafe { transmute(0x9834u32) }),
0x3151 => Some(unsafe { transmute(0x82f1u32) }),
0x3152 => Some(unsafe { transmute(0x885bu32) }),
0x3153 => Some(unsafe { transmute(0x8a60u32) }),
0x3154 => Some(unsafe { transmute(0x92edu32) }),
0x3155 => Some(unsafe { transmute(0x6db2u32) }),
0x3156 => Some(unsafe { transmute(0x75abu32) }),
0x3157 => Some(unsafe { transmute(0x76cau32) }),
0x3158 => Some(unsafe { transmute(0x99c5u32) }),
0x3159 => Some(unsafe { transmute(0x60a6u32) }),
0x315a => Some(unsafe { transmute(0x8b01u32) }),
0x315b => Some(unsafe { transmute(0x8d8au32) }),
0x315c => Some(unsafe { transmute(0x95b2u32) }),
0x315d => Some(unsafe { transmute(0x698eu32) }),
0x315e => Some(unsafe { transmute(0x53adu32) }),
0x315f => Some(unsafe { transmute(0x5186u32) }),
0x3160 => Some(unsafe { transmute(0x5712u32) }),
0x3161 => Some(unsafe { transmute(0x5830u32) }),
0x3162 => Some(unsafe { transmute(0x5944u32) }),
0x3163 => Some(unsafe { transmute(0x5bb4u32) }),
0x3164 => Some(unsafe { transmute(0x5ef6u32) }),
0x3165 => Some(unsafe { transmute(0x6028u32) }),
0x3166 => Some(unsafe { transmute(0x63a9u32) }),
0x3167 => Some(unsafe { transmute(0x63f4u32) }),
0x3168 => Some(unsafe { transmute(0x6cbfu32) }),
0x3169 => Some(unsafe { transmute(0x6f14u32) }),
0x316a => Some(unsafe { transmute(0x708eu32) }),
0x316b => Some(unsafe { transmute(0x7114u32) }),
0x316c => Some(unsafe { transmute(0x7159u32) }),
0x316d => Some(unsafe { transmute(0x71d5u32) }),
0x316e => Some(unsafe { transmute(0x733fu32) }),
0x316f => Some(unsafe { transmute(0x7e01u32) }),
0x3170 => Some(unsafe { transmute(0x8276u32) }),
0x3171 => Some(unsafe { transmute(0x82d1u32) }),
0x3172 => Some(unsafe { transmute(0x8597u32) }),
0x3173 => Some(unsafe { transmute(0x9060u32) }),
0x3174 => Some(unsafe { transmute(0x925bu32) }),
0x3175 => Some(unsafe { transmute(0x9d1bu32) }),
0x3176 => Some(unsafe { transmute(0x5869u32) }),
0x3177 => Some(unsafe { transmute(0x65bcu32) }),
0x3178 => Some(unsafe { transmute(0x6c5au32) }),
0x3179 => Some(unsafe { transmute(0x7525u32) }),
0x317a => Some(unsafe { transmute(0x51f9u32) }),
0x317b => Some(unsafe { transmute(0x592eu32) }),
0x317c => Some(unsafe { transmute(0x5965u32) }),
0x317d => Some(unsafe { transmute(0x5f80u32) }),
0x317e => Some(unsafe { transmute(0x5fdcu32) }),
0x3221 => Some(unsafe { transmute(0x62bcu32) }),
0x3222 => Some(unsafe { transmute(0x65fau32) }),
0x3223 => Some(unsafe { transmute(0x6a2au32) }),
0x3224 => Some(unsafe { transmute(0x6b27u32) }),
0x3225 => Some(unsafe { transmute(0x6bb4u32) }),
0x3226 => Some(unsafe { transmute(0x738bu32) }),
0x3227 => Some(unsafe { transmute(0x7fc1u32) }),
0x3228 => Some(unsafe { transmute(0x8956u32) }),
0x3229 => Some(unsafe { transmute(0x9d2cu32) }),
0x322a => Some(unsafe { transmute(0x9d0eu32) }),
0x322b => Some(unsafe { transmute(0x9ec4u32) }),
0x322c => Some(unsafe { transmute(0x5ca1u32) }),
0x322d => Some(unsafe { transmute(0x6c96u32) }),
0x322e => Some(unsafe { transmute(0x837bu32) }),
0x322f => Some(unsafe { transmute(0x5104u32) }),
0x3230 => Some(unsafe { transmute(0x5c4bu32) }),
0x3231 => Some(unsafe { transmute(0x61b6u32) }),
0x3232 => Some(unsafe { transmute(0x81c6u32) }),
0x3233 => Some(unsafe { transmute(0x6876u32) }),
0x3234 => Some(unsafe { transmute(0x7261u32) }),
0x3235 => Some(unsafe { transmute(0x4e59u32) }),
0x3236 => Some(unsafe { transmute(0x4ffau32) }),
0x3237 => Some(unsafe { transmute(0x5378u32) }),
0x3238 => Some(unsafe { transmute(0x6069u32) }),
0x3239 => Some(unsafe { transmute(0x6e29u32) }),
0x323a => Some(unsafe { transmute(0x7a4fu32) }),
0x323b => Some(unsafe { transmute(0x97f3u32) }),
0x323c => Some(unsafe { transmute(0x4e0bu32) }),
0x323d => Some(unsafe { transmute(0x5316u32) }),
0x323e => Some(unsafe { transmute(0x4eeeu32) }),
0x323f => Some(unsafe { transmute(0x4f55u32) }),
0x3240 => Some(unsafe { transmute(0x4f3du32) }),
0x3241 => Some(unsafe { transmute(0x4fa1u32) }),
0x3242 => Some(unsafe { transmute(0x4f73u32) }),
0x3243 => Some(unsafe { transmute(0x52a0u32) }),
0x3244 => Some(unsafe { transmute(0x53efu32) }),
0x3245 => Some(unsafe { transmute(0x5609u32) }),
0x3246 => Some(unsafe { transmute(0x590fu32) }),
0x3247 => Some(unsafe { transmute(0x5ac1u32) }),
0x3248 => Some(unsafe { transmute(0x5bb6u32) }),
0x3249 => Some(unsafe { transmute(0x5be1u32) }),
0x324a => Some(unsafe { transmute(0x79d1u32) }),
0x324b => Some(unsafe { transmute(0x6687u32) }),
0x324c => Some(unsafe { transmute(0x679cu32) }),
0x324d => Some(unsafe { transmute(0x67b6u32) }),
0x324e => Some(unsafe { transmute(0x6b4cu32) }),
0x324f => Some(unsafe { transmute(0x6cb3u32) }),
0x3250 => Some(unsafe { transmute(0x706bu32) }),
0x3251 => Some(unsafe { transmute(0x73c2u32) }),
0x3252 => Some(unsafe { transmute(0x798du32) }),
0x3253 => Some(unsafe { transmute(0x79beu32) }),
0x3254 => Some(unsafe { transmute(0x7a3cu32) }),
0x3255 => Some(unsafe { transmute(0x7b87u32) }),
0x3256 => Some(unsafe { transmute(0x82b1u32) }),
0x3257 => Some(unsafe { transmute(0x82dbu32) }),
0x3258 => Some(unsafe { transmute(0x8304u32) }),
0x3259 => Some(unsafe { transmute(0x8377u32) }),
0x325a => Some(unsafe { transmute(0x83efu32) }),
0x325b => Some(unsafe { transmute(0x83d3u32) }),
0x325c => Some(unsafe { transmute(0x8766u32) }),
0x325d => Some(unsafe { transmute(0x8ab2u32) }),
0x325e => Some(unsafe { transmute(0x5629u32) }),
0x325f => Some(unsafe { transmute(0x8ca8u32) }),
0x3260 => Some(unsafe { transmute(0x8fe6u32) }),
0x3261 => Some(unsafe { transmute(0x904eu32) }),
0x3262 => Some(unsafe { transmute(0x971eu32) }),
0x3263 => Some(unsafe { transmute(0x868au32) }),
0x3264 => Some(unsafe { transmute(0x4fc4u32) }),
0x3265 => Some(unsafe { transmute(0x5ce8u32) }),
0x3266 => Some(unsafe { transmute(0x6211u32) }),
0x3267 => Some(unsafe { transmute(0x7259u32) }),
0x3268 => Some(unsafe { transmute(0x753bu32) }),
0x3269 => Some(unsafe { transmute(0x81e5u32) }),
0x326a => Some(unsafe { transmute(0x82bdu32) }),
0x326b => Some(unsafe { transmute(0x86feu32) }),
0x326c => Some(unsafe { transmute(0x8cc0u32) }),
0x326d => Some(unsafe { transmute(0x96c5u32) }),
0x326e => Some(unsafe { transmute(0x9913u32) }),
0x326f => Some(unsafe { transmute(0x99d5u32) }),
0x3270 => Some(unsafe { transmute(0x4ecbu32) }),
0x3271 => Some(unsafe { transmute(0x4f1au32) }),
0x3272 => Some(unsafe { transmute(0x89e3u32) }),
0x3273 => Some(unsafe { transmute(0x56deu32) }),
0x3274 => Some(unsafe { transmute(0x584au32) }),
0x3275 => Some(unsafe { transmute(0x58cau32) }),
0x3276 => Some(unsafe { transmute(0x5efbu32) }),
0x3277 => Some(unsafe { transmute(0x5febu32) }),
0x3278 => Some(unsafe { transmute(0x602au32) }),
0x3279 => Some(unsafe { transmute(0x6094u32) }),
0x327a => Some(unsafe { transmute(0x6062u32) }),
0x327b => Some(unsafe { transmute(0x61d0u32) }),
0x327c => Some(unsafe { transmute(0x6212u32) }),
0x327d => Some(unsafe { transmute(0x62d0u32) }),
0x327e => Some(unsafe { transmute(0x6539u32) }),
0x3321 => Some(unsafe { transmute(0x9b41u32) }),
0x3322 => Some(unsafe { transmute(0x6666u32) }),
0x3323 => Some(unsafe { transmute(0x68b0u32) }),
0x3324 => Some(unsafe { transmute(0x6d77u32) }),
0x3325 => Some(unsafe { transmute(0x7070u32) }),
0x3326 => Some(unsafe { transmute(0x754cu32) }),
0x3327 => Some(unsafe { transmute(0x7686u32) }),
0x3328 => Some(unsafe { transmute(0x7d75u32) }),
0x3329 => Some(unsafe { transmute(0x82a5u32) }),
0x332a => Some(unsafe { transmute(0x87f9u32) }),
0x332b => Some(unsafe { transmute(0x958bu32) }),
0x332c => Some(unsafe { transmute(0x968eu32) }),
0x332d => Some(unsafe { transmute(0x8c9du32) }),
0x332e => Some(unsafe { transmute(0x51f1u32) }),
0x332f => Some(unsafe { transmute(0x52beu32) }),
0x3330 => Some(unsafe { transmute(0x5916u32) }),
0x3331 => Some(unsafe { transmute(0x54b3u32) }),
0x3332 => Some(unsafe { transmute(0x5bb3u32) }),
0x3333 => Some(unsafe { transmute(0x5d16u32) }),
0x3334 => Some(unsafe { transmute(0x6168u32) }),
0x3335 => Some(unsafe { transmute(0x6982u32) }),
0x3336 => Some(unsafe { transmute(0x6dafu32) }),
0x3337 => Some(unsafe { transmute(0x788du32) }),
0x3338 => Some(unsafe { transmute(0x84cbu32) }),
0x3339 => Some(unsafe { transmute(0x8857u32) }),
0x333a => Some(unsafe { transmute(0x8a72u32) }),
0x333b => Some(unsafe { transmute(0x93a7u32) }),
0x333c => Some(unsafe { transmute(0x9ab8u32) }),
0x333d => Some(unsafe { transmute(0x6d6cu32) }),
0x333e => Some(unsafe { transmute(0x99a8u32) }),
0x333f => Some(unsafe { transmute(0x86d9u32) }),
0x3340 => Some(unsafe { transmute(0x57a3u32) }),
0x3341 => Some(unsafe { transmute(0x67ffu32) }),
0x3342 => Some(unsafe { transmute(0x86ceu32) }),
0x3343 => Some(unsafe { transmute(0x920eu32) }),
0x3344 => Some(unsafe { transmute(0x5283u32) }),
0x3345 => Some(unsafe { transmute(0x5687u32) }),
0x3346 => Some(unsafe { transmute(0x5404u32) }),
0x3347 => Some(unsafe { transmute(0x5ed3u32) }),
0x3348 => Some(unsafe { transmute(0x62e1u32) }),
0x3349 => Some(unsafe { transmute(0x64b9u32) }),
0x334a => Some(unsafe { transmute(0x683cu32) }),
0x334b => Some(unsafe { transmute(0x6838u32) }),
0x334c => Some(unsafe { transmute(0x6bbbu32) }),
0x334d => Some(unsafe { transmute(0x7372u32) }),
0x334e => Some(unsafe { transmute(0x78bau32) }),
0x334f => Some(unsafe { transmute(0x7a6bu32) }),
0x3350 => Some(unsafe { transmute(0x899au32) }),
0x3351 => Some(unsafe { transmute(0x89d2u32) }),
0x3352 => Some(unsafe { transmute(0x8d6bu32) }),
0x3353 => Some(unsafe { transmute(0x8f03u32) }),
0x3354 => Some(unsafe { transmute(0x90edu32) }),
0x3355 => Some(unsafe { transmute(0x95a3u32) }),
0x3356 => Some(unsafe { transmute(0x9694u32) }),
0x3357 => Some(unsafe { transmute(0x9769u32) }),
0x3358 => Some(unsafe { transmute(0x5b66u32) }),
0x3359 => Some(unsafe { transmute(0x5cb3u32) }),
0x335a => Some(unsafe { transmute(0x697du32) }),
0x335b => Some(unsafe { transmute(0x984du32) }),
0x335c => Some(unsafe { transmute(0x984eu32) }),
0x335d => Some(unsafe { transmute(0x639bu32) }),
0x335e => Some(unsafe { transmute(0x7b20u32) }),
0x335f => Some(unsafe { transmute(0x6a2bu32) }),
0x3360 => Some(unsafe { transmute(0x6a7fu32) }),
0x3361 => Some(unsafe { transmute(0x68b6u32) }),
0x3362 => Some(unsafe { transmute(0x9c0du32) }),
0x3363 => Some(unsafe { transmute(0x6f5fu32) }),
0x3364 => Some(unsafe { transmute(0x5272u32) }),
0x3365 => Some(unsafe { transmute(0x559du32) }),
0x3366 => Some(unsafe { transmute(0x6070u32) }),
0x3367 => Some(unsafe { transmute(0x62ecu32) }),
0x3368 => Some(unsafe { transmute(0x6d3bu32) }),
0x3369 => Some(unsafe { transmute(0x6e07u32) }),
0x336a => Some(unsafe { transmute(0x6ed1u32) }),
0x336b => Some(unsafe { transmute(0x845bu32) }),
0x336c => Some(unsafe { transmute(0x8910u32) }),
0x336d => Some(unsafe { transmute(0x8f44u32) }),
0x336e => Some(unsafe { transmute(0x4e14u32) }),
0x336f => Some(unsafe { transmute(0x9c39u32) }),
0x3370 => Some(unsafe { transmute(0x53f6u32) }),
0x3371 => Some(unsafe { transmute(0x691bu32) }),
0x3372 => Some(unsafe { transmute(0x6a3au32) }),
0x3373 => Some(unsafe { transmute(0x9784u32) }),
0x3374 => Some(unsafe { transmute(0x682au32) }),
0x3375 => Some(unsafe { transmute(0x515cu32) }),
0x3376 => Some(unsafe { transmute(0x7ac3u32) }),
0x3377 => Some(unsafe { transmute(0x84b2u32) }),
0x3378 => Some(unsafe { transmute(0x91dcu32) }),
0x3379 => Some(unsafe { transmute(0x938cu32) }),
0x337a => Some(unsafe { transmute(0x565bu32) }),
0x337b => Some(unsafe { transmute(0x9d28u32) }),
0x337c => Some(unsafe { transmute(0x6822u32) }),
0x337d => Some(unsafe { transmute(0x8305u32) }),
0x337e => Some(unsafe { transmute(0x8431u32) }),
0x3421 => Some(unsafe { transmute(0x7ca5u32) }),
0x3422 => Some(unsafe { transmute(0x5208u32) }),
0x3423 => Some(unsafe { transmute(0x82c5u32) }),
0x3424 => Some(unsafe { transmute(0x74e6u32) }),
0x3425 => Some(unsafe { transmute(0x4e7eu32) }),
0x3426 => Some(unsafe { transmute(0x4f83u32) }),
0x3427 => Some(unsafe { transmute(0x51a0u32) }),
0x3428 => Some(unsafe { transmute(0x5bd2u32) }),
0x3429 => Some(unsafe { transmute(0x520au32) }),
0x342a => Some(unsafe { transmute(0x52d8u32) }),
0x342b => Some(unsafe { transmute(0x52e7u32) }),
0x342c => Some(unsafe { transmute(0x5dfbu32) }),
0x342d => Some(unsafe { transmute(0x559au32) }),
0x342e => Some(unsafe { transmute(0x582au32) }),
0x342f => Some(unsafe { transmute(0x59e6u32) }),
0x3430 => Some(unsafe { transmute(0x5b8cu32) }),
0x3431 => Some(unsafe { transmute(0x5b98u32) }),
0x3432 => Some(unsafe { transmute(0x5bdbu32) }),
0x3433 => Some(unsafe { transmute(0x5e72u32) }),
0x3434 => Some(unsafe { transmute(0x5e79u32) }),
0x3435 => Some(unsafe { transmute(0x60a3u32) }),
0x3436 => Some(unsafe { transmute(0x611fu32) }),
0x3437 => Some(unsafe { transmute(0x6163u32) }),
0x3438 => Some(unsafe { transmute(0x61beu32) }),
0x3439 => Some(unsafe { transmute(0x63dbu32) }),
0x343a => Some(unsafe { transmute(0x6562u32) }),
0x343b => Some(unsafe { transmute(0x67d1u32) }),
0x343c => Some(unsafe { transmute(0x6853u32) }),
0x343d => Some(unsafe { transmute(0x68fau32) }),
0x343e => Some(unsafe { transmute(0x6b3eu32) }),
0x343f => Some(unsafe { transmute(0x6b53u32) }),
0x3440 => Some(unsafe { transmute(0x6c57u32) }),
0x3441 => Some(unsafe { transmute(0x6f22u32) }),
0x3442 => Some(unsafe { transmute(0x6f97u32) }),
0x3443 => Some(unsafe { transmute(0x6f45u32) }),
0x3444 => Some(unsafe { transmute(0x74b0u32) }),
0x3445 => Some(unsafe { transmute(0x7518u32) }),
0x3446 => Some(unsafe { transmute(0x76e3u32) }),
0x3447 => Some(unsafe { transmute(0x770bu32) }),
0x3448 => Some(unsafe { transmute(0x7affu32) }),
0x3449 => Some(unsafe { transmute(0x7ba1u32) }),
0x344a => Some(unsafe { transmute(0x7c21u32) }),
0x344b => Some(unsafe { transmute(0x7de9u32) }),
0x344c => Some(unsafe { transmute(0x7f36u32) }),
0x344d => Some(unsafe { transmute(0x7ff0u32) }),
0x344e => Some(unsafe { transmute(0x809du32) }),
0x344f => Some(unsafe { transmute(0x8266u32) }),
0x3450 => Some(unsafe { transmute(0x839eu32) }),
0x3451 => Some(unsafe { transmute(0x89b3u32) }),
0x3452 => Some(unsafe { transmute(0x8accu32) }),
0x3453 => Some(unsafe { transmute(0x8cabu32) }),
0x3454 => Some(unsafe { transmute(0x9084u32) }),
0x3455 => Some(unsafe { transmute(0x9451u32) }),
0x3456 => Some(unsafe { transmute(0x9593u32) }),
0x3457 => Some(unsafe { transmute(0x9591u32) }),
0x3458 => Some(unsafe { transmute(0x95a2u32) }),
0x3459 => Some(unsafe { transmute(0x9665u32) }),
0x345a => Some(unsafe { transmute(0x97d3u32) }),
0x345b => Some(unsafe { transmute(0x9928u32) }),
0x345c => Some(unsafe { transmute(0x8218u32) }),
0x345d => Some(unsafe { transmute(0x4e38u32) }),
0x345e => Some(unsafe { transmute(0x542bu32) }),
0x345f => Some(unsafe { transmute(0x5cb8u32) }),
0x3460 => Some(unsafe { transmute(0x5dccu32) }),
0x3461 => Some(unsafe { transmute(0x73a9u32) }),
0x3462 => Some(unsafe { transmute(0x764cu32) }),
0x3463 => Some(unsafe { transmute(0x773cu32) }),
0x3464 => Some(unsafe { transmute(0x5ca9u32) }),
0x3465 => Some(unsafe { transmute(0x7febu32) }),
0x3466 => Some(unsafe { transmute(0x8d0bu32) }),
0x3467 => Some(unsafe { transmute(0x96c1u32) }),
0x3468 => Some(unsafe { transmute(0x9811u32) }),
0x3469 => Some(unsafe { transmute(0x9854u32) }),
0x346a => Some(unsafe { transmute(0x9858u32) }),
0x346b => Some(unsafe { transmute(0x4f01u32) }),
0x346c => Some(unsafe { transmute(0x4f0eu32) }),
0x346d => Some(unsafe { transmute(0x5371u32) }),
0x346e => Some(unsafe { transmute(0x559cu32) }),
0x346f => Some(unsafe { transmute(0x5668u32) }),
0x3470 => Some(unsafe { transmute(0x57fau32) }),
0x3471 => Some(unsafe { transmute(0x5947u32) }),
0x3472 => Some(unsafe { transmute(0x5b09u32) }),
0x3473 => Some(unsafe { transmute(0x5bc4u32) }),
0x3474 => Some(unsafe { transmute(0x5c90u32) }),
0x3475 => Some(unsafe { transmute(0x5e0cu32) }),
0x3476 => Some(unsafe { transmute(0x5e7eu32) }),
0x3477 => Some(unsafe { transmute(0x5fccu32) }),
0x3478 => Some(unsafe { transmute(0x63eeu32) }),
0x3479 => Some(unsafe { transmute(0x673au32) }),
0x347a => Some(unsafe { transmute(0x65d7u32) }),
0x347b => Some(unsafe { transmute(0x65e2u32) }),
0x347c => Some(unsafe { transmute(0x671fu32) }),
0x347d => Some(unsafe { transmute(0x68cbu32) }),
0x347e => Some(unsafe { transmute(0x68c4u32) }),
0x3521 => Some(unsafe { transmute(0x6a5fu32) }),
0x3522 => Some(unsafe { transmute(0x5e30u32) }),
0x3523 => Some(unsafe { transmute(0x6bc5u32) }),
0x3524 => Some(unsafe { transmute(0x6c17u32) }),
0x3525 => Some(unsafe { transmute(0x6c7du32) }),
0x3526 => Some(unsafe { transmute(0x757fu32) }),
0x3527 => Some(unsafe { transmute(0x7948u32) }),
0x3528 => Some(unsafe { transmute(0x5b63u32) }),
0x3529 => Some(unsafe { transmute(0x7a00u32) }),
0x352a => Some(unsafe { transmute(0x7d00u32) }),
0x352b => Some(unsafe { transmute(0x5fbdu32) }),
0x352c => Some(unsafe { transmute(0x898fu32) }),
0x352d => Some(unsafe { transmute(0x8a18u32) }),
0x352e => Some(unsafe { transmute(0x8cb4u32) }),
0x352f => Some(unsafe { transmute(0x8d77u32) }),
0x3530 => Some(unsafe { transmute(0x8eccu32) }),
0x3531 => Some(unsafe { transmute(0x8f1du32) }),
0x3532 => Some(unsafe { transmute(0x98e2u32) }),
0x3533 => Some(unsafe { transmute(0x9a0eu32) }),
0x3534 => Some(unsafe { transmute(0x9b3cu32) }),
0x3535 => Some(unsafe { transmute(0x4e80u32) }),
0x3536 => Some(unsafe { transmute(0x507du32) }),
0x3537 => Some(unsafe { transmute(0x5100u32) }),
0x3538 => Some(unsafe { transmute(0x5993u32) }),
0x3539 => Some(unsafe { transmute(0x5b9cu32) }),
0x353a => Some(unsafe { transmute(0x622fu32) }),
0x353b => Some(unsafe { transmute(0x6280u32) }),
0x353c => Some(unsafe { transmute(0x64ecu32) }),
0x353d => Some(unsafe { transmute(0x6b3au32) }),
0x353e => Some(unsafe { transmute(0x72a0u32) }),
0x353f => Some(unsafe { transmute(0x7591u32) }),
0x3540 => Some(unsafe { transmute(0x7947u32) }),
0x3541 => Some(unsafe { transmute(0x7fa9u32) }),
0x3542 => Some(unsafe { transmute(0x87fbu32) }),
0x3543 => Some(unsafe { transmute(0x8abcu32) }),
0x3544 => Some(unsafe { transmute(0x8b70u32) }),
0x3545 => Some(unsafe { transmute(0x63acu32) }),
0x3546 => Some(unsafe { transmute(0x83cau32) }),
0x3547 => Some(unsafe { transmute(0x97a0u32) }),
0x3548 => Some(unsafe { transmute(0x5409u32) }),
0x3549 => Some(unsafe { transmute(0x5403u32) }),
0x354a => Some(unsafe { transmute(0x55abu32) }),
0x354b => Some(unsafe { transmute(0x6854u32) }),
0x354c => Some(unsafe { transmute(0x6a58u32) }),
0x354d => Some(unsafe { transmute(0x8a70u32) }),
0x354e => Some(unsafe { transmute(0x7827u32) }),
0x354f => Some(unsafe { transmute(0x6775u32) }),
0x3550 => Some(unsafe { transmute(0x9ecdu32) }),
0x3551 => Some(unsafe { transmute(0x5374u32) }),
0x3552 => Some(unsafe { transmute(0x5ba2u32) }),
0x3553 => Some(unsafe { transmute(0x811au32) }),
0x3554 => Some(unsafe { transmute(0x8650u32) }),
0x3555 => Some(unsafe { transmute(0x9006u32) }),
0x3556 => Some(unsafe { transmute(0x4e18u32) }),
0x3557 => Some(unsafe { transmute(0x4e45u32) }),
0x3558 => Some(unsafe { transmute(0x4ec7u32) }),
0x3559 => Some(unsafe { transmute(0x4f11u32) }),
0x355a => Some(unsafe { transmute(0x53cau32) }),
0x355b => Some(unsafe { transmute(0x5438u32) }),
0x355c => Some(unsafe { transmute(0x5baeu32) }),
0x355d => Some(unsafe { transmute(0x5f13u32) }),
0x355e => Some(unsafe { transmute(0x6025u32) }),
0x355f => Some(unsafe { transmute(0x6551u32) }),
0x3560 => Some(unsafe { transmute(0x673du32) }),
0x3561 => Some(unsafe { transmute(0x6c42u32) }),
0x3562 => Some(unsafe { transmute(0x6c72u32) }),
0x3563 => Some(unsafe { transmute(0x6ce3u32) }),
0x3564 => Some(unsafe { transmute(0x7078u32) }),
0x3565 => Some(unsafe { transmute(0x7403u32) }),
0x3566 => Some(unsafe { transmute(0x7a76u32) }),
0x3567 => Some(unsafe { transmute(0x7aaeu32) }),
0x3568 => Some(unsafe { transmute(0x7b08u32) }),
0x3569 => Some(unsafe { transmute(0x7d1au32) }),
0x356a => Some(unsafe { transmute(0x7cfeu32) }),
0x356b => Some(unsafe { transmute(0x7d66u32) }),
0x356c => Some(unsafe { transmute(0x65e7u32) }),
0x356d => Some(unsafe { transmute(0x725bu32) }),
0x356e => Some(unsafe { transmute(0x53bbu32) }),
0x356f => Some(unsafe { transmute(0x5c45u32) }),
0x3570 => Some(unsafe { transmute(0x5de8u32) }),
0x3571 => Some(unsafe { transmute(0x62d2u32) }),
0x3572 => Some(unsafe { transmute(0x62e0u32) }),
0x3573 => Some(unsafe { transmute(0x6319u32) }),
0x3574 => Some(unsafe { transmute(0x6e20u32) }),
0x3575 => Some(unsafe { transmute(0x865au32) }),
0x3576 => Some(unsafe { transmute(0x8a31u32) }),
0x3577 => Some(unsafe { transmute(0x8dddu32) }),
0x3578 => Some(unsafe { transmute(0x92f8u32) }),
0x3579 => Some(unsafe { transmute(0x6f01u32) }),
0x357a => Some(unsafe { transmute(0x79a6u32) }),
0x357b => Some(unsafe { transmute(0x9b5au32) }),
0x357c => Some(unsafe { transmute(0x4ea8u32) }),
0x357d => Some(unsafe { transmute(0x4eabu32) }),
0x357e => Some(unsafe { transmute(0x4eacu32) }),
0x3621 => Some(unsafe { transmute(0x4f9bu32) }),
0x3622 => Some(unsafe { transmute(0x4fa0u32) }),
0x3623 => Some(unsafe { transmute(0x50d1u32) }),
0x3624 => Some(unsafe { transmute(0x5147u32) }),
0x3625 => Some(unsafe { transmute(0x7af6u32) }),
0x3626 => Some(unsafe { transmute(0x5171u32) }),
0x3627 => Some(unsafe { transmute(0x51f6u32) }),
0x3628 => Some(unsafe { transmute(0x5354u32) }),
0x3629 => Some(unsafe { transmute(0x5321u32) }),
0x362a => Some(unsafe { transmute(0x537fu32) }),
0x362b => Some(unsafe { transmute(0x53ebu32) }),
0x362c => Some(unsafe { transmute(0x55acu32) }),
0x362d => Some(unsafe { transmute(0x5883u32) }),
0x362e => Some(unsafe { transmute(0x5ce1u32) }),
0x362f => Some(unsafe { transmute(0x5f37u32) }),
0x3630 => Some(unsafe { transmute(0x5f4au32) }),
0x3631 => Some(unsafe { transmute(0x602fu32) }),
0x3632 => Some(unsafe { transmute(0x6050u32) }),
0x3633 => Some(unsafe { transmute(0x606du32) }),
0x3634 => Some(unsafe { transmute(0x631fu32) }),
0x3635 => Some(unsafe { transmute(0x6559u32) }),
0x3636 => Some(unsafe { transmute(0x6a4bu32) }),
0x3637 => Some(unsafe { transmute(0x6cc1u32) }),
0x3638 => Some(unsafe { transmute(0x72c2u32) }),
0x3639 => Some(unsafe { transmute(0x72edu32) }),
0x363a => Some(unsafe { transmute(0x77efu32) }),
0x363b => Some(unsafe { transmute(0x80f8u32) }),
0x363c => Some(unsafe { transmute(0x8105u32) }),
0x363d => Some(unsafe { transmute(0x8208u32) }),
0x363e => Some(unsafe { transmute(0x854eu32) }),
0x363f => Some(unsafe { transmute(0x90f7u32) }),
0x3640 => Some(unsafe { transmute(0x93e1u32) }),
0x3641 => Some(unsafe { transmute(0x97ffu32) }),
0x3642 => Some(unsafe { transmute(0x9957u32) }),
0x3643 => Some(unsafe { transmute(0x9a5au32) }),
0x3644 => Some(unsafe { transmute(0x4ef0u32) }),
0x3645 => Some(unsafe { transmute(0x51ddu32) }),
0x3646 => Some(unsafe { transmute(0x5c2du32) }),
0x3647 => Some(unsafe { transmute(0x6681u32) }),
0x3648 => Some(unsafe { transmute(0x696du32) }),
0x3649 => Some(unsafe { transmute(0x5c40u32) }),
0x364a => Some(unsafe { transmute(0x66f2u32) }),
0x364b => Some(unsafe { transmute(0x6975u32) }),
0x364c => Some(unsafe { transmute(0x7389u32) }),
0x364d => Some(unsafe { transmute(0x6850u32) }),
0x364e => Some(unsafe { transmute(0x7c81u32) }),
0x364f => Some(unsafe { transmute(0x50c5u32) }),
0x3650 => Some(unsafe { transmute(0x52e4u32) }),
0x3651 => Some(unsafe { transmute(0x5747u32) }),
0x3652 => Some(unsafe { transmute(0x5dfeu32) }),
0x3653 => Some(unsafe { transmute(0x9326u32) }),
0x3654 => Some(unsafe { transmute(0x65a4u32) }),
0x3655 => Some(unsafe { transmute(0x6b23u32) }),
0x3656 => Some(unsafe { transmute(0x6b3du32) }),
0x3657 => Some(unsafe { transmute(0x7434u32) }),
0x3658 => Some(unsafe { transmute(0x7981u32) }),
0x3659 => Some(unsafe { transmute(0x79bdu32) }),
0x365a => Some(unsafe { transmute(0x7b4bu32) }),
0x365b => Some(unsafe { transmute(0x7dcau32) }),
0x365c => Some(unsafe { transmute(0x82b9u32) }),
0x365d => Some(unsafe { transmute(0x83ccu32) }),
0x365e => Some(unsafe { transmute(0x887fu32) }),
0x365f => Some(unsafe { transmute(0x895fu32) }),
0x3660 => Some(unsafe { transmute(0x8b39u32) }),
0x3661 => Some(unsafe { transmute(0x8fd1u32) }),
0x3662 => Some(unsafe { transmute(0x91d1u32) }),
0x3663 => Some(unsafe { transmute(0x541fu32) }),
0x3664 => Some(unsafe { transmute(0x9280u32) }),
0x3665 => Some(unsafe { transmute(0x4e5du32) }),
0x3666 => Some(unsafe { transmute(0x5036u32) }),
0x3667 => Some(unsafe { transmute(0x53e5u32) }),
0x3668 => Some(unsafe { transmute(0x533au32) }),
0x3669 => Some(unsafe { transmute(0x72d7u32) }),
0x366a => Some(unsafe { transmute(0x7396u32) }),
0x366b => Some(unsafe { transmute(0x77e9u32) }),
0x366c => Some(unsafe { transmute(0x82e6u32) }),
0x366d => Some(unsafe { transmute(0x8eafu32) }),
0x366e => Some(unsafe { transmute(0x99c6u32) }),
0x366f => Some(unsafe { transmute(0x99c8u32) }),
0x3670 => Some(unsafe { transmute(0x99d2u32) }),
0x3671 => Some(unsafe { transmute(0x5177u32) }),
0x3672 => Some(unsafe { transmute(0x611au32) }),
0x3673 => Some(unsafe { transmute(0x865eu32) }),
0x3674 => Some(unsafe { transmute(0x55b0u32) }),
0x3675 => Some(unsafe { transmute(0x7a7au32) }),
0x3676 => Some(unsafe { transmute(0x5076u32) }),
0x3677 => Some(unsafe { transmute(0x5bd3u32) }),
0x3678 => Some(unsafe { transmute(0x9047u32) }),
0x3679 => Some(unsafe { transmute(0x9685u32) }),
0x367a => Some(unsafe { transmute(0x4e32u32) }),
0x367b => Some(unsafe { transmute(0x6adbu32) }),
0x367c => Some(unsafe { transmute(0x91e7u32) }),
0x367d => Some(unsafe { transmute(0x5c51u32) }),
0x367e => Some(unsafe { transmute(0x5c48u32) }),
0x3721 => Some(unsafe { transmute(0x6398u32) }),
0x3722 => Some(unsafe { transmute(0x7a9fu32) }),
0x3723 => Some(unsafe { transmute(0x6c93u32) }),
0x3724 => Some(unsafe { transmute(0x9774u32) }),
0x3725 => Some(unsafe { transmute(0x8f61u32) }),
0x3726 => Some(unsafe { transmute(0x7aaau32) }),
0x3727 => Some(unsafe { transmute(0x718au32) }),
0x3728 => Some(unsafe { transmute(0x9688u32) }),
0x3729 => Some(unsafe { transmute(0x7c82u32) }),
0x372a => Some(unsafe { transmute(0x6817u32) }),
0x372b => Some(unsafe { transmute(0x7e70u32) }),
0x372c => Some(unsafe { transmute(0x6851u32) }),
0x372d => Some(unsafe { transmute(0x936cu32) }),
0x372e => Some(unsafe { transmute(0x52f2u32) }),
0x372f => Some(unsafe { transmute(0x541bu32) }),
0x3730 => Some(unsafe { transmute(0x85abu32) }),
0x3731 => Some(unsafe { transmute(0x8a13u32) }),
0x3732 => Some(unsafe { transmute(0x7fa4u32) }),
0x3733 => Some(unsafe { transmute(0x8ecdu32) }),
0x3734 => Some(unsafe { transmute(0x90e1u32) }),
0x3735 => Some(unsafe { transmute(0x5366u32) }),
0x3736 => Some(unsafe { transmute(0x8888u32) }),
0x3737 => Some(unsafe { transmute(0x7941u32) }),
0x3738 => Some(unsafe { transmute(0x4fc2u32) }),
0x3739 => Some(unsafe { transmute(0x50beu32) }),
0x373a => Some(unsafe { transmute(0x5211u32) }),
0x373b => Some(unsafe { transmute(0x5144u32) }),
0x373c => Some(unsafe { transmute(0x5553u32) }),
0x373d => Some(unsafe { transmute(0x572du32) }),
0x373e => Some(unsafe { transmute(0x73eau32) }),
0x373f => Some(unsafe { transmute(0x578bu32) }),
0x3740 => Some(unsafe { transmute(0x5951u32) }),
0x3741 => Some(unsafe { transmute(0x5f62u32) }),
0x3742 => Some(unsafe { transmute(0x5f84u32) }),
0x3743 => Some(unsafe { transmute(0x6075u32) }),
0x3744 => Some(unsafe { transmute(0x6176u32) }),
0x3745 => Some(unsafe { transmute(0x6167u32) }),
0x3746 => Some(unsafe { transmute(0x61a9u32) }),
0x3747 => Some(unsafe { transmute(0x63b2u32) }),
0x3748 => Some(unsafe { transmute(0x643au32) }),
0x3749 => Some(unsafe { transmute(0x656cu32) }),
0x374a => Some(unsafe { transmute(0x666fu32) }),
0x374b => Some(unsafe { transmute(0x6842u32) }),
0x374c => Some(unsafe { transmute(0x6e13u32) }),
0x374d => Some(unsafe { transmute(0x7566u32) }),
0x374e => Some(unsafe { transmute(0x7a3du32) }),
0x374f => Some(unsafe { transmute(0x7cfbu32) }),
0x3750 => Some(unsafe { transmute(0x7d4cu32) }),
0x3751 => Some(unsafe { transmute(0x7d99u32) }),
0x3752 => Some(unsafe { transmute(0x7e4bu32) }),
0x3753 => Some(unsafe { transmute(0x7f6bu32) }),
0x3754 => Some(unsafe { transmute(0x830eu32) }),
0x3755 => Some(unsafe { transmute(0x834au32) }),
0x3756 => Some(unsafe { transmute(0x86cdu32) }),
0x3757 => Some(unsafe { transmute(0x8a08u32) }),
0x3758 => Some(unsafe { transmute(0x8a63u32) }),
0x3759 => Some(unsafe { transmute(0x8b66u32) }),
0x375a => Some(unsafe { transmute(0x8efdu32) }),
0x375b => Some(unsafe { transmute(0x981au32) }),
0x375c => Some(unsafe { transmute(0x9d8fu32) }),
0x375d => Some(unsafe { transmute(0x82b8u32) }),
0x375e => Some(unsafe { transmute(0x8fceu32) }),
0x375f => Some(unsafe { transmute(0x9be8u32) }),
0x3760 => Some(unsafe { transmute(0x5287u32) }),
0x3761 => Some(unsafe { transmute(0x621fu32) }),
0x3762 => Some(unsafe { transmute(0x6483u32) }),
0x3763 => Some(unsafe { transmute(0x6fc0u32) }),
0x3764 => Some(unsafe { transmute(0x9699u32) }),
0x3765 => Some(unsafe { transmute(0x6841u32) }),
0x3766 => Some(unsafe { transmute(0x5091u32) }),
0x3767 => Some(unsafe { transmute(0x6b20u32) }),
0x3768 => Some(unsafe { transmute(0x6c7au32) }),
0x3769 => Some(unsafe { transmute(0x6f54u32) }),
0x376a => Some(unsafe { transmute(0x7a74u32) }),
0x376b => Some(unsafe { transmute(0x7d50u32) }),
0x376c => Some(unsafe { transmute(0x8840u32) }),
0x376d => Some(unsafe { transmute(0x8a23u32) }),
0x376e => Some(unsafe { transmute(0x6708u32) }),
0x376f => Some(unsafe { transmute(0x4ef6u32) }),
0x3770 => Some(unsafe { transmute(0x5039u32) }),
0x3771 => Some(unsafe { transmute(0x5026u32) }),
0x3772 => Some(unsafe { transmute(0x5065u32) }),
0x3773 => Some(unsafe { transmute(0x517cu32) }),
0x3774 => Some(unsafe { transmute(0x5238u32) }),
0x3775 => Some(unsafe { transmute(0x5263u32) }),
0x3776 => Some(unsafe { transmute(0x55a7u32) }),
0x3777 => Some(unsafe { transmute(0x570fu32) }),
0x3778 => Some(unsafe { transmute(0x5805u32) }),
0x3779 => Some(unsafe { transmute(0x5accu32) }),
0x377a => Some(unsafe { transmute(0x5efau32) }),
0x377b => Some(unsafe { transmute(0x61b2u32) }),
0x377c => Some(unsafe { transmute(0x61f8u32) }),
0x377d => Some(unsafe { transmute(0x62f3u32) }),
0x377e => Some(unsafe { transmute(0x6372u32) }),
0x3821 => Some(unsafe { transmute(0x691cu32) }),
0x3822 => Some(unsafe { transmute(0x6a29u32) }),
0x3823 => Some(unsafe { transmute(0x727du32) }),
0x3824 => Some(unsafe { transmute(0x72acu32) }),
0x3825 => Some(unsafe { transmute(0x732eu32) }),
0x3826 => Some(unsafe { transmute(0x7814u32) }),
0x3827 => Some(unsafe { transmute(0x786fu32) }),
0x3828 => Some(unsafe { transmute(0x7d79u32) }),
0x3829 => Some(unsafe { transmute(0x770cu32) }),
0x382a => Some(unsafe { transmute(0x80a9u32) }),
0x382b => Some(unsafe { transmute(0x898bu32) }),
0x382c => Some(unsafe { transmute(0x8b19u32) }),
0x382d => Some(unsafe { transmute(0x8ce2u32) }),
0x382e => Some(unsafe { transmute(0x8ed2u32) }),
0x382f => Some(unsafe { transmute(0x9063u32) }),
0x3830 => Some(unsafe { transmute(0x9375u32) }),
0x3831 => Some(unsafe { transmute(0x967au32) }),
0x3832 => Some(unsafe { transmute(0x9855u32) }),
0x3833 => Some(unsafe { transmute(0x9a13u32) }),
0x3834 => Some(unsafe { transmute(0x9e78u32) }),
0x3835 => Some(unsafe { transmute(0x5143u32) }),
0x3836 => Some(unsafe { transmute(0x539fu32) }),
0x3837 => Some(unsafe { transmute(0x53b3u32) }),
0x3838 => Some(unsafe { transmute(0x5e7bu32) }),
0x3839 => Some(unsafe { transmute(0x5f26u32) }),
0x383a => Some(unsafe { transmute(0x6e1bu32) }),
0x383b => Some(unsafe { transmute(0x6e90u32) }),
0x383c => Some(unsafe { transmute(0x7384u32) }),
0x383d => Some(unsafe { transmute(0x73feu32) }),
0x383e => Some(unsafe { transmute(0x7d43u32) }),
0x383f => Some(unsafe { transmute(0x8237u32) }),
0x3840 => Some(unsafe { transmute(0x8a00u32) }),
0x3841 => Some(unsafe { transmute(0x8afau32) }),
0x3842 => Some(unsafe { transmute(0x9650u32) }),
0x3843 => Some(unsafe { transmute(0x4e4eu32) }),
0x3844 => Some(unsafe { transmute(0x500bu32) }),
0x3845 => Some(unsafe { transmute(0x53e4u32) }),
0x3846 => Some(unsafe { transmute(0x547cu32) }),
0x3847 => Some(unsafe { transmute(0x56fau32) }),
0x3848 => Some(unsafe { transmute(0x59d1u32) }),
0x3849 => Some(unsafe { transmute(0x5b64u32) }),
0x384a => Some(unsafe { transmute(0x5df1u32) }),
0x384b => Some(unsafe { transmute(0x5eabu32) }),
0x384c => Some(unsafe { transmute(0x5f27u32) }),
0x384d => Some(unsafe { transmute(0x6238u32) }),
0x384e => Some(unsafe { transmute(0x6545u32) }),
0x384f => Some(unsafe { transmute(0x67afu32) }),
0x3850 => Some(unsafe { transmute(0x6e56u32) }),
0x3851 => Some(unsafe { transmute(0x72d0u32) }),
0x3852 => Some(unsafe { transmute(0x7ccau32) }),
0x3853 => Some(unsafe { transmute(0x88b4u32) }),
0x3854 => Some(unsafe { transmute(0x80a1u32) }),
0x3855 => Some(unsafe { transmute(0x80e1u32) }),
0x3856 => Some(unsafe { transmute(0x83f0u32) }),
0x3857 => Some(unsafe { transmute(0x864eu32) }),
0x3858 => Some(unsafe { transmute(0x8a87u32) }),
0x3859 => Some(unsafe { transmute(0x8de8u32) }),
0x385a => Some(unsafe { transmute(0x9237u32) }),
0x385b => Some(unsafe { transmute(0x96c7u32) }),
0x385c => Some(unsafe { transmute(0x9867u32) }),
0x385d => Some(unsafe { transmute(0x9f13u32) }),
0x385e => Some(unsafe { transmute(0x4e94u32) }),
0x385f => Some(unsafe { transmute(0x4e92u32) }),
0x3860 => Some(unsafe { transmute(0x4f0du32) }),
0x3861 => Some(unsafe { transmute(0x5348u32) }),
0x3862 => Some(unsafe { transmute(0x5449u32) }),
0x3863 => Some(unsafe { transmute(0x543eu32) }),
0x3864 => Some(unsafe { transmute(0x5a2fu32) }),
0x3865 => Some(unsafe { transmute(0x5f8cu32) }),
0x3866 => Some(unsafe { transmute(0x5fa1u32) }),
0x3867 => Some(unsafe { transmute(0x609fu32) }),
0x3868 => Some(unsafe { transmute(0x68a7u32) }),
0x3869 => Some(unsafe { transmute(0x6a8eu32) }),
0x386a => Some(unsafe { transmute(0x745au32) }),
0x386b => Some(unsafe { transmute(0x7881u32) }),
0x386c => Some(unsafe { transmute(0x8a9eu32) }),
0x386d => Some(unsafe { transmute(0x8aa4u32) }),
0x386e => Some(unsafe { transmute(0x8b77u32) }),
0x386f => Some(unsafe { transmute(0x9190u32) }),
0x3870 => Some(unsafe { transmute(0x4e5eu32) }),
0x3871 => Some(unsafe { transmute(0x9bc9u32) }),
0x3872 => Some(unsafe { transmute(0x4ea4u32) }),
0x3873 => Some(unsafe { transmute(0x4f7cu32) }),
0x3874 => Some(unsafe { transmute(0x4fafu32) }),
0x3875 => Some(unsafe { transmute(0x5019u32) }),
0x3876 => Some(unsafe { transmute(0x5016u32) }),
0x3877 => Some(unsafe { transmute(0x5149u32) }),
0x3878 => Some(unsafe { transmute(0x516cu32) }),
0x3879 => Some(unsafe { transmute(0x529fu32) }),
0x387a => Some(unsafe { transmute(0x52b9u32) }),
0x387b => Some(unsafe { transmute(0x52feu32) }),
0x387c => Some(unsafe { transmute(0x539au32) }),
0x387d => Some(unsafe { transmute(0x53e3u32) }),
0x387e => Some(unsafe { transmute(0x5411u32) }),
0x3921 => Some(unsafe { transmute(0x540eu32) }),
0x3922 => Some(unsafe { transmute(0x5589u32) }),
0x3923 => Some(unsafe { transmute(0x5751u32) }),
0x3924 => Some(unsafe { transmute(0x57a2u32) }),
0x3925 => Some(unsafe { transmute(0x597du32) }),
0x3926 => Some(unsafe { transmute(0x5b54u32) }),
0x3927 => Some(unsafe { transmute(0x5b5du32) }),
0x3928 => Some(unsafe { transmute(0x5b8fu32) }),
0x3929 => Some(unsafe { transmute(0x5de5u32) }),
0x392a => Some(unsafe { transmute(0x5de7u32) }),
0x392b => Some(unsafe { transmute(0x5df7u32) }),
0x392c => Some(unsafe { transmute(0x5e78u32) }),
0x392d => Some(unsafe { transmute(0x5e83u32) }),
0x392e => Some(unsafe { transmute(0x5e9au32) }),
0x392f => Some(unsafe { transmute(0x5eb7u32) }),
0x3930 => Some(unsafe { transmute(0x5f18u32) }),
0x3931 => Some(unsafe { transmute(0x6052u32) }),
0x3932 => Some(unsafe { transmute(0x614cu32) }),
0x3933 => Some(unsafe { transmute(0x6297u32) }),
0x3934 => Some(unsafe { transmute(0x62d8u32) }),
0x3935 => Some(unsafe { transmute(0x63a7u32) }),
0x3936 => Some(unsafe { transmute(0x653bu32) }),
0x3937 => Some(unsafe { transmute(0x6602u32) }),
0x3938 => Some(unsafe { transmute(0x6643u32) }),
0x3939 => Some(unsafe { transmute(0x66f4u32) }),
0x393a => Some(unsafe { transmute(0x676du32) }),
0x393b => Some(unsafe { transmute(0x6821u32) }),
0x393c => Some(unsafe { transmute(0x6897u32) }),
0x393d => Some(unsafe { transmute(0x69cbu32) }),
0x393e => Some(unsafe { transmute(0x6c5fu32) }),
0x393f => Some(unsafe { transmute(0x6d2au32) }),
0x3940 => Some(unsafe { transmute(0x6d69u32) }),
0x3941 => Some(unsafe { transmute(0x6e2fu32) }),
0x3942 => Some(unsafe { transmute(0x6e9du32) }),
0x3943 => Some(unsafe { transmute(0x7532u32) }),
0x3944 => Some(unsafe { transmute(0x7687u32) }),
0x3945 => Some(unsafe { transmute(0x786cu32) }),
0x3946 => Some(unsafe { transmute(0x7a3fu32) }),
0x3947 => Some(unsafe { transmute(0x7ce0u32) }),
0x3948 => Some(unsafe { transmute(0x7d05u32) }),
0x3949 => Some(unsafe { transmute(0x7d18u32) }),
0x394a => Some(unsafe { transmute(0x7d5eu32) }),
0x394b => Some(unsafe { transmute(0x7db1u32) }),
0x394c => Some(unsafe { transmute(0x8015u32) }),
0x394d => Some(unsafe { transmute(0x8003u32) }),
0x394e => Some(unsafe { transmute(0x80afu32) }),
0x394f => Some(unsafe { transmute(0x80b1u32) }),
0x3950 => Some(unsafe { transmute(0x8154u32) }),
0x3951 => Some(unsafe { transmute(0x818fu32) }),
0x3952 => Some(unsafe { transmute(0x822au32) }),
0x3953 => Some(unsafe { transmute(0x8352u32) }),
0x3954 => Some(unsafe { transmute(0x884cu32) }),
0x3955 => Some(unsafe { transmute(0x8861u32) }),
0x3956 => Some(unsafe { transmute(0x8b1bu32) }),
0x3957 => Some(unsafe { transmute(0x8ca2u32) }),
0x3958 => Some(unsafe { transmute(0x8cfcu32) }),
0x3959 => Some(unsafe { transmute(0x90cau32) }),
0x395a => Some(unsafe { transmute(0x9175u32) }),
0x395b => Some(unsafe { transmute(0x9271u32) }),
0x395c => Some(unsafe { transmute(0x783fu32) }),
0x395d => Some(unsafe { transmute(0x92fcu32) }),
0x395e => Some(unsafe { transmute(0x95a4u32) }),
0x395f => Some(unsafe { transmute(0x964du32) }),
0x3960 => Some(unsafe { transmute(0x9805u32) }),
0x3961 => Some(unsafe { transmute(0x9999u32) }),
0x3962 => Some(unsafe { transmute(0x9ad8u32) }),
0x3963 => Some(unsafe { transmute(0x9d3bu32) }),
0x3964 => Some(unsafe { transmute(0x525bu32) }),
0x3965 => Some(unsafe { transmute(0x52abu32) }),
0x3966 => Some(unsafe { transmute(0x53f7u32) }),
0x3967 => Some(unsafe { transmute(0x5408u32) }),
0x3968 => Some(unsafe { transmute(0x58d5u32) }),
0x3969 => Some(unsafe { transmute(0x62f7u32) }),
0x396a => Some(unsafe { transmute(0x6fe0u32) }),
0x396b => Some(unsafe { transmute(0x8c6au32) }),
0x396c => Some(unsafe { transmute(0x8f5fu32) }),
0x396d => Some(unsafe { transmute(0x9eb9u32) }),
0x396e => Some(unsafe { transmute(0x514bu32) }),
0x396f => Some(unsafe { transmute(0x523bu32) }),
0x3970 => Some(unsafe { transmute(0x544au32) }),
0x3971 => Some(unsafe { transmute(0x56fdu32) }),
0x3972 => Some(unsafe { transmute(0x7a40u32) }),
0x3973 => Some(unsafe { transmute(0x9177u32) }),
0x3974 => Some(unsafe { transmute(0x9d60u32) }),
0x3975 => Some(unsafe { transmute(0x9ed2u32) }),
0x3976 => Some(unsafe { transmute(0x7344u32) }),
0x3977 => Some(unsafe { transmute(0x6f09u32) }),
0x3978 => Some(unsafe { transmute(0x8170u32) }),
0x3979 => Some(unsafe { transmute(0x7511u32) }),
0x397a => Some(unsafe { transmute(0x5ffdu32) }),
0x397b => Some(unsafe { transmute(0x60dau32) }),
0x397c => Some(unsafe { transmute(0x9aa8u32) }),
0x397d => Some(unsafe { transmute(0x72dbu32) }),
0x397e => Some(unsafe { transmute(0x8fbcu32) }),
0x3a21 => Some(unsafe { transmute(0x6b64u32) }),
0x3a22 => Some(unsafe { transmute(0x9803u32) }),
0x3a23 => Some(unsafe { transmute(0x4ecau32) }),
0x3a24 => Some(unsafe { transmute(0x56f0u32) }),
0x3a25 => Some(unsafe { transmute(0x5764u32) }),
0x3a26 => Some(unsafe { transmute(0x58beu32) }),
0x3a27 => Some(unsafe { transmute(0x5a5au32) }),
0x3a28 => Some(unsafe { transmute(0x6068u32) }),
0x3a29 => Some(unsafe { transmute(0x61c7u32) }),
0x3a2a => Some(unsafe { transmute(0x660fu32) }),
0x3a2b => Some(unsafe { transmute(0x6606u32) }),
0x3a2c => Some(unsafe { transmute(0x6839u32) }),
0x3a2d => Some(unsafe { transmute(0x68b1u32) }),
0x3a2e => Some(unsafe { transmute(0x6df7u32) }),
0x3a2f => Some(unsafe { transmute(0x75d5u32) }),
0x3a30 => Some(unsafe { transmute(0x7d3au32) }),
0x3a31 => Some(unsafe { transmute(0x826eu32) }),
0x3a32 => Some(unsafe { transmute(0x9b42u32) }),
0x3a33 => Some(unsafe { transmute(0x4e9bu32) }),
0x3a34 => Some(unsafe { transmute(0x4f50u32) }),
0x3a35 => Some(unsafe { transmute(0x53c9u32) }),
0x3a36 => Some(unsafe { transmute(0x5506u32) }),
0x3a37 => Some(unsafe { transmute(0x5d6fu32) }),
0x3a38 => Some(unsafe { transmute(0x5de6u32) }),
0x3a39 => Some(unsafe { transmute(0x5deeu32) }),
0x3a3a => Some(unsafe { transmute(0x67fbu32) }),
0x3a3b => Some(unsafe { transmute(0x6c99u32) }),
0x3a3c => Some(unsafe { transmute(0x7473u32) }),
0x3a3d => Some(unsafe { transmute(0x7802u32) }),
0x3a3e => Some(unsafe { transmute(0x8a50u32) }),
0x3a3f => Some(unsafe { transmute(0x9396u32) }),
0x3a40 => Some(unsafe { transmute(0x88dfu32) }),
0x3a41 => Some(unsafe { transmute(0x5750u32) }),
0x3a42 => Some(unsafe { transmute(0x5ea7u32) }),
0x3a43 => Some(unsafe { transmute(0x632bu32) }),
0x3a44 => Some(unsafe { transmute(0x50b5u32) }),
0x3a45 => Some(unsafe { transmute(0x50acu32) }),
0x3a46 => Some(unsafe { transmute(0x518du32) }),
0x3a47 => Some(unsafe { transmute(0x6700u32) }),
0x3a48 => Some(unsafe { transmute(0x54c9u32) }),
0x3a49 => Some(unsafe { transmute(0x585eu32) }),
0x3a4a => Some(unsafe { transmute(0x59bbu32) }),
0x3a4b => Some(unsafe { transmute(0x5bb0u32) }),
0x3a4c => Some(unsafe { transmute(0x5f69u32) }),
0x3a4d => Some(unsafe { transmute(0x624du32) }),
0x3a4e => Some(unsafe { transmute(0x63a1u32) }),
0x3a4f => Some(unsafe { transmute(0x683du32) }),
0x3a50 => Some(unsafe { transmute(0x6b73u32) }),
0x3a51 => Some(unsafe { transmute(0x6e08u32) }),
0x3a52 => Some(unsafe { transmute(0x707du32) }),
0x3a53 => Some(unsafe { transmute(0x91c7u32) }),
0x3a54 => Some(unsafe { transmute(0x7280u32) }),
0x3a55 => Some(unsafe { transmute(0x7815u32) }),
0x3a56 => Some(unsafe { transmute(0x7826u32) }),
0x3a57 => Some(unsafe { transmute(0x796du32) }),
0x3a58 => Some(unsafe { transmute(0x658eu32) }),
0x3a59 => Some(unsafe { transmute(0x7d30u32) }),
0x3a5a => Some(unsafe { transmute(0x83dcu32) }),
0x3a5b => Some(unsafe { transmute(0x88c1u32) }),
0x3a5c => Some(unsafe { transmute(0x8f09u32) }),
0x3a5d => Some(unsafe { transmute(0x969bu32) }),
0x3a5e => Some(unsafe { transmute(0x5264u32) }),
0x3a5f => Some(unsafe { transmute(0x5728u32) }),
0x3a60 => Some(unsafe { transmute(0x6750u32) }),
0x3a61 => Some(unsafe { transmute(0x7f6au32) }),
0x3a62 => Some(unsafe { transmute(0x8ca1u32) }),
0x3a63 => Some(unsafe { transmute(0x51b4u32) }),
0x3a64 => Some(unsafe { transmute(0x5742u32) }),
0x3a65 => Some(unsafe { transmute(0x962au32) }),
0x3a66 => Some(unsafe { transmute(0x583au32) }),
0x3a67 => Some(unsafe { transmute(0x698au32) }),
0x3a68 => Some(unsafe { transmute(0x80b4u32) }),
0x3a69 => Some(unsafe { transmute(0x54b2u32) }),
0x3a6a => Some(unsafe { transmute(0x5d0eu32) }),
0x3a6b => Some(unsafe { transmute(0x57fcu32) }),
0x3a6c => Some(unsafe { transmute(0x7895u32) }),
0x3a6d => Some(unsafe { transmute(0x9dfau32) }),
0x3a6e => Some(unsafe { transmute(0x4f5cu32) }),
0x3a6f => Some(unsafe { transmute(0x524au32) }),
0x3a70 => Some(unsafe { transmute(0x548bu32) }),
0x3a71 => Some(unsafe { transmute(0x643eu32) }),
0x3a72 => Some(unsafe { transmute(0x6628u32) }),
0x3a73 => Some(unsafe { transmute(0x6714u32) }),
0x3a74 => Some(unsafe { transmute(0x67f5u32) }),
0x3a75 => Some(unsafe { transmute(0x7a84u32) }),
0x3a76 => Some(unsafe { transmute(0x7b56u32) }),
0x3a77 => Some(unsafe { transmute(0x7d22u32) }),
0x3a78 => Some(unsafe { transmute(0x932fu32) }),
0x3a79 => Some(unsafe { transmute(0x685cu32) }),
0x3a7a => Some(unsafe { transmute(0x9badu32) }),
0x3a7b => Some(unsafe { transmute(0x7b39u32) }),
0x3a7c => Some(unsafe { transmute(0x5319u32) }),
0x3a7d => Some(unsafe { transmute(0x518au32) }),
0x3a7e => Some(unsafe { transmute(0x5237u32) }),
0x3b21 => Some(unsafe { transmute(0x5bdfu32) }),
0x3b22 => Some(unsafe { transmute(0x62f6u32) }),
0x3b23 => Some(unsafe { transmute(0x64aeu32) }),
0x3b24 => Some(unsafe { transmute(0x64e6u32) }),
0x3b25 => Some(unsafe { transmute(0x672du32) }),
0x3b26 => Some(unsafe { transmute(0x6bbau32) }),
0x3b27 => Some(unsafe { transmute(0x85a9u32) }),
0x3b28 => Some(unsafe { transmute(0x96d1u32) }),
0x3b29 => Some(unsafe { transmute(0x7690u32) }),
0x3b2a => Some(unsafe { transmute(0x9bd6u32) }),
0x3b2b => Some(unsafe { transmute(0x634cu32) }),
0x3b2c => Some(unsafe { transmute(0x9306u32) }),
0x3b2d => Some(unsafe { transmute(0x9babu32) }),
0x3b2e => Some(unsafe { transmute(0x76bfu32) }),
0x3b2f => Some(unsafe { transmute(0x6652u32) }),
0x3b30 => Some(unsafe { transmute(0x4e09u32) }),
0x3b31 => Some(unsafe { transmute(0x5098u32) }),
0x3b32 => Some(unsafe { transmute(0x53c2u32) }),
0x3b33 => Some(unsafe { transmute(0x5c71u32) }),
0x3b34 => Some(unsafe { transmute(0x60e8u32) }),
0x3b35 => Some(unsafe { transmute(0x6492u32) }),
0x3b36 => Some(unsafe { transmute(0x6563u32) }),
0x3b37 => Some(unsafe { transmute(0x685fu32) }),
0x3b38 => Some(unsafe { transmute(0x71e6u32) }),
0x3b39 => Some(unsafe { transmute(0x73cau32) }),
0x3b3a => Some(unsafe { transmute(0x7523u32) }),
0x3b3b => Some(unsafe { transmute(0x7b97u32) }),
0x3b3c => Some(unsafe { transmute(0x7e82u32) }),
0x3b3d => Some(unsafe { transmute(0x8695u32) }),
0x3b3e => Some(unsafe { transmute(0x8b83u32) }),
0x3b3f => Some(unsafe { transmute(0x8cdbu32) }),
0x3b40 => Some(unsafe { transmute(0x9178u32) }),
0x3b41 => Some(unsafe { transmute(0x9910u32) }),
0x3b42 => Some(unsafe { transmute(0x65acu32) }),
0x3b43 => Some(unsafe { transmute(0x66abu32) }),
0x3b44 => Some(unsafe { transmute(0x6b8bu32) }),
0x3b45 => Some(unsafe { transmute(0x4ed5u32) }),
0x3b46 => Some(unsafe { transmute(0x4ed4u32) }),
0x3b47 => Some(unsafe { transmute(0x4f3au32) }),
0x3b48 => Some(unsafe { transmute(0x4f7fu32) }),
0x3b49 => Some(unsafe { transmute(0x523au32) }),
0x3b4a => Some(unsafe { transmute(0x53f8u32) }),
0x3b4b => Some(unsafe { transmute(0x53f2u32) }),
0x3b4c => Some(unsafe { transmute(0x55e3u32) }),
0x3b4d => Some(unsafe { transmute(0x56dbu32) }),
0x3b4e => Some(unsafe { transmute(0x58ebu32) }),
0x3b4f => Some(unsafe { transmute(0x59cbu32) }),
0x3b50 => Some(unsafe { transmute(0x59c9u32) }),
0x3b51 => Some(unsafe { transmute(0x59ffu32) }),
0x3b52 => Some(unsafe { transmute(0x5b50u32) }),
0x3b53 => Some(unsafe { transmute(0x5c4du32) }),
0x3b54 => Some(unsafe { transmute(0x5e02u32) }),
0x3b55 => Some(unsafe { transmute(0x5e2bu32) }),
0x3b56 => Some(unsafe { transmute(0x5fd7u32) }),
0x3b57 => Some(unsafe { transmute(0x601du32) }),
0x3b58 => Some(unsafe { transmute(0x6307u32) }),
0x3b59 => Some(unsafe { transmute(0x652fu32) }),
0x3b5a => Some(unsafe { transmute(0x5b5cu32) }),
0x3b5b => Some(unsafe { transmute(0x65afu32) }),
0x3b5c => Some(unsafe { transmute(0x65bdu32) }),
0x3b5d => Some(unsafe { transmute(0x65e8u32) }),
0x3b5e => Some(unsafe { transmute(0x679du32) }),
0x3b5f => Some(unsafe { transmute(0x6b62u32) }),
0x3b60 => Some(unsafe { transmute(0x6b7bu32) }),
0x3b61 => Some(unsafe { transmute(0x6c0fu32) }),
0x3b62 => Some(unsafe { transmute(0x7345u32) }),
0x3b63 => Some(unsafe { transmute(0x7949u32) }),
0x3b64 => Some(unsafe { transmute(0x79c1u32) }),
0x3b65 => Some(unsafe { transmute(0x7cf8u32) }),
0x3b66 => Some(unsafe { transmute(0x7d19u32) }),
0x3b67 => Some(unsafe { transmute(0x7d2bu32) }),
0x3b68 => Some(unsafe { transmute(0x80a2u32) }),
0x3b69 => Some(unsafe { transmute(0x8102u32) }),
0x3b6a => Some(unsafe { transmute(0x81f3u32) }),
0x3b6b => Some(unsafe { transmute(0x8996u32) }),
0x3b6c => Some(unsafe { transmute(0x8a5eu32) }),
0x3b6d => Some(unsafe { transmute(0x8a69u32) }),
0x3b6e => Some(unsafe { transmute(0x8a66u32) }),
0x3b6f => Some(unsafe { transmute(0x8a8cu32) }),
0x3b70 => Some(unsafe { transmute(0x8aeeu32) }),
0x3b71 => Some(unsafe { transmute(0x8cc7u32) }),
0x3b72 => Some(unsafe { transmute(0x8cdcu32) }),
0x3b73 => Some(unsafe { transmute(0x96ccu32) }),
0x3b74 => Some(unsafe { transmute(0x98fcu32) }),
0x3b75 => Some(unsafe { transmute(0x6b6fu32) }),
0x3b76 => Some(unsafe { transmute(0x4e8bu32) }),
0x3b77 => Some(unsafe { transmute(0x4f3cu32) }),
0x3b78 => Some(unsafe { transmute(0x4f8du32) }),
0x3b79 => Some(unsafe { transmute(0x5150u32) }),
0x3b7a => Some(unsafe { transmute(0x5b57u32) }),
0x3b7b => Some(unsafe { transmute(0x5bfau32) }),
0x3b7c => Some(unsafe { transmute(0x6148u32) }),
0x3b7d => Some(unsafe { transmute(0x6301u32) }),
0x3b7e => Some(unsafe { transmute(0x6642u32) }),
0x3c21 => Some(unsafe { transmute(0x6b21u32) }),
0x3c22 => Some(unsafe { transmute(0x6ecbu32) }),
0x3c23 => Some(unsafe { transmute(0x6cbbu32) }),
0x3c24 => Some(unsafe { transmute(0x723eu32) }),
0x3c25 => Some(unsafe { transmute(0x74bdu32) }),
0x3c26 => Some(unsafe { transmute(0x75d4u32) }),
0x3c27 => Some(unsafe { transmute(0x78c1u32) }),
0x3c28 => Some(unsafe { transmute(0x793au32) }),
0x3c29 => Some(unsafe { transmute(0x800cu32) }),
0x3c2a => Some(unsafe { transmute(0x8033u32) }),
0x3c2b => Some(unsafe { transmute(0x81eau32) }),
0x3c2c => Some(unsafe { transmute(0x8494u32) }),
0x3c2d => Some(unsafe { transmute(0x8f9eu32) }),
0x3c2e => Some(unsafe { transmute(0x6c50u32) }),
0x3c2f => Some(unsafe { transmute(0x9e7fu32) }),
0x3c30 => Some(unsafe { transmute(0x5f0fu32) }),
0x3c31 => Some(unsafe { transmute(0x8b58u32) }),
0x3c32 => Some(unsafe { transmute(0x9d2bu32) }),
0x3c33 => Some(unsafe { transmute(0x7afau32) }),
0x3c34 => Some(unsafe { transmute(0x8ef8u32) }),
0x3c35 => Some(unsafe { transmute(0x5b8du32) }),
0x3c36 => Some(unsafe { transmute(0x96ebu32) }),
0x3c37 => Some(unsafe { transmute(0x4e03u32) }),
0x3c38 => Some(unsafe { transmute(0x53f1u32) }),
0x3c39 => Some(unsafe { transmute(0x57f7u32) }),
0x3c3a => Some(unsafe { transmute(0x5931u32) }),
0x3c3b => Some(unsafe { transmute(0x5ac9u32) }),
0x3c3c => Some(unsafe { transmute(0x5ba4u32) }),
0x3c3d => Some(unsafe { transmute(0x6089u32) }),
0x3c3e => Some(unsafe { transmute(0x6e7fu32) }),
0x3c3f => Some(unsafe { transmute(0x6f06u32) }),
0x3c40 => Some(unsafe { transmute(0x75beu32) }),
0x3c41 => Some(unsafe { transmute(0x8ceau32) }),
0x3c42 => Some(unsafe { transmute(0x5b9fu32) }),
0x3c43 => Some(unsafe { transmute(0x8500u32) }),
0x3c44 => Some(unsafe { transmute(0x7be0u32) }),
0x3c45 => Some(unsafe { transmute(0x5072u32) }),
0x3c46 => Some(unsafe { transmute(0x67f4u32) }),
0x3c47 => Some(unsafe { transmute(0x829du32) }),
0x3c48 => Some(unsafe { transmute(0x5c61u32) }),
0x3c49 => Some(unsafe { transmute(0x854au32) }),
0x3c4a => Some(unsafe { transmute(0x7e1eu32) }),
0x3c4b => Some(unsafe { transmute(0x820eu32) }),
0x3c4c => Some(unsafe { transmute(0x5199u32) }),
0x3c4d => Some(unsafe { transmute(0x5c04u32) }),
0x3c4e => Some(unsafe { transmute(0x6368u32) }),
0x3c4f => Some(unsafe { transmute(0x8d66u32) }),
0x3c50 => Some(unsafe { transmute(0x659cu32) }),
0x3c51 => Some(unsafe { transmute(0x716eu32) }),
0x3c52 => Some(unsafe { transmute(0x793eu32) }),
0x3c53 => Some(unsafe { transmute(0x7d17u32) }),
0x3c54 => Some(unsafe { transmute(0x8005u32) }),
0x3c55 => Some(unsafe { transmute(0x8b1du32) }),
0x3c56 => Some(unsafe { transmute(0x8ecau32) }),
0x3c57 => Some(unsafe { transmute(0x906eu32) }),
0x3c58 => Some(unsafe { transmute(0x86c7u32) }),
0x3c59 => Some(unsafe { transmute(0x90aau32) }),
0x3c5a => Some(unsafe { transmute(0x501fu32) }),
0x3c5b => Some(unsafe { transmute(0x52fau32) }),
0x3c5c => Some(unsafe { transmute(0x5c3au32) }),
0x3c5d => Some(unsafe { transmute(0x6753u32) }),
0x3c5e => Some(unsafe { transmute(0x707cu32) }),
0x3c5f => Some(unsafe { transmute(0x7235u32) }),
0x3c60 => Some(unsafe { transmute(0x914cu32) }),
0x3c61 => Some(unsafe { transmute(0x91c8u32) }),
0x3c62 => Some(unsafe { transmute(0x932bu32) }),
0x3c63 => Some(unsafe { transmute(0x82e5u32) }),
0x3c64 => Some(unsafe { transmute(0x5bc2u32) }),
0x3c65 => Some(unsafe { transmute(0x5f31u32) }),
0x3c66 => Some(unsafe { transmute(0x60f9u32) }),
0x3c67 => Some(unsafe { transmute(0x4e3bu32) }),
0x3c68 => Some(unsafe { transmute(0x53d6u32) }),
0x3c69 => Some(unsafe { transmute(0x5b88u32) }),
0x3c6a => Some(unsafe { transmute(0x624bu32) }),
0x3c6b => Some(unsafe { transmute(0x6731u32) }),
0x3c6c => Some(unsafe { transmute(0x6b8au32) }),
0x3c6d => Some(unsafe { transmute(0x72e9u32) }),
0x3c6e => Some(unsafe { transmute(0x73e0u32) }),
0x3c6f => Some(unsafe { transmute(0x7a2eu32) }),
0x3c70 => Some(unsafe { transmute(0x816bu32) }),
0x3c71 => Some(unsafe { transmute(0x8da3u32) }),
0x3c72 => Some(unsafe { transmute(0x9152u32) }),
0x3c73 => Some(unsafe { transmute(0x9996u32) }),
0x3c74 => Some(unsafe { transmute(0x5112u32) }),
0x3c75 => Some(unsafe { transmute(0x53d7u32) }),
0x3c76 => Some(unsafe { transmute(0x546au32) }),
0x3c77 => Some(unsafe { transmute(0x5bffu32) }),
0x3c78 => Some(unsafe { transmute(0x6388u32) }),
0x3c79 => Some(unsafe { transmute(0x6a39u32) }),
0x3c7a => Some(unsafe { transmute(0x7dacu32) }),
0x3c7b => Some(unsafe { transmute(0x9700u32) }),
0x3c7c => Some(unsafe { transmute(0x56dau32) }),
0x3c7d => Some(unsafe { transmute(0x53ceu32) }),
0x3c7e => Some(unsafe { transmute(0x5468u32) }),
0x3d21 => Some(unsafe { transmute(0x5b97u32) }),
0x3d22 => Some(unsafe { transmute(0x5c31u32) }),
0x3d23 => Some(unsafe { transmute(0x5ddeu32) }),
0x3d24 => Some(unsafe { transmute(0x4feeu32) }),
0x3d25 => Some(unsafe { transmute(0x6101u32) }),
0x3d26 => Some(unsafe { transmute(0x62feu32) }),
0x3d27 => Some(unsafe { transmute(0x6d32u32) }),
0x3d28 => Some(unsafe { transmute(0x79c0u32) }),
0x3d29 => Some(unsafe { transmute(0x79cbu32) }),
0x3d2a => Some(unsafe { transmute(0x7d42u32) }),
0x3d2b => Some(unsafe { transmute(0x7e4du32) }),
0x3d2c => Some(unsafe { transmute(0x7fd2u32) }),
0x3d2d => Some(unsafe { transmute(0x81edu32) }),
0x3d2e => Some(unsafe { transmute(0x821fu32) }),
0x3d2f => Some(unsafe { transmute(0x8490u32) }),
0x3d30 => Some(unsafe { transmute(0x8846u32) }),
0x3d31 => Some(unsafe { transmute(0x8972u32) }),
0x3d32 => Some(unsafe { transmute(0x8b90u32) }),
0x3d33 => Some(unsafe { transmute(0x8e74u32) }),
0x3d34 => Some(unsafe { transmute(0x8f2fu32) }),
0x3d35 => Some(unsafe { transmute(0x9031u32) }),
0x3d36 => Some(unsafe { transmute(0x914bu32) }),
0x3d37 => Some(unsafe { transmute(0x916cu32) }),
0x3d38 => Some(unsafe { transmute(0x96c6u32) }),
0x3d39 => Some(unsafe { transmute(0x919cu32) }),
0x3d3a => Some(unsafe { transmute(0x4ec0u32) }),
0x3d3b => Some(unsafe { transmute(0x4f4fu32) }),
0x3d3c => Some(unsafe { transmute(0x5145u32) }),
0x3d3d => Some(unsafe { transmute(0x5341u32) }),
0x3d3e => Some(unsafe { transmute(0x5f93u32) }),
0x3d3f => Some(unsafe { transmute(0x620eu32) }),
0x3d40 => Some(unsafe { transmute(0x67d4u32) }),
0x3d41 => Some(unsafe { transmute(0x6c41u32) }),
0x3d42 => Some(unsafe { transmute(0x6e0bu32) }),
0x3d43 => Some(unsafe { transmute(0x7363u32) }),
0x3d44 => Some(unsafe { transmute(0x7e26u32) }),
0x3d45 => Some(unsafe { transmute(0x91cdu32) }),
0x3d46 => Some(unsafe { transmute(0x9283u32) }),
0x3d47 => Some(unsafe { transmute(0x53d4u32) }),
0x3d48 => Some(unsafe { transmute(0x5919u32) }),
0x3d49 => Some(unsafe { transmute(0x5bbfu32) }),
0x3d4a => Some(unsafe { transmute(0x6dd1u32) }),
0x3d4b => Some(unsafe { transmute(0x795du32) }),
0x3d4c => Some(unsafe { transmute(0x7e2eu32) }),
0x3d4d => Some(unsafe { transmute(0x7c9bu32) }),
0x3d4e => Some(unsafe { transmute(0x587eu32) }),
0x3d4f => Some(unsafe { transmute(0x719fu32) }),
0x3d50 => Some(unsafe { transmute(0x51fau32) }),
0x3d51 => Some(unsafe { transmute(0x8853u32) }),
0x3d52 => Some(unsafe { transmute(0x8ff0u32) }),
0x3d53 => Some(unsafe { transmute(0x4fcau32) }),
0x3d54 => Some(unsafe { transmute(0x5cfbu32) }),
0x3d55 => Some(unsafe { transmute(0x6625u32) }),
0x3d56 => Some(unsafe { transmute(0x77acu32) }),
0x3d57 => Some(unsafe { transmute(0x7ae3u32) }),
0x3d58 => Some(unsafe { transmute(0x821cu32) }),
0x3d59 => Some(unsafe { transmute(0x99ffu32) }),
0x3d5a => Some(unsafe { transmute(0x51c6u32) }),
0x3d5b => Some(unsafe { transmute(0x5faau32) }),
0x3d5c => Some(unsafe { transmute(0x65ecu32) }),
0x3d5d => Some(unsafe { transmute(0x696fu32) }),
0x3d5e => Some(unsafe { transmute(0x6b89u32) }),
0x3d5f => Some(unsafe { transmute(0x6df3u32) }),
0x3d60 => Some(unsafe { transmute(0x6e96u32) }),
0x3d61 => Some(unsafe { transmute(0x6f64u32) }),
0x3d62 => Some(unsafe { transmute(0x76feu32) }),
0x3d63 => Some(unsafe { transmute(0x7d14u32) }),
0x3d64 => Some(unsafe { transmute(0x5de1u32) }),
0x3d65 => Some(unsafe { transmute(0x9075u32) }),
0x3d66 => Some(unsafe { transmute(0x9187u32) }),
0x3d67 => Some(unsafe { transmute(0x9806u32) }),
0x3d68 => Some(unsafe { transmute(0x51e6u32) }),
0x3d69 => Some(unsafe { transmute(0x521du32) }),
0x3d6a => Some(unsafe { transmute(0x6240u32) }),
0x3d6b => Some(unsafe { transmute(0x6691u32) }),
0x3d6c => Some(unsafe { transmute(0x66d9u32) }),
0x3d6d => Some(unsafe { transmute(0x6e1au32) }),
0x3d6e => Some(unsafe { transmute(0x5eb6u32) }),
0x3d6f => Some(unsafe { transmute(0x7dd2u32) }),
0x3d70 => Some(unsafe { transmute(0x7f72u32) }),
0x3d71 => Some(unsafe { transmute(0x66f8u32) }),
0x3d72 => Some(unsafe { transmute(0x85afu32) }),
0x3d73 => Some(unsafe { transmute(0x85f7u32) }),
0x3d74 => Some(unsafe { transmute(0x8af8u32) }),
0x3d75 => Some(unsafe { transmute(0x52a9u32) }),
0x3d76 => Some(unsafe { transmute(0x53d9u32) }),
0x3d77 => Some(unsafe { transmute(0x5973u32) }),
0x3d78 => Some(unsafe { transmute(0x5e8fu32) }),
0x3d79 => Some(unsafe { transmute(0x5f90u32) }),
0x3d7a => Some(unsafe { transmute(0x6055u32) }),
0x3d7b => Some(unsafe { transmute(0x92e4u32) }),
0x3d7c => Some(unsafe { transmute(0x9664u32) }),
0x3d7d => Some(unsafe { transmute(0x50b7u32) }),
0x3d7e => Some(unsafe { transmute(0x511fu32) }),
0x3e21 => Some(unsafe { transmute(0x52ddu32) }),
0x3e22 => Some(unsafe { transmute(0x5320u32) }),
0x3e23 => Some(unsafe { transmute(0x5347u32) }),
0x3e24 => Some(unsafe { transmute(0x53ecu32) }),
0x3e25 => Some(unsafe { transmute(0x54e8u32) }),
0x3e26 => Some(unsafe { transmute(0x5546u32) }),
0x3e27 => Some(unsafe { transmute(0x5531u32) }),
0x3e28 => Some(unsafe { transmute(0x5617u32) }),
0x3e29 => Some(unsafe { transmute(0x5968u32) }),
0x3e2a => Some(unsafe { transmute(0x59beu32) }),
0x3e2b => Some(unsafe { transmute(0x5a3cu32) }),
0x3e2c => Some(unsafe { transmute(0x5bb5u32) }),
0x3e2d => Some(unsafe { transmute(0x5c06u32) }),
0x3e2e => Some(unsafe { transmute(0x5c0fu32) }),
0x3e2f => Some(unsafe { transmute(0x5c11u32) }),
0x3e30 => Some(unsafe { transmute(0x5c1au32) }),
0x3e31 => Some(unsafe { transmute(0x5e84u32) }),
0x3e32 => Some(unsafe { transmute(0x5e8au32) }),
0x3e33 => Some(unsafe { transmute(0x5ee0u32) }),
0x3e34 => Some(unsafe { transmute(0x5f70u32) }),
0x3e35 => Some(unsafe { transmute(0x627fu32) }),
0x3e36 => Some(unsafe { transmute(0x6284u32) }),
0x3e37 => Some(unsafe { transmute(0x62dbu32) }),
0x3e38 => Some(unsafe { transmute(0x638cu32) }),
0x3e39 => Some(unsafe { transmute(0x6377u32) }),
0x3e3a => Some(unsafe { transmute(0x6607u32) }),
0x3e3b => Some(unsafe { transmute(0x660cu32) }),
0x3e3c => Some(unsafe { transmute(0x662du32) }),
0x3e3d => Some(unsafe { transmute(0x6676u32) }),
0x3e3e => Some(unsafe { transmute(0x677eu32) }),
0x3e3f => Some(unsafe { transmute(0x68a2u32) }),
0x3e40 => Some(unsafe { transmute(0x6a1fu32) }),
0x3e41 => Some(unsafe { transmute(0x6a35u32) }),
0x3e42 => Some(unsafe { transmute(0x6cbcu32) }),
0x3e43 => Some(unsafe { transmute(0x6d88u32) }),
0x3e44 => Some(unsafe { transmute(0x6e09u32) }),
0x3e45 => Some(unsafe { transmute(0x6e58u32) }),
0x3e46 => Some(unsafe { transmute(0x713cu32) }),
0x3e47 => Some(unsafe { transmute(0x7126u32) }),
0x3e48 => Some(unsafe { transmute(0x7167u32) }),
0x3e49 => Some(unsafe { transmute(0x75c7u32) }),
0x3e4a => Some(unsafe { transmute(0x7701u32) }),
0x3e4b => Some(unsafe { transmute(0x785du32) }),
0x3e4c => Some(unsafe { transmute(0x7901u32) }),
0x3e4d => Some(unsafe { transmute(0x7965u32) }),
0x3e4e => Some(unsafe { transmute(0x79f0u32) }),
0x3e4f => Some(unsafe { transmute(0x7ae0u32) }),
0x3e50 => Some(unsafe { transmute(0x7b11u32) }),
0x3e51 => Some(unsafe { transmute(0x7ca7u32) }),
0x3e52 => Some(unsafe { transmute(0x7d39u32) }),
0x3e53 => Some(unsafe { transmute(0x8096u32) }),
0x3e54 => Some(unsafe { transmute(0x83d6u32) }),
0x3e55 => Some(unsafe { transmute(0x848bu32) }),
0x3e56 => Some(unsafe { transmute(0x8549u32) }),
0x3e57 => Some(unsafe { transmute(0x885du32) }),
0x3e58 => Some(unsafe { transmute(0x88f3u32) }),
0x3e59 => Some(unsafe { transmute(0x8a1fu32) }),
0x3e5a => Some(unsafe { transmute(0x8a3cu32) }),
0x3e5b => Some(unsafe { transmute(0x8a54u32) }),
0x3e5c => Some(unsafe { transmute(0x8a73u32) }),
0x3e5d => Some(unsafe { transmute(0x8c61u32) }),
0x3e5e => Some(unsafe { transmute(0x8cdeu32) }),
0x3e5f => Some(unsafe { transmute(0x91a4u32) }),
0x3e60 => Some(unsafe { transmute(0x9266u32) }),
0x3e61 => Some(unsafe { transmute(0x937eu32) }),
0x3e62 => Some(unsafe { transmute(0x9418u32) }),
0x3e63 => Some(unsafe { transmute(0x969cu32) }),
0x3e64 => Some(unsafe { transmute(0x9798u32) }),
0x3e65 => Some(unsafe { transmute(0x4e0au32) }),
0x3e66 => Some(unsafe { transmute(0x4e08u32) }),
0x3e67 => Some(unsafe { transmute(0x4e1eu32) }),
0x3e68 => Some(unsafe { transmute(0x4e57u32) }),
0x3e69 => Some(unsafe { transmute(0x5197u32) }),
0x3e6a => Some(unsafe { transmute(0x5270u32) }),
0x3e6b => Some(unsafe { transmute(0x57ceu32) }),
0x3e6c => Some(unsafe { transmute(0x5834u32) }),
0x3e6d => Some(unsafe { transmute(0x58ccu32) }),
0x3e6e => Some(unsafe { transmute(0x5b22u32) }),
0x3e6f => Some(unsafe { transmute(0x5e38u32) }),
0x3e70 => Some(unsafe { transmute(0x60c5u32) }),
0x3e71 => Some(unsafe { transmute(0x64feu32) }),
0x3e72 => Some(unsafe { transmute(0x6761u32) }),
0x3e73 => Some(unsafe { transmute(0x6756u32) }),
0x3e74 => Some(unsafe { transmute(0x6d44u32) }),
0x3e75 => Some(unsafe { transmute(0x72b6u32) }),
0x3e76 => Some(unsafe { transmute(0x7573u32) }),
0x3e77 => Some(unsafe { transmute(0x7a63u32) }),
0x3e78 => Some(unsafe { transmute(0x84b8u32) }),
0x3e79 => Some(unsafe { transmute(0x8b72u32) }),
0x3e7a => Some(unsafe { transmute(0x91b8u32) }),
0x3e7b => Some(unsafe { transmute(0x9320u32) }),
0x3e7c => Some(unsafe { transmute(0x5631u32) }),
0x3e7d => Some(unsafe { transmute(0x57f4u32) }),
0x3e7e => Some(unsafe { transmute(0x98feu32) }),
0x3f21 => Some(unsafe { transmute(0x62edu32) }),
0x3f22 => Some(unsafe { transmute(0x690du32) }),
0x3f23 => Some(unsafe { transmute(0x6b96u32) }),
0x3f24 => Some(unsafe { transmute(0x71edu32) }),
0x3f25 => Some(unsafe { transmute(0x7e54u32) }),
0x3f26 => Some(unsafe { transmute(0x8077u32) }),
0x3f27 => Some(unsafe { transmute(0x8272u32) }),
0x3f28 => Some(unsafe { transmute(0x89e6u32) }),
0x3f29 => Some(unsafe { transmute(0x98dfu32) }),
0x3f2a => Some(unsafe { transmute(0x8755u32) }),
0x3f2b => Some(unsafe { transmute(0x8fb1u32) }),
0x3f2c => Some(unsafe { transmute(0x5c3bu32) }),
0x3f2d => Some(unsafe { transmute(0x4f38u32) }),
0x3f2e => Some(unsafe { transmute(0x4fe1u32) }),
0x3f2f => Some(unsafe { transmute(0x4fb5u32) }),
0x3f30 => Some(unsafe { transmute(0x5507u32) }),
0x3f31 => Some(unsafe { transmute(0x5a20u32) }),
0x3f32 => Some(unsafe { transmute(0x5bddu32) }),
0x3f33 => Some(unsafe { transmute(0x5be9u32) }),
0x3f34 => Some(unsafe { transmute(0x5fc3u32) }),
0x3f35 => Some(unsafe { transmute(0x614eu32) }),
0x3f36 => Some(unsafe { transmute(0x632fu32) }),
0x3f37 => Some(unsafe { transmute(0x65b0u32) }),
0x3f38 => Some(unsafe { transmute(0x664bu32) }),
0x3f39 => Some(unsafe { transmute(0x68eeu32) }),
0x3f3a => Some(unsafe { transmute(0x699bu32) }),
0x3f3b => Some(unsafe { transmute(0x6d78u32) }),
0x3f3c => Some(unsafe { transmute(0x6df1u32) }),
0x3f3d => Some(unsafe { transmute(0x7533u32) }),
0x3f3e => Some(unsafe { transmute(0x75b9u32) }),
0x3f3f => Some(unsafe { transmute(0x771fu32) }),
0x3f40 => Some(unsafe { transmute(0x795eu32) }),
0x3f41 => Some(unsafe { transmute(0x79e6u32) }),
0x3f42 => Some(unsafe { transmute(0x7d33u32) }),
0x3f43 => Some(unsafe { transmute(0x81e3u32) }),
0x3f44 => Some(unsafe { transmute(0x82afu32) }),
0x3f45 => Some(unsafe { transmute(0x85aau32) }),
0x3f46 => Some(unsafe { transmute(0x89aau32) }),
0x3f47 => Some(unsafe { transmute(0x8a3au32) }),
0x3f48 => Some(unsafe { transmute(0x8eabu32) }),
0x3f49 => Some(unsafe { transmute(0x8f9bu32) }),
0x3f4a => Some(unsafe { transmute(0x9032u32) }),
0x3f4b => Some(unsafe { transmute(0x91ddu32) }),
0x3f4c => Some(unsafe { transmute(0x9707u32) }),
0x3f4d => Some(unsafe { transmute(0x4ebau32) }),
0x3f4e => Some(unsafe { transmute(0x4ec1u32) }),
0x3f4f => Some(unsafe { transmute(0x5203u32) }),
0x3f50 => Some(unsafe { transmute(0x5875u32) }),
0x3f51 => Some(unsafe { transmute(0x58ecu32) }),
0x3f52 => Some(unsafe { transmute(0x5c0bu32) }),
0x3f53 => Some(unsafe { transmute(0x751au32) }),
0x3f54 => Some(unsafe { transmute(0x5c3du32) }),
0x3f55 => Some(unsafe { transmute(0x814eu32) }),
0x3f56 => Some(unsafe { transmute(0x8a0au32) }),
0x3f57 => Some(unsafe { transmute(0x8fc5u32) }),
0x3f58 => Some(unsafe { transmute(0x9663u32) }),
0x3f59 => Some(unsafe { transmute(0x976du32) }),
0x3f5a => Some(unsafe { transmute(0x7b25u32) }),
0x3f5b => Some(unsafe { transmute(0x8acfu32) }),
0x3f5c => Some(unsafe { transmute(0x9808u32) }),
0x3f5d => Some(unsafe { transmute(0x9162u32) }),
0x3f5e => Some(unsafe { transmute(0x56f3u32) }),
0x3f5f => Some(unsafe { transmute(0x53a8u32) }),
0x3f60 => Some(unsafe { transmute(0x9017u32) }),
0x3f61 => Some(unsafe { transmute(0x5439u32) }),
0x3f62 => Some(unsafe { transmute(0x5782u32) }),
0x3f63 => Some(unsafe { transmute(0x5e25u32) }),
0x3f64 => Some(unsafe { transmute(0x63a8u32) }),
0x3f65 => Some(unsafe { transmute(0x6c34u32) }),
0x3f66 => Some(unsafe { transmute(0x708au32) }),
0x3f67 => Some(unsafe { transmute(0x7761u32) }),
0x3f68 => Some(unsafe { transmute(0x7c8bu32) }),
0x3f69 => Some(unsafe { transmute(0x7fe0u32) }),
0x3f6a => Some(unsafe { transmute(0x8870u32) }),
0x3f6b => Some(unsafe { transmute(0x9042u32) }),
0x3f6c => Some(unsafe { transmute(0x9154u32) }),
0x3f6d => Some(unsafe { transmute(0x9310u32) }),
0x3f6e => Some(unsafe { transmute(0x9318u32) }),
0x3f6f => Some(unsafe { transmute(0x968fu32) }),
0x3f70 => Some(unsafe { transmute(0x745eu32) }),
0x3f71 => Some(unsafe { transmute(0x9ac4u32) }),
0x3f72 => Some(unsafe { transmute(0x5d07u32) }),
0x3f73 => Some(unsafe { transmute(0x5d69u32) }),
0x3f74 => Some(unsafe { transmute(0x6570u32) }),
0x3f75 => Some(unsafe { transmute(0x67a2u32) }),
0x3f76 => Some(unsafe { transmute(0x8da8u32) }),
0x3f77 => Some(unsafe { transmute(0x96dbu32) }),
0x3f78 => Some(unsafe { transmute(0x636eu32) }),
0x3f79 => Some(unsafe { transmute(0x6749u32) }),
0x3f7a => Some(unsafe { transmute(0x6919u32) }),
0x3f7b => Some(unsafe { transmute(0x83c5u32) }),
0x3f7c => Some(unsafe { transmute(0x9817u32) }),
0x3f7d => Some(unsafe { transmute(0x96c0u32) }),
0x3f7e => Some(unsafe { transmute(0x88feu32) }),
0x4021 => Some(unsafe { transmute(0x6f84u32) }),
0x4022 => Some(unsafe { transmute(0x647au32) }),
0x4023 => Some(unsafe { transmute(0x5bf8u32) }),
0x4024 => Some(unsafe { transmute(0x4e16u32) }),
0x4025 => Some(unsafe { transmute(0x702cu32) }),
0x4026 => Some(unsafe { transmute(0x755du32) }),
0x4027 => Some(unsafe { transmute(0x662fu32) }),
0x4028 => Some(unsafe { transmute(0x51c4u32) }),
0x4029 => Some(unsafe { transmute(0x5236u32) }),
0x402a => Some(unsafe { transmute(0x52e2u32) }),
0x402b => Some(unsafe { transmute(0x59d3u32) }),
0x402c => Some(unsafe { transmute(0x5f81u32) }),
0x402d => Some(unsafe { transmute(0x6027u32) }),
0x402e => Some(unsafe { transmute(0x6210u32) }),
0x402f => Some(unsafe { transmute(0x653fu32) }),
0x4030 => Some(unsafe { transmute(0x6574u32) }),
0x4031 => Some(unsafe { transmute(0x661fu32) }),
0x4032 => Some(unsafe { transmute(0x6674u32) }),
0x4033 => Some(unsafe { transmute(0x68f2u32) }),
0x4034 => Some(unsafe { transmute(0x6816u32) }),
0x4035 => Some(unsafe { transmute(0x6b63u32) }),
0x4036 => Some(unsafe { transmute(0x6e05u32) }),
0x4037 => Some(unsafe { transmute(0x7272u32) }),
0x4038 => Some(unsafe { transmute(0x751fu32) }),
0x4039 => Some(unsafe { transmute(0x76dbu32) }),
0x403a => Some(unsafe { transmute(0x7cbeu32) }),
0x403b => Some(unsafe { transmute(0x8056u32) }),
0x403c => Some(unsafe { transmute(0x58f0u32) }),
0x403d => Some(unsafe { transmute(0x88fdu32) }),
0x403e => Some(unsafe { transmute(0x897fu32) }),
0x403f => Some(unsafe { transmute(0x8aa0u32) }),
0x4040 => Some(unsafe { transmute(0x8a93u32) }),
0x4041 => Some(unsafe { transmute(0x8acbu32) }),
0x4042 => Some(unsafe { transmute(0x901du32) }),
0x4043 => Some(unsafe { transmute(0x9192u32) }),
0x4044 => Some(unsafe { transmute(0x9752u32) }),
0x4045 => Some(unsafe { transmute(0x9759u32) }),
0x4046 => Some(unsafe { transmute(0x6589u32) }),
0x4047 => Some(unsafe { transmute(0x7a0eu32) }),
0x4048 => Some(unsafe { transmute(0x8106u32) }),
0x4049 => Some(unsafe { transmute(0x96bbu32) }),
0x404a => Some(unsafe { transmute(0x5e2du32) }),
0x404b => Some(unsafe { transmute(0x60dcu32) }),
0x404c => Some(unsafe { transmute(0x621au32) }),
0x404d => Some(unsafe { transmute(0x65a5u32) }),
0x404e => Some(unsafe { transmute(0x6614u32) }),
0x404f => Some(unsafe { transmute(0x6790u32) }),
0x4050 => Some(unsafe { transmute(0x77f3u32) }),
0x4051 => Some(unsafe { transmute(0x7a4du32) }),
0x4052 => Some(unsafe { transmute(0x7c4du32) }),
0x4053 => Some(unsafe { transmute(0x7e3eu32) }),
0x4054 => Some(unsafe { transmute(0x810au32) }),
0x4055 => Some(unsafe { transmute(0x8cacu32) }),
0x4056 => Some(unsafe { transmute(0x8d64u32) }),
0x4057 => Some(unsafe { transmute(0x8de1u32) }),
0x4058 => Some(unsafe { transmute(0x8e5fu32) }),
0x4059 => Some(unsafe { transmute(0x78a9u32) }),
0x405a => Some(unsafe { transmute(0x5207u32) }),
0x405b => Some(unsafe { transmute(0x62d9u32) }),
0x405c => Some(unsafe { transmute(0x63a5u32) }),
0x405d => Some(unsafe { transmute(0x6442u32) }),
0x405e => Some(unsafe { transmute(0x6298u32) }),
0x405f => Some(unsafe { transmute(0x8a2du32) }),
0x4060 => Some(unsafe { transmute(0x7a83u32) }),
0x4061 => Some(unsafe { transmute(0x7bc0u32) }),
0x4062 => Some(unsafe { transmute(0x8aacu32) }),
0x4063 => Some(unsafe { transmute(0x96eau32) }),
0x4064 => Some(unsafe { transmute(0x7d76u32) }),
0x4065 => Some(unsafe { transmute(0x820cu32) }),
0x4066 => Some(unsafe { transmute(0x8749u32) }),
0x4067 => Some(unsafe { transmute(0x4ed9u32) }),
0x4068 => Some(unsafe { transmute(0x5148u32) }),
0x4069 => Some(unsafe { transmute(0x5343u32) }),
0x406a => Some(unsafe { transmute(0x5360u32) }),
0x406b => Some(unsafe { transmute(0x5ba3u32) }),
0x406c => Some(unsafe { transmute(0x5c02u32) }),
0x406d => Some(unsafe { transmute(0x5c16u32) }),
0x406e => Some(unsafe { transmute(0x5dddu32) }),
0x406f => Some(unsafe { transmute(0x6226u32) }),
0x4070 => Some(unsafe { transmute(0x6247u32) }),
0x4071 => Some(unsafe { transmute(0x64b0u32) }),
0x4072 => Some(unsafe { transmute(0x6813u32) }),
0x4073 => Some(unsafe { transmute(0x6834u32) }),
0x4074 => Some(unsafe { transmute(0x6cc9u32) }),
0x4075 => Some(unsafe { transmute(0x6d45u32) }),
0x4076 => Some(unsafe { transmute(0x6d17u32) }),
0x4077 => Some(unsafe { transmute(0x67d3u32) }),
0x4078 => Some(unsafe { transmute(0x6f5cu32) }),
0x4079 => Some(unsafe { transmute(0x714eu32) }),
0x407a => Some(unsafe { transmute(0x717du32) }),
0x407b => Some(unsafe { transmute(0x65cbu32) }),
0x407c => Some(unsafe { transmute(0x7a7fu32) }),
0x407d => Some(unsafe { transmute(0x7badu32) }),
0x407e => Some(unsafe { transmute(0x7ddau32) }),
0x4121 => Some(unsafe { transmute(0x7e4au32) }),
0x4122 => Some(unsafe { transmute(0x7fa8u32) }),
0x4123 => Some(unsafe { transmute(0x817au32) }),
0x4124 => Some(unsafe { transmute(0x821bu32) }),
0x4125 => Some(unsafe { transmute(0x8239u32) }),
0x4126 => Some(unsafe { transmute(0x85a6u32) }),
0x4127 => Some(unsafe { transmute(0x8a6eu32) }),
0x4128 => Some(unsafe { transmute(0x8cceu32) }),
0x4129 => Some(unsafe { transmute(0x8df5u32) }),
0x412a => Some(unsafe { transmute(0x9078u32) }),
0x412b => Some(unsafe { transmute(0x9077u32) }),
0x412c => Some(unsafe { transmute(0x92adu32) }),
0x412d => Some(unsafe { transmute(0x9291u32) }),
0x412e => Some(unsafe { transmute(0x9583u32) }),
0x412f => Some(unsafe { transmute(0x9baeu32) }),
0x4130 => Some(unsafe { transmute(0x524du32) }),
0x4131 => Some(unsafe { transmute(0x5584u32) }),
0x4132 => Some(unsafe { transmute(0x6f38u32) }),
0x4133 => Some(unsafe { transmute(0x7136u32) }),
0x4134 => Some(unsafe { transmute(0x5168u32) }),
0x4135 => Some(unsafe { transmute(0x7985u32) }),
0x4136 => Some(unsafe { transmute(0x7e55u32) }),
0x4137 => Some(unsafe { transmute(0x81b3u32) }),
0x4138 => Some(unsafe { transmute(0x7cceu32) }),
0x4139 => Some(unsafe { transmute(0x564cu32) }),
0x413a => Some(unsafe { transmute(0x5851u32) }),
0x413b => Some(unsafe { transmute(0x5ca8u32) }),
0x413c => Some(unsafe { transmute(0x63aau32) }),
0x413d => Some(unsafe { transmute(0x66feu32) }),
0x413e => Some(unsafe { transmute(0x66fdu32) }),
0x413f => Some(unsafe { transmute(0x695au32) }),
0x4140 => Some(unsafe { transmute(0x72d9u32) }),
0x4141 => Some(unsafe { transmute(0x758fu32) }),
0x4142 => Some(unsafe { transmute(0x758eu32) }),
0x4143 => Some(unsafe { transmute(0x790eu32) }),
0x4144 => Some(unsafe { transmute(0x7956u32) }),
0x4145 => Some(unsafe { transmute(0x79dfu32) }),
0x4146 => Some(unsafe { transmute(0x7c97u32) }),
0x4147 => Some(unsafe { transmute(0x7d20u32) }),
0x4148 => Some(unsafe { transmute(0x7d44u32) }),
0x4149 => Some(unsafe { transmute(0x8607u32) }),
0x414a => Some(unsafe { transmute(0x8a34u32) }),
0x414b => Some(unsafe { transmute(0x963bu32) }),
0x414c => Some(unsafe { transmute(0x9061u32) }),
0x414d => Some(unsafe { transmute(0x9f20u32) }),
0x414e => Some(unsafe { transmute(0x50e7u32) }),
0x414f => Some(unsafe { transmute(0x5275u32) }),
0x4150 => Some(unsafe { transmute(0x53ccu32) }),
0x4151 => Some(unsafe { transmute(0x53e2u32) }),
0x4152 => Some(unsafe { transmute(0x5009u32) }),
0x4153 => Some(unsafe { transmute(0x55aau32) }),
0x4154 => Some(unsafe { transmute(0x58eeu32) }),
0x4155 => Some(unsafe { transmute(0x594fu32) }),
0x4156 => Some(unsafe { transmute(0x723du32) }),
0x4157 => Some(unsafe { transmute(0x5b8bu32) }),
0x4158 => Some(unsafe { transmute(0x5c64u32) }),
0x4159 => Some(unsafe { transmute(0x531du32) }),
0x415a => Some(unsafe { transmute(0x60e3u32) }),
0x415b => Some(unsafe { transmute(0x60f3u32) }),
0x415c => Some(unsafe { transmute(0x635cu32) }),
0x415d => Some(unsafe { transmute(0x6383u32) }),
0x415e => Some(unsafe { transmute(0x633fu32) }),
0x415f => Some(unsafe { transmute(0x63bbu32) }),
0x4160 => Some(unsafe { transmute(0x64cdu32) }),
0x4161 => Some(unsafe { transmute(0x65e9u32) }),
0x4162 => Some(unsafe { transmute(0x66f9u32) }),
0x4163 => Some(unsafe { transmute(0x5de3u32) }),
0x4164 => Some(unsafe { transmute(0x69cdu32) }),
0x4165 => Some(unsafe { transmute(0x69fdu32) }),
0x4166 => Some(unsafe { transmute(0x6f15u32) }),
0x4167 => Some(unsafe { transmute(0x71e5u32) }),
0x4168 => Some(unsafe { transmute(0x4e89u32) }),
0x4169 => Some(unsafe { transmute(0x75e9u32) }),
0x416a => Some(unsafe { transmute(0x76f8u32) }),
0x416b => Some(unsafe { transmute(0x7a93u32) }),
0x416c => Some(unsafe { transmute(0x7cdfu32) }),
0x416d => Some(unsafe { transmute(0x7dcfu32) }),
0x416e => Some(unsafe { transmute(0x7d9cu32) }),
0x416f => Some(unsafe { transmute(0x8061u32) }),
0x4170 => Some(unsafe { transmute(0x8349u32) }),
0x4171 => Some(unsafe { transmute(0x8358u32) }),
0x4172 => Some(unsafe { transmute(0x846cu32) }),
0x4173 => Some(unsafe { transmute(0x84bcu32) }),
0x4174 => Some(unsafe { transmute(0x85fbu32) }),
0x4175 => Some(unsafe { transmute(0x88c5u32) }),
0x4176 => Some(unsafe { transmute(0x8d70u32) }),
0x4177 => Some(unsafe { transmute(0x9001u32) }),
0x4178 => Some(unsafe { transmute(0x906du32) }),
0x4179 => Some(unsafe { transmute(0x9397u32) }),
0x417a => Some(unsafe { transmute(0x971cu32) }),
0x417b => Some(unsafe { transmute(0x9a12u32) }),
0x417c => Some(unsafe { transmute(0x50cfu32) }),
0x417d => Some(unsafe { transmute(0x5897u32) }),
0x417e => Some(unsafe { transmute(0x618eu32) }),
0x4221 => Some(unsafe { transmute(0x81d3u32) }),
0x4222 => Some(unsafe { transmute(0x8535u32) }),
0x4223 => Some(unsafe { transmute(0x8d08u32) }),
0x4224 => Some(unsafe { transmute(0x9020u32) }),
0x4225 => Some(unsafe { transmute(0x4fc3u32) }),
0x4226 => Some(unsafe { transmute(0x5074u32) }),
0x4227 => Some(unsafe { transmute(0x5247u32) }),
0x4228 => Some(unsafe { transmute(0x5373u32) }),
0x4229 => Some(unsafe { transmute(0x606fu32) }),
0x422a => Some(unsafe { transmute(0x6349u32) }),
0x422b => Some(unsafe { transmute(0x675fu32) }),
0x422c => Some(unsafe { transmute(0x6e2cu32) }),
0x422d => Some(unsafe { transmute(0x8db3u32) }),
0x422e => Some(unsafe { transmute(0x901fu32) }),
0x422f => Some(unsafe { transmute(0x4fd7u32) }),
0x4230 => Some(unsafe { transmute(0x5c5eu32) }),
0x4231 => Some(unsafe { transmute(0x8ccau32) }),
0x4232 => Some(unsafe { transmute(0x65cfu32) }),
0x4233 => Some(unsafe { transmute(0x7d9au32) }),
0x4234 => Some(unsafe { transmute(0x5352u32) }),
0x4235 => Some(unsafe { transmute(0x8896u32) }),
0x4236 => Some(unsafe { transmute(0x5176u32) }),
0x4237 => Some(unsafe { transmute(0x63c3u32) }),
0x4238 => Some(unsafe { transmute(0x5b58u32) }),
0x4239 => Some(unsafe { transmute(0x5b6bu32) }),
0x423a => Some(unsafe { transmute(0x5c0au32) }),
0x423b => Some(unsafe { transmute(0x640du32) }),
0x423c => Some(unsafe { transmute(0x6751u32) }),
0x423d => Some(unsafe { transmute(0x905cu32) }),
0x423e => Some(unsafe { transmute(0x4ed6u32) }),
0x423f => Some(unsafe { transmute(0x591au32) }),
0x4240 => Some(unsafe { transmute(0x592au32) }),
0x4241 => Some(unsafe { transmute(0x6c70u32) }),
0x4242 => Some(unsafe { transmute(0x8a51u32) }),
0x4243 => Some(unsafe { transmute(0x553eu32) }),
0x4244 => Some(unsafe { transmute(0x5815u32) }),
0x4245 => Some(unsafe { transmute(0x59a5u32) }),
0x4246 => Some(unsafe { transmute(0x60f0u32) }),
0x4247 => Some(unsafe { transmute(0x6253u32) }),
0x4248 => Some(unsafe { transmute(0x67c1u32) }),
0x4249 => Some(unsafe { transmute(0x8235u32) }),
0x424a => Some(unsafe { transmute(0x6955u32) }),
0x424b => Some(unsafe { transmute(0x9640u32) }),
0x424c => Some(unsafe { transmute(0x99c4u32) }),
0x424d => Some(unsafe { transmute(0x9a28u32) }),
0x424e => Some(unsafe { transmute(0x4f53u32) }),
0x424f => Some(unsafe { transmute(0x5806u32) }),
0x4250 => Some(unsafe { transmute(0x5bfeu32) }),
0x4251 => Some(unsafe { transmute(0x8010u32) }),
0x4252 => Some(unsafe { transmute(0x5cb1u32) }),
0x4253 => Some(unsafe { transmute(0x5e2fu32) }),
0x4254 => Some(unsafe { transmute(0x5f85u32) }),
0x4255 => Some(unsafe { transmute(0x6020u32) }),
0x4256 => Some(unsafe { transmute(0x614bu32) }),
0x4257 => Some(unsafe { transmute(0x6234u32) }),
0x4258 => Some(unsafe { transmute(0x66ffu32) }),
0x4259 => Some(unsafe { transmute(0x6cf0u32) }),
0x425a => Some(unsafe { transmute(0x6edeu32) }),
0x425b => Some(unsafe { transmute(0x80ceu32) }),
0x425c => Some(unsafe { transmute(0x817fu32) }),
0x425d => Some(unsafe { transmute(0x82d4u32) }),
0x425e => Some(unsafe { transmute(0x888bu32) }),
0x425f => Some(unsafe { transmute(0x8cb8u32) }),
0x4260 => Some(unsafe { transmute(0x9000u32) }),
0x4261 => Some(unsafe { transmute(0x902eu32) }),
0x4262 => Some(unsafe { transmute(0x968au32) }),
0x4263 => Some(unsafe { transmute(0x9edbu32) }),
0x4264 => Some(unsafe { transmute(0x9bdbu32) }),
0x4265 => Some(unsafe { transmute(0x4ee3u32) }),
0x4266 => Some(unsafe { transmute(0x53f0u32) }),
0x4267 => Some(unsafe { transmute(0x5927u32) }),
0x4268 => Some(unsafe { transmute(0x7b2cu32) }),
0x4269 => Some(unsafe { transmute(0x918du32) }),
0x426a => Some(unsafe { transmute(0x984cu32) }),
0x426b => Some(unsafe { transmute(0x9df9u32) }),
0x426c => Some(unsafe { transmute(0x6eddu32) }),
0x426d => Some(unsafe { transmute(0x7027u32) }),
0x426e => Some(unsafe { transmute(0x5353u32) }),
0x426f => Some(unsafe { transmute(0x5544u32) }),
0x4270 => Some(unsafe { transmute(0x5b85u32) }),
0x4271 => Some(unsafe { transmute(0x6258u32) }),
0x4272 => Some(unsafe { transmute(0x629eu32) }),
0x4273 => Some(unsafe { transmute(0x62d3u32) }),
0x4274 => Some(unsafe { transmute(0x6ca2u32) }),
0x4275 => Some(unsafe { transmute(0x6fefu32) }),
0x4276 => Some(unsafe { transmute(0x7422u32) }),
0x4277 => Some(unsafe { transmute(0x8a17u32) }),
0x4278 => Some(unsafe { transmute(0x9438u32) }),
0x4279 => Some(unsafe { transmute(0x6fc1u32) }),
0x427a => Some(unsafe { transmute(0x8afeu32) }),
0x427b => Some(unsafe { transmute(0x8338u32) }),
0x427c => Some(unsafe { transmute(0x51e7u32) }),
0x427d => Some(unsafe { transmute(0x86f8u32) }),
0x427e => Some(unsafe { transmute(0x53eau32) }),
0x4321 => Some(unsafe { transmute(0x53e9u32) }),
0x4322 => Some(unsafe { transmute(0x4f46u32) }),
0x4323 => Some(unsafe { transmute(0x9054u32) }),
0x4324 => Some(unsafe { transmute(0x8fb0u32) }),
0x4325 => Some(unsafe { transmute(0x596au32) }),
0x4326 => Some(unsafe { transmute(0x8131u32) }),
0x4327 => Some(unsafe { transmute(0x5dfdu32) }),
0x4328 => Some(unsafe { transmute(0x7aeau32) }),
0x4329 => Some(unsafe { transmute(0x8fbfu32) }),
0x432a => Some(unsafe { transmute(0x68dau32) }),
0x432b => Some(unsafe { transmute(0x8c37u32) }),
0x432c => Some(unsafe { transmute(0x72f8u32) }),
0x432d => Some(unsafe { transmute(0x9c48u32) }),
0x432e => Some(unsafe { transmute(0x6a3du32) }),
0x432f => Some(unsafe { transmute(0x8ab0u32) }),
0x4330 => Some(unsafe { transmute(0x4e39u32) }),
0x4331 => Some(unsafe { transmute(0x5358u32) }),
0x4332 => Some(unsafe { transmute(0x5606u32) }),
0x4333 => Some(unsafe { transmute(0x5766u32) }),
0x4334 => Some(unsafe { transmute(0x62c5u32) }),
0x4335 => Some(unsafe { transmute(0x63a2u32) }),
0x4336 => Some(unsafe { transmute(0x65e6u32) }),
0x4337 => Some(unsafe { transmute(0x6b4eu32) }),
0x4338 => Some(unsafe { transmute(0x6de1u32) }),
0x4339 => Some(unsafe { transmute(0x6e5bu32) }),
0x433a => Some(unsafe { transmute(0x70adu32) }),
0x433b => Some(unsafe { transmute(0x77edu32) }),
0x433c => Some(unsafe { transmute(0x7aefu32) }),
0x433d => Some(unsafe { transmute(0x7baau32) }),
0x433e => Some(unsafe { transmute(0x7dbbu32) }),
0x433f => Some(unsafe { transmute(0x803du32) }),
0x4340 => Some(unsafe { transmute(0x80c6u32) }),
0x4341 => Some(unsafe { transmute(0x86cbu32) }),
0x4342 => Some(unsafe { transmute(0x8a95u32) }),
0x4343 => Some(unsafe { transmute(0x935bu32) }),
0x4344 => Some(unsafe { transmute(0x56e3u32) }),
0x4345 => Some(unsafe { transmute(0x58c7u32) }),
0x4346 => Some(unsafe { transmute(0x5f3eu32) }),
0x4347 => Some(unsafe { transmute(0x65adu32) }),
0x4348 => Some(unsafe { transmute(0x6696u32) }),
0x4349 => Some(unsafe { transmute(0x6a80u32) }),
0x434a => Some(unsafe { transmute(0x6bb5u32) }),
0x434b => Some(unsafe { transmute(0x7537u32) }),
0x434c => Some(unsafe { transmute(0x8ac7u32) }),
0x434d => Some(unsafe { transmute(0x5024u32) }),
0x434e => Some(unsafe { transmute(0x77e5u32) }),
0x434f => Some(unsafe { transmute(0x5730u32) }),
0x4350 => Some(unsafe { transmute(0x5f1bu32) }),
0x4351 => Some(unsafe { transmute(0x6065u32) }),
0x4352 => Some(unsafe { transmute(0x667au32) }),
0x4353 => Some(unsafe { transmute(0x6c60u32) }),
0x4354 => Some(unsafe { transmute(0x75f4u32) }),
0x4355 => Some(unsafe { transmute(0x7a1au32) }),
0x4356 => Some(unsafe { transmute(0x7f6eu32) }),
0x4357 => Some(unsafe { transmute(0x81f4u32) }),
0x4358 => Some(unsafe { transmute(0x8718u32) }),
0x4359 => Some(unsafe { transmute(0x9045u32) }),
0x435a => Some(unsafe { transmute(0x99b3u32) }),
0x435b => Some(unsafe { transmute(0x7bc9u32) }),
0x435c => Some(unsafe { transmute(0x755cu32) }),
0x435d => Some(unsafe { transmute(0x7af9u32) }),
0x435e => Some(unsafe { transmute(0x7b51u32) }),
0x435f => Some(unsafe { transmute(0x84c4u32) }),
0x4360 => Some(unsafe { transmute(0x9010u32) }),
0x4361 => Some(unsafe { transmute(0x79e9u32) }),
0x4362 => Some(unsafe { transmute(0x7a92u32) }),
0x4363 => Some(unsafe { transmute(0x8336u32) }),
0x4364 => Some(unsafe { transmute(0x5ae1u32) }),
0x4365 => Some(unsafe { transmute(0x7740u32) }),
0x4366 => Some(unsafe { transmute(0x4e2du32) }),
0x4367 => Some(unsafe { transmute(0x4ef2u32) }),
0x4368 => Some(unsafe { transmute(0x5b99u32) }),
0x4369 => Some(unsafe { transmute(0x5fe0u32) }),
0x436a => Some(unsafe { transmute(0x62bdu32) }),
0x436b => Some(unsafe { transmute(0x663cu32) }),
0x436c => Some(unsafe { transmute(0x67f1u32) }),
0x436d => Some(unsafe { transmute(0x6ce8u32) }),
0x436e => Some(unsafe { transmute(0x866bu32) }),
0x436f => Some(unsafe { transmute(0x8877u32) }),
0x4370 => Some(unsafe { transmute(0x8a3bu32) }),
0x4371 => Some(unsafe { transmute(0x914eu32) }),
0x4372 => Some(unsafe { transmute(0x92f3u32) }),
0x4373 => Some(unsafe { transmute(0x99d0u32) }),
0x4374 => Some(unsafe { transmute(0x6a17u32) }),
0x4375 => Some(unsafe { transmute(0x7026u32) }),
0x4376 => Some(unsafe { transmute(0x732au32) }),
0x4377 => Some(unsafe { transmute(0x82e7u32) }),
0x4378 => Some(unsafe { transmute(0x8457u32) }),
0x4379 => Some(unsafe { transmute(0x8cafu32) }),
0x437a => Some(unsafe { transmute(0x4e01u32) }),
0x437b => Some(unsafe { transmute(0x5146u32) }),
0x437c => Some(unsafe { transmute(0x51cbu32) }),
0x437d => Some(unsafe { transmute(0x558bu32) }),
0x437e => Some(unsafe { transmute(0x5bf5u32) }),
0x4421 => Some(unsafe { transmute(0x5e16u32) }),
0x4422 => Some(unsafe { transmute(0x5e33u32) }),
0x4423 => Some(unsafe { transmute(0x5e81u32) }),
0x4424 => Some(unsafe { transmute(0x5f14u32) }),
0x4425 => Some(unsafe { transmute(0x5f35u32) }),
0x4426 => Some(unsafe { transmute(0x5f6bu32) }),
0x4427 => Some(unsafe { transmute(0x5fb4u32) }),
0x4428 => Some(unsafe { transmute(0x61f2u32) }),
0x4429 => Some(unsafe { transmute(0x6311u32) }),
0x442a => Some(unsafe { transmute(0x66a2u32) }),
0x442b => Some(unsafe { transmute(0x671du32) }),
0x442c => Some(unsafe { transmute(0x6f6eu32) }),
0x442d => Some(unsafe { transmute(0x7252u32) }),
0x442e => Some(unsafe { transmute(0x753au32) }),
0x442f => Some(unsafe { transmute(0x773au32) }),
0x4430 => Some(unsafe { transmute(0x8074u32) }),
0x4431 => Some(unsafe { transmute(0x8139u32) }),
0x4432 => Some(unsafe { transmute(0x8178u32) }),
0x4433 => Some(unsafe { transmute(0x8776u32) }),
0x4434 => Some(unsafe { transmute(0x8abfu32) }),
0x4435 => Some(unsafe { transmute(0x8adcu32) }),
0x4436 => Some(unsafe { transmute(0x8d85u32) }),
0x4437 => Some(unsafe { transmute(0x8df3u32) }),
0x4438 => Some(unsafe { transmute(0x929au32) }),
0x4439 => Some(unsafe { transmute(0x9577u32) }),
0x443a => Some(unsafe { transmute(0x9802u32) }),
0x443b => Some(unsafe { transmute(0x9ce5u32) }),
0x443c => Some(unsafe { transmute(0x52c5u32) }),
0x443d => Some(unsafe { transmute(0x6357u32) }),
0x443e => Some(unsafe { transmute(0x76f4u32) }),
0x443f => Some(unsafe { transmute(0x6715u32) }),
0x4440 => Some(unsafe { transmute(0x6c88u32) }),
0x4441 => Some(unsafe { transmute(0x73cdu32) }),
0x4442 => Some(unsafe { transmute(0x8cc3u32) }),
0x4443 => Some(unsafe { transmute(0x93aeu32) }),
0x4444 => Some(unsafe { transmute(0x9673u32) }),
0x4445 => Some(unsafe { transmute(0x6d25u32) }),
0x4446 => Some(unsafe { transmute(0x589cu32) }),
0x4447 => Some(unsafe { transmute(0x690eu32) }),
0x4448 => Some(unsafe { transmute(0x69ccu32) }),
0x4449 => Some(unsafe { transmute(0x8ffdu32) }),
0x444a => Some(unsafe { transmute(0x939au32) }),
0x444b => Some(unsafe { transmute(0x75dbu32) }),
0x444c => Some(unsafe { transmute(0x901au32) }),
0x444d => Some(unsafe { transmute(0x585au32) }),
0x444e => Some(unsafe { transmute(0x6802u32) }),
0x444f => Some(unsafe { transmute(0x63b4u32) }),
0x4450 => Some(unsafe { transmute(0x69fbu32) }),
0x4451 => Some(unsafe { transmute(0x4f43u32) }),
0x4452 => Some(unsafe { transmute(0x6f2cu32) }),
0x4453 => Some(unsafe { transmute(0x67d8u32) }),
0x4454 => Some(unsafe { transmute(0x8fbbu32) }),
0x4455 => Some(unsafe { transmute(0x8526u32) }),
0x4456 => Some(unsafe { transmute(0x7db4u32) }),
0x4457 => Some(unsafe { transmute(0x9354u32) }),
0x4458 => Some(unsafe { transmute(0x693fu32) }),
0x4459 => Some(unsafe { transmute(0x6f70u32) }),
0x445a => Some(unsafe { transmute(0x576au32) }),
0x445b => Some(unsafe { transmute(0x58f7u32) }),
0x445c => Some(unsafe { transmute(0x5b2cu32) }),
0x445d => Some(unsafe { transmute(0x7d2cu32) }),
0x445e => Some(unsafe { transmute(0x722au32) }),
0x445f => Some(unsafe { transmute(0x540au32) }),
0x4460 => Some(unsafe { transmute(0x91e3u32) }),
0x4461 => Some(unsafe { transmute(0x9db4u32) }),
0x4462 => Some(unsafe { transmute(0x4eadu32) }),
0x4463 => Some(unsafe { transmute(0x4f4eu32) }),
0x4464 => Some(unsafe { transmute(0x505cu32) }),
0x4465 => Some(unsafe { transmute(0x5075u32) }),
0x4466 => Some(unsafe { transmute(0x5243u32) }),
0x4467 => Some(unsafe { transmute(0x8c9eu32) }),
0x4468 => Some(unsafe { transmute(0x5448u32) }),
0x4469 => Some(unsafe { transmute(0x5824u32) }),
0x446a => Some(unsafe { transmute(0x5b9au32) }),
0x446b => Some(unsafe { transmute(0x5e1du32) }),
0x446c => Some(unsafe { transmute(0x5e95u32) }),
0x446d => Some(unsafe { transmute(0x5eadu32) }),
0x446e => Some(unsafe { transmute(0x5ef7u32) }),
0x446f => Some(unsafe { transmute(0x5f1fu32) }),
0x4470 => Some(unsafe { transmute(0x608cu32) }),
0x4471 => Some(unsafe { transmute(0x62b5u32) }),
0x4472 => Some(unsafe { transmute(0x633au32) }),
0x4473 => Some(unsafe { transmute(0x63d0u32) }),
0x4474 => Some(unsafe { transmute(0x68afu32) }),
0x4475 => Some(unsafe { transmute(0x6c40u32) }),
0x4476 => Some(unsafe { transmute(0x7887u32) }),
0x4477 => Some(unsafe { transmute(0x798eu32) }),
0x4478 => Some(unsafe { transmute(0x7a0bu32) }),
0x4479 => Some(unsafe { transmute(0x7de0u32) }),
0x447a => Some(unsafe { transmute(0x8247u32) }),
0x447b => Some(unsafe { transmute(0x8a02u32) }),
0x447c => Some(unsafe { transmute(0x8ae6u32) }),
0x447d => Some(unsafe { transmute(0x8e44u32) }),
0x447e => Some(unsafe { transmute(0x9013u32) }),
0x4521 => Some(unsafe { transmute(0x90b8u32) }),
0x4522 => Some(unsafe { transmute(0x912du32) }),
0x4523 => Some(unsafe { transmute(0x91d8u32) }),
0x4524 => Some(unsafe { transmute(0x9f0eu32) }),
0x4525 => Some(unsafe { transmute(0x6ce5u32) }),
0x4526 => Some(unsafe { transmute(0x6458u32) }),
0x4527 => Some(unsafe { transmute(0x64e2u32) }),
0x4528 => Some(unsafe { transmute(0x6575u32) }),
0x4529 => Some(unsafe { transmute(0x6ef4u32) }),
0x452a => Some(unsafe { transmute(0x7684u32) }),
0x452b => Some(unsafe { transmute(0x7b1bu32) }),
0x452c => Some(unsafe { transmute(0x9069u32) }),
0x452d => Some(unsafe { transmute(0x93d1u32) }),
0x452e => Some(unsafe { transmute(0x6ebau32) }),
0x452f => Some(unsafe { transmute(0x54f2u32) }),
0x4530 => Some(unsafe { transmute(0x5fb9u32) }),
0x4531 => Some(unsafe { transmute(0x64a4u32) }),
0x4532 => Some(unsafe { transmute(0x8f4du32) }),
0x4533 => Some(unsafe { transmute(0x8fedu32) }),
0x4534 => Some(unsafe { transmute(0x9244u32) }),
0x4535 => Some(unsafe { transmute(0x5178u32) }),
0x4536 => Some(unsafe { transmute(0x586bu32) }),
0x4537 => Some(unsafe { transmute(0x5929u32) }),
0x4538 => Some(unsafe { transmute(0x5c55u32) }),
0x4539 => Some(unsafe { transmute(0x5e97u32) }),
0x453a => Some(unsafe { transmute(0x6dfbu32) }),
0x453b => Some(unsafe { transmute(0x7e8fu32) }),
0x453c => Some(unsafe { transmute(0x751cu32) }),
0x453d => Some(unsafe { transmute(0x8cbcu32) }),
0x453e => Some(unsafe { transmute(0x8ee2u32) }),
0x453f => Some(unsafe { transmute(0x985bu32) }),
0x4540 => Some(unsafe { transmute(0x70b9u32) }),
0x4541 => Some(unsafe { transmute(0x4f1du32) }),
0x4542 => Some(unsafe { transmute(0x6bbfu32) }),
0x4543 => Some(unsafe { transmute(0x6fb1u32) }),
0x4544 => Some(unsafe { transmute(0x7530u32) }),
0x4545 => Some(unsafe { transmute(0x96fbu32) }),
0x4546 => Some(unsafe { transmute(0x514eu32) }),
0x4547 => Some(unsafe { transmute(0x5410u32) }),
0x4548 => Some(unsafe { transmute(0x5835u32) }),
0x4549 => Some(unsafe { transmute(0x5857u32) }),
0x454a => Some(unsafe { transmute(0x59acu32) }),
0x454b => Some(unsafe { transmute(0x5c60u32) }),
0x454c => Some(unsafe { transmute(0x5f92u32) }),
0x454d => Some(unsafe { transmute(0x6597u32) }),
0x454e => Some(unsafe { transmute(0x675cu32) }),
0x454f => Some(unsafe { transmute(0x6e21u32) }),
0x4550 => Some(unsafe { transmute(0x767bu32) }),
0x4551 => Some(unsafe { transmute(0x83dfu32) }),
0x4552 => Some(unsafe { transmute(0x8cedu32) }),
0x4553 => Some(unsafe { transmute(0x9014u32) }),
0x4554 => Some(unsafe { transmute(0x90fdu32) }),
0x4555 => Some(unsafe { transmute(0x934du32) }),
0x4556 => Some(unsafe { transmute(0x7825u32) }),
0x4557 => Some(unsafe { transmute(0x783au32) }),
0x4558 => Some(unsafe { transmute(0x52aau32) }),
0x4559 => Some(unsafe { transmute(0x5ea6u32) }),
0x455a => Some(unsafe { transmute(0x571fu32) }),
0x455b => Some(unsafe { transmute(0x5974u32) }),
0x455c => Some(unsafe { transmute(0x6012u32) }),
0x455d => Some(unsafe { transmute(0x5012u32) }),
0x455e => Some(unsafe { transmute(0x515au32) }),
0x455f => Some(unsafe { transmute(0x51acu32) }),
0x4560 => Some(unsafe { transmute(0x51cdu32) }),
0x4561 => Some(unsafe { transmute(0x5200u32) }),
0x4562 => Some(unsafe { transmute(0x5510u32) }),
0x4563 => Some(unsafe { transmute(0x5854u32) }),
0x4564 => Some(unsafe { transmute(0x5858u32) }),
0x4565 => Some(unsafe { transmute(0x5957u32) }),
0x4566 => Some(unsafe { transmute(0x5b95u32) }),
0x4567 => Some(unsafe { transmute(0x5cf6u32) }),
0x4568 => Some(unsafe { transmute(0x5d8bu32) }),
0x4569 => Some(unsafe { transmute(0x60bcu32) }),
0x456a => Some(unsafe { transmute(0x6295u32) }),
0x456b => Some(unsafe { transmute(0x642du32) }),
0x456c => Some(unsafe { transmute(0x6771u32) }),
0x456d => Some(unsafe { transmute(0x6843u32) }),
0x456e => Some(unsafe { transmute(0x68bcu32) }),
0x456f => Some(unsafe { transmute(0x68dfu32) }),
0x4570 => Some(unsafe { transmute(0x76d7u32) }),
0x4571 => Some(unsafe { transmute(0x6dd8u32) }),
0x4572 => Some(unsafe { transmute(0x6e6fu32) }),
0x4573 => Some(unsafe { transmute(0x6d9bu32) }),
0x4574 => Some(unsafe { transmute(0x706fu32) }),
0x4575 => Some(unsafe { transmute(0x71c8u32) }),
0x4576 => Some(unsafe { transmute(0x5f53u32) }),
0x4577 => Some(unsafe { transmute(0x75d8u32) }),
0x4578 => Some(unsafe { transmute(0x7977u32) }),
0x4579 => Some(unsafe { transmute(0x7b49u32) }),
0x457a => Some(unsafe { transmute(0x7b54u32) }),
0x457b => Some(unsafe { transmute(0x7b52u32) }),
0x457c => Some(unsafe { transmute(0x7cd6u32) }),
0x457d => Some(unsafe { transmute(0x7d71u32) }),
0x457e => Some(unsafe { transmute(0x5230u32) }),
0x4621 => Some(unsafe { transmute(0x8463u32) }),
0x4622 => Some(unsafe { transmute(0x8569u32) }),
0x4623 => Some(unsafe { transmute(0x85e4u32) }),
0x4624 => Some(unsafe { transmute(0x8a0eu32) }),
0x4625 => Some(unsafe { transmute(0x8b04u32) }),
0x4626 => Some(unsafe { transmute(0x8c46u32) }),
0x4627 => Some(unsafe { transmute(0x8e0fu32) }),
0x4628 => Some(unsafe { transmute(0x9003u32) }),
0x4629 => Some(unsafe { transmute(0x900fu32) }),
0x462a => Some(unsafe { transmute(0x9419u32) }),
0x462b => Some(unsafe { transmute(0x9676u32) }),
0x462c => Some(unsafe { transmute(0x982du32) }),
0x462d => Some(unsafe { transmute(0x9a30u32) }),
0x462e => Some(unsafe { transmute(0x95d8u32) }),
0x462f => Some(unsafe { transmute(0x50cdu32) }),
0x4630 => Some(unsafe { transmute(0x52d5u32) }),
0x4631 => Some(unsafe { transmute(0x540cu32) }),
0x4632 => Some(unsafe { transmute(0x5802u32) }),
0x4633 => Some(unsafe { transmute(0x5c0eu32) }),
0x4634 => Some(unsafe { transmute(0x61a7u32) }),
0x4635 => Some(unsafe { transmute(0x649eu32) }),
0x4636 => Some(unsafe { transmute(0x6d1eu32) }),
0x4637 => Some(unsafe { transmute(0x77b3u32) }),
0x4638 => Some(unsafe { transmute(0x7ae5u32) }),
0x4639 => Some(unsafe { transmute(0x80f4u32) }),
0x463a => Some(unsafe { transmute(0x8404u32) }),
0x463b => Some(unsafe { transmute(0x9053u32) }),
0x463c => Some(unsafe { transmute(0x9285u32) }),
0x463d => Some(unsafe { transmute(0x5ce0u32) }),
0x463e => Some(unsafe { transmute(0x9d07u32) }),
0x463f => Some(unsafe { transmute(0x533fu32) }),
0x4640 => Some(unsafe { transmute(0x5f97u32) }),
0x4641 => Some(unsafe { transmute(0x5fb3u32) }),
0x4642 => Some(unsafe { transmute(0x6d9cu32) }),
0x4643 => Some(unsafe { transmute(0x7279u32) }),
0x4644 => Some(unsafe { transmute(0x7763u32) }),
0x4645 => Some(unsafe { transmute(0x79bfu32) }),
0x4646 => Some(unsafe { transmute(0x7be4u32) }),
0x4647 => Some(unsafe { transmute(0x6bd2u32) }),
0x4648 => Some(unsafe { transmute(0x72ecu32) }),
0x4649 => Some(unsafe { transmute(0x8aadu32) }),
0x464a => Some(unsafe { transmute(0x6803u32) }),
0x464b => Some(unsafe { transmute(0x6a61u32) }),
0x464c => Some(unsafe { transmute(0x51f8u32) }),
0x464d => Some(unsafe { transmute(0x7a81u32) }),
0x464e => Some(unsafe { transmute(0x6934u32) }),
0x464f => Some(unsafe { transmute(0x5c4au32) }),
0x4650 => Some(unsafe { transmute(0x9cf6u32) }),
0x4651 => Some(unsafe { transmute(0x82ebu32) }),
0x4652 => Some(unsafe { transmute(0x5bc5u32) }),
0x4653 => Some(unsafe { transmute(0x9149u32) }),
0x4654 => Some(unsafe { transmute(0x701eu32) }),
0x4655 => Some(unsafe { transmute(0x5678u32) }),
0x4656 => Some(unsafe { transmute(0x5c6fu32) }),
0x4657 => Some(unsafe { transmute(0x60c7u32) }),
0x4658 => Some(unsafe { transmute(0x6566u32) }),
0x4659 => Some(unsafe { transmute(0x6c8cu32) }),
0x465a => Some(unsafe { transmute(0x8c5au32) }),
0x465b => Some(unsafe { transmute(0x9041u32) }),
0x465c => Some(unsafe { transmute(0x9813u32) }),
0x465d => Some(unsafe { transmute(0x5451u32) }),
0x465e => Some(unsafe { transmute(0x66c7u32) }),
0x465f => Some(unsafe { transmute(0x920du32) }),
0x4660 => Some(unsafe { transmute(0x5948u32) }),
0x4661 => Some(unsafe { transmute(0x90a3u32) }),
0x4662 => Some(unsafe { transmute(0x5185u32) }),
0x4663 => Some(unsafe { transmute(0x4e4du32) }),
0x4664 => Some(unsafe { transmute(0x51eau32) }),
0x4665 => Some(unsafe { transmute(0x8599u32) }),
0x4666 => Some(unsafe { transmute(0x8b0eu32) }),
0x4667 => Some(unsafe { transmute(0x7058u32) }),
0x4668 => Some(unsafe { transmute(0x637au32) }),
0x4669 => Some(unsafe { transmute(0x934bu32) }),
0x466a => Some(unsafe { transmute(0x6962u32) }),
0x466b => Some(unsafe { transmute(0x99b4u32) }),
0x466c => Some(unsafe { transmute(0x7e04u32) }),
0x466d => Some(unsafe { transmute(0x7577u32) }),
0x466e => Some(unsafe { transmute(0x5357u32) }),
0x466f => Some(unsafe { transmute(0x6960u32) }),
0x4670 => Some(unsafe { transmute(0x8edfu32) }),
0x4671 => Some(unsafe { transmute(0x96e3u32) }),
0x4672 => Some(unsafe { transmute(0x6c5du32) }),
0x4673 => Some(unsafe { transmute(0x4e8cu32) }),
0x4674 => Some(unsafe { transmute(0x5c3cu32) }),
0x4675 => Some(unsafe { transmute(0x5f10u32) }),
0x4676 => Some(unsafe { transmute(0x8fe9u32) }),
0x4677 => Some(unsafe { transmute(0x5302u32) }),
0x4678 => Some(unsafe { transmute(0x8cd1u32) }),
0x4679 => Some(unsafe { transmute(0x8089u32) }),
0x467a => Some(unsafe { transmute(0x8679u32) }),
0x467b => Some(unsafe { transmute(0x5effu32) }),
0x467c => Some(unsafe { transmute(0x65e5u32) }),
0x467d => Some(unsafe { transmute(0x4e73u32) }),
0x467e => Some(unsafe { transmute(0x5165u32) }),
0x4721 => Some(unsafe { transmute(0x5982u32) }),
0x4722 => Some(unsafe { transmute(0x5c3fu32) }),
0x4723 => Some(unsafe { transmute(0x97eeu32) }),
0x4724 => Some(unsafe { transmute(0x4efbu32) }),
0x4725 => Some(unsafe { transmute(0x598au32) }),
0x4726 => Some(unsafe { transmute(0x5fcdu32) }),
0x4727 => Some(unsafe { transmute(0x8a8du32) }),
0x4728 => Some(unsafe { transmute(0x6fe1u32) }),
0x4729 => Some(unsafe { transmute(0x79b0u32) }),
0x472a => Some(unsafe { transmute(0x7962u32) }),
0x472b => Some(unsafe { transmute(0x5be7u32) }),
0x472c => Some(unsafe { transmute(0x8471u32) }),
0x472d => Some(unsafe { transmute(0x732bu32) }),
0x472e => Some(unsafe { transmute(0x71b1u32) }),
0x472f => Some(unsafe { transmute(0x5e74u32) }),
0x4730 => Some(unsafe { transmute(0x5ff5u32) }),
0x4731 => Some(unsafe { transmute(0x637bu32) }),
0x4732 => Some(unsafe { transmute(0x649au32) }),
0x4733 => Some(unsafe { transmute(0x71c3u32) }),
0x4734 => Some(unsafe { transmute(0x7c98u32) }),
0x4735 => Some(unsafe { transmute(0x4e43u32) }),
0x4736 => Some(unsafe { transmute(0x5efcu32) }),
0x4737 => Some(unsafe { transmute(0x4e4bu32) }),
0x4738 => Some(unsafe { transmute(0x57dcu32) }),
0x4739 => Some(unsafe { transmute(0x56a2u32) }),
0x473a => Some(unsafe { transmute(0x60a9u32) }),
0x473b => Some(unsafe { transmute(0x6fc3u32) }),
0x473c => Some(unsafe { transmute(0x7d0du32) }),
0x473d => Some(unsafe { transmute(0x80fdu32) }),
0x473e => Some(unsafe { transmute(0x8133u32) }),
0x473f => Some(unsafe { transmute(0x81bfu32) }),
0x4740 => Some(unsafe { transmute(0x8fb2u32) }),
0x4741 => Some(unsafe { transmute(0x8997u32) }),
0x4742 => Some(unsafe { transmute(0x86a4u32) }),
0x4743 => Some(unsafe { transmute(0x5df4u32) }),
0x4744 => Some(unsafe { transmute(0x628au32) }),
0x4745 => Some(unsafe { transmute(0x64adu32) }),
0x4746 => Some(unsafe { transmute(0x8987u32) }),
0x4747 => Some(unsafe { transmute(0x6777u32) }),
0x4748 => Some(unsafe { transmute(0x6ce2u32) }),
0x4749 => Some(unsafe { transmute(0x6d3eu32) }),
0x474a => Some(unsafe { transmute(0x7436u32) }),
0x474b => Some(unsafe { transmute(0x7834u32) }),
0x474c => Some(unsafe { transmute(0x5a46u32) }),
0x474d => Some(unsafe { transmute(0x7f75u32) }),
0x474e => Some(unsafe { transmute(0x82adu32) }),
0x474f => Some(unsafe { transmute(0x99acu32) }),
0x4750 => Some(unsafe { transmute(0x4ff3u32) }),
0x4751 => Some(unsafe { transmute(0x5ec3u32) }),
0x4752 => Some(unsafe { transmute(0x62ddu32) }),
0x4753 => Some(unsafe { transmute(0x6392u32) }),
0x4754 => Some(unsafe { transmute(0x6557u32) }),
0x4755 => Some(unsafe { transmute(0x676fu32) }),
0x4756 => Some(unsafe { transmute(0x76c3u32) }),
0x4757 => Some(unsafe { transmute(0x724cu32) }),
0x4758 => Some(unsafe { transmute(0x80ccu32) }),
0x4759 => Some(unsafe { transmute(0x80bau32) }),
0x475a => Some(unsafe { transmute(0x8f29u32) }),
0x475b => Some(unsafe { transmute(0x914du32) }),
0x475c => Some(unsafe { transmute(0x500du32) }),
0x475d => Some(unsafe { transmute(0x57f9u32) }),
0x475e => Some(unsafe { transmute(0x5a92u32) }),
0x475f => Some(unsafe { transmute(0x6885u32) }),
0x4760 => Some(unsafe { transmute(0x6973u32) }),
0x4761 => Some(unsafe { transmute(0x7164u32) }),
0x4762 => Some(unsafe { transmute(0x72fdu32) }),
0x4763 => Some(unsafe { transmute(0x8cb7u32) }),
0x4764 => Some(unsafe { transmute(0x58f2u32) }),
0x4765 => Some(unsafe { transmute(0x8ce0u32) }),
0x4766 => Some(unsafe { transmute(0x966au32) }),
0x4767 => Some(unsafe { transmute(0x9019u32) }),
0x4768 => Some(unsafe { transmute(0x877fu32) }),
0x4769 => Some(unsafe { transmute(0x79e4u32) }),
0x476a => Some(unsafe { transmute(0x77e7u32) }),
0x476b => Some(unsafe { transmute(0x8429u32) }),
0x476c => Some(unsafe { transmute(0x4f2fu32) }),
0x476d => Some(unsafe { transmute(0x5265u32) }),
0x476e => Some(unsafe { transmute(0x535au32) }),
0x476f => Some(unsafe { transmute(0x62cdu32) }),
0x4770 => Some(unsafe { transmute(0x67cfu32) }),
0x4771 => Some(unsafe { transmute(0x6ccau32) }),
0x4772 => Some(unsafe { transmute(0x767du32) }),
0x4773 => Some(unsafe { transmute(0x7b94u32) }),
0x4774 => Some(unsafe { transmute(0x7c95u32) }),
0x4775 => Some(unsafe { transmute(0x8236u32) }),
0x4776 => Some(unsafe { transmute(0x8584u32) }),
0x4777 => Some(unsafe { transmute(0x8febu32) }),
0x4778 => Some(unsafe { transmute(0x66ddu32) }),
0x4779 => Some(unsafe { transmute(0x6f20u32) }),
0x477a => Some(unsafe { transmute(0x7206u32) }),
0x477b => Some(unsafe { transmute(0x7e1bu32) }),
0x477c => Some(unsafe { transmute(0x83abu32) }),
0x477d => Some(unsafe { transmute(0x99c1u32) }),
0x477e => Some(unsafe { transmute(0x9ea6u32) }),
0x4821 => Some(unsafe { transmute(0x51fdu32) }),
0x4822 => Some(unsafe { transmute(0x7bb1u32) }),
0x4823 => Some(unsafe { transmute(0x7872u32) }),
0x4824 => Some(unsafe { transmute(0x7bb8u32) }),
0x4825 => Some(unsafe { transmute(0x8087u32) }),
0x4826 => Some(unsafe { transmute(0x7b48u32) }),
0x4827 => Some(unsafe { transmute(0x6ae8u32) }),
0x4828 => Some(unsafe { transmute(0x5e61u32) }),
0x4829 => Some(unsafe { transmute(0x808cu32) }),
0x482a => Some(unsafe { transmute(0x7551u32) }),
0x482b => Some(unsafe { transmute(0x7560u32) }),
0x482c => Some(unsafe { transmute(0x516bu32) }),
0x482d => Some(unsafe { transmute(0x9262u32) }),
0x482e => Some(unsafe { transmute(0x6e8cu32) }),
0x482f => Some(unsafe { transmute(0x767au32) }),
0x4830 => Some(unsafe { transmute(0x9197u32) }),
0x4831 => Some(unsafe { transmute(0x9aeau32) }),
0x4832 => Some(unsafe { transmute(0x4f10u32) }),
0x4833 => Some(unsafe { transmute(0x7f70u32) }),
0x4834 => Some(unsafe { transmute(0x629cu32) }),
0x4835 => Some(unsafe { transmute(0x7b4fu32) }),
0x4836 => Some(unsafe { transmute(0x95a5u32) }),
0x4837 => Some(unsafe { transmute(0x9ce9u32) }),
0x4838 => Some(unsafe { transmute(0x567au32) }),
0x4839 => Some(unsafe { transmute(0x5859u32) }),
0x483a => Some(unsafe { transmute(0x86e4u32) }),
0x483b => Some(unsafe { transmute(0x96bcu32) }),
0x483c => Some(unsafe { transmute(0x4f34u32) }),
0x483d => Some(unsafe { transmute(0x5224u32) }),
0x483e => Some(unsafe { transmute(0x534au32) }),
0x483f => Some(unsafe { transmute(0x53cdu32) }),
0x4840 => Some(unsafe { transmute(0x53dbu32) }),
0x4841 => Some(unsafe { transmute(0x5e06u32) }),
0x4842 => Some(unsafe { transmute(0x642cu32) }),
0x4843 => Some(unsafe { transmute(0x6591u32) }),
0x4844 => Some(unsafe { transmute(0x677fu32) }),
0x4845 => Some(unsafe { transmute(0x6c3eu32) }),
0x4846 => Some(unsafe { transmute(0x6c4eu32) }),
0x4847 => Some(unsafe { transmute(0x7248u32) }),
0x4848 => Some(unsafe { transmute(0x72afu32) }),
0x4849 => Some(unsafe { transmute(0x73edu32) }),
0x484a => Some(unsafe { transmute(0x7554u32) }),
0x484b => Some(unsafe { transmute(0x7e41u32) }),
0x484c => Some(unsafe { transmute(0x822cu32) }),
0x484d => Some(unsafe { transmute(0x85e9u32) }),
0x484e => Some(unsafe { transmute(0x8ca9u32) }),
0x484f => Some(unsafe { transmute(0x7bc4u32) }),
0x4850 => Some(unsafe { transmute(0x91c6u32) }),
0x4851 => Some(unsafe { transmute(0x7169u32) }),
0x4852 => Some(unsafe { transmute(0x9812u32) }),
0x4853 => Some(unsafe { transmute(0x98efu32) }),
0x4854 => Some(unsafe { transmute(0x633du32) }),
0x4855 => Some(unsafe { transmute(0x6669u32) }),
0x4856 => Some(unsafe { transmute(0x756au32) }),
0x4857 => Some(unsafe { transmute(0x76e4u32) }),
0x4858 => Some(unsafe { transmute(0x78d0u32) }),
0x4859 => Some(unsafe { transmute(0x8543u32) }),
0x485a => Some(unsafe { transmute(0x86eeu32) }),
0x485b => Some(unsafe { transmute(0x532au32) }),
0x485c => Some(unsafe { transmute(0x5351u32) }),
0x485d => Some(unsafe { transmute(0x5426u32) }),
0x485e => Some(unsafe { transmute(0x5983u32) }),
0x485f => Some(unsafe { transmute(0x5e87u32) }),
0x4860 => Some(unsafe { transmute(0x5f7cu32) }),
0x4861 => Some(unsafe { transmute(0x60b2u32) }),
0x4862 => Some(unsafe { transmute(0x6249u32) }),
0x4863 => Some(unsafe { transmute(0x6279u32) }),
0x4864 => Some(unsafe { transmute(0x62abu32) }),
0x4865 => Some(unsafe { transmute(0x6590u32) }),
0x4866 => Some(unsafe { transmute(0x6bd4u32) }),
0x4867 => Some(unsafe { transmute(0x6cccu32) }),
0x4868 => Some(unsafe { transmute(0x75b2u32) }),
0x4869 => Some(unsafe { transmute(0x76aeu32) }),
0x486a => Some(unsafe { transmute(0x7891u32) }),
0x486b => Some(unsafe { transmute(0x79d8u32) }),
0x486c => Some(unsafe { transmute(0x7dcbu32) }),
0x486d => Some(unsafe { transmute(0x7f77u32) }),
0x486e => Some(unsafe { transmute(0x80a5u32) }),
0x486f => Some(unsafe { transmute(0x88abu32) }),
0x4870 => Some(unsafe { transmute(0x8ab9u32) }),
0x4871 => Some(unsafe { transmute(0x8cbbu32) }),
0x4872 => Some(unsafe { transmute(0x907fu32) }),
0x4873 => Some(unsafe { transmute(0x975eu32) }),
0x4874 => Some(unsafe { transmute(0x98dbu32) }),
0x4875 => Some(unsafe { transmute(0x6a0bu32) }),
0x4876 => Some(unsafe { transmute(0x7c38u32) }),
0x4877 => Some(unsafe { transmute(0x5099u32) }),
0x4878 => Some(unsafe { transmute(0x5c3eu32) }),
0x4879 => Some(unsafe { transmute(0x5faeu32) }),
0x487a => Some(unsafe { transmute(0x6787u32) }),
0x487b => Some(unsafe { transmute(0x6bd8u32) }),
0x487c => Some(unsafe { transmute(0x7435u32) }),
0x487d => Some(unsafe { transmute(0x7709u32) }),
0x487e => Some(unsafe { transmute(0x7f8eu32) }),
0x4921 => Some(unsafe { transmute(0x9f3bu32) }),
0x4922 => Some(unsafe { transmute(0x67cau32) }),
0x4923 => Some(unsafe { transmute(0x7a17u32) }),
0x4924 => Some(unsafe { transmute(0x5339u32) }),
0x4925 => Some(unsafe { transmute(0x758bu32) }),
0x4926 => Some(unsafe { transmute(0x9aedu32) }),
0x4927 => Some(unsafe { transmute(0x5f66u32) }),
0x4928 => Some(unsafe { transmute(0x819du32) }),
0x4929 => Some(unsafe { transmute(0x83f1u32) }),
0x492a => Some(unsafe { transmute(0x8098u32) }),
0x492b => Some(unsafe { transmute(0x5f3cu32) }),
0x492c => Some(unsafe { transmute(0x5fc5u32) }),
0x492d => Some(unsafe { transmute(0x7562u32) }),
0x492e => Some(unsafe { transmute(0x7b46u32) }),
0x492f => Some(unsafe { transmute(0x903cu32) }),
0x4930 => Some(unsafe { transmute(0x6867u32) }),
0x4931 => Some(unsafe { transmute(0x59ebu32) }),
0x4932 => Some(unsafe { transmute(0x5a9bu32) }),
0x4933 => Some(unsafe { transmute(0x7d10u32) }),
0x4934 => Some(unsafe { transmute(0x767eu32) }),
0x4935 => Some(unsafe { transmute(0x8b2cu32) }),
0x4936 => Some(unsafe { transmute(0x4ff5u32) }),
0x4937 => Some(unsafe { transmute(0x5f6au32) }),
0x4938 => Some(unsafe { transmute(0x6a19u32) }),
0x4939 => Some(unsafe { transmute(0x6c37u32) }),
0x493a => Some(unsafe { transmute(0x6f02u32) }),
0x493b => Some(unsafe { transmute(0x74e2u32) }),
0x493c => Some(unsafe { transmute(0x7968u32) }),
0x493d => Some(unsafe { transmute(0x8868u32) }),
0x493e => Some(unsafe { transmute(0x8a55u32) }),
0x493f => Some(unsafe { transmute(0x8c79u32) }),
0x4940 => Some(unsafe { transmute(0x5edfu32) }),
0x4941 => Some(unsafe { transmute(0x63cfu32) }),
0x4942 => Some(unsafe { transmute(0x75c5u32) }),
0x4943 => Some(unsafe { transmute(0x79d2u32) }),
0x4944 => Some(unsafe { transmute(0x82d7u32) }),
0x4945 => Some(unsafe { transmute(0x9328u32) }),
0x4946 => Some(unsafe { transmute(0x92f2u32) }),
0x4947 => Some(unsafe { transmute(0x849cu32) }),
0x4948 => Some(unsafe { transmute(0x86edu32) }),
0x4949 => Some(unsafe { transmute(0x9c2du32) }),
0x494a => Some(unsafe { transmute(0x54c1u32) }),
0x494b => Some(unsafe { transmute(0x5f6cu32) }),
0x494c => Some(unsafe { transmute(0x658cu32) }),
0x494d => Some(unsafe { transmute(0x6d5cu32) }),
0x494e => Some(unsafe { transmute(0x7015u32) }),
0x494f => Some(unsafe { transmute(0x8ca7u32) }),
0x4950 => Some(unsafe { transmute(0x8cd3u32) }),
0x4951 => Some(unsafe { transmute(0x983bu32) }),
0x4952 => Some(unsafe { transmute(0x654fu32) }),
0x4953 => Some(unsafe { transmute(0x74f6u32) }),
0x4954 => Some(unsafe { transmute(0x4e0du32) }),
0x4955 => Some(unsafe { transmute(0x4ed8u32) }),
0x4956 => Some(unsafe { transmute(0x57e0u32) }),
0x4957 => Some(unsafe { transmute(0x592bu32) }),
0x4958 => Some(unsafe { transmute(0x5a66u32) }),
0x4959 => Some(unsafe { transmute(0x5bccu32) }),
0x495a => Some(unsafe { transmute(0x51a8u32) }),
0x495b => Some(unsafe { transmute(0x5e03u32) }),
0x495c => Some(unsafe { transmute(0x5e9cu32) }),
0x495d => Some(unsafe { transmute(0x6016u32) }),
0x495e => Some(unsafe { transmute(0x6276u32) }),
0x495f => Some(unsafe { transmute(0x6577u32) }),
0x4960 => Some(unsafe { transmute(0x65a7u32) }),
0x4961 => Some(unsafe { transmute(0x666eu32) }),
0x4962 => Some(unsafe { transmute(0x6d6eu32) }),
0x4963 => Some(unsafe { transmute(0x7236u32) }),
0x4964 => Some(unsafe { transmute(0x7b26u32) }),
0x4965 => Some(unsafe { transmute(0x8150u32) }),
0x4966 => Some(unsafe { transmute(0x819au32) }),
0x4967 => Some(unsafe { transmute(0x8299u32) }),
0x4968 => Some(unsafe { transmute(0x8b5cu32) }),
0x4969 => Some(unsafe { transmute(0x8ca0u32) }),
0x496a => Some(unsafe { transmute(0x8ce6u32) }),
0x496b => Some(unsafe { transmute(0x8d74u32) }),
0x496c => Some(unsafe { transmute(0x961cu32) }),
0x496d => Some(unsafe { transmute(0x9644u32) }),
0x496e => Some(unsafe { transmute(0x4faeu32) }),
0x496f => Some(unsafe { transmute(0x64abu32) }),
0x4970 => Some(unsafe { transmute(0x6b66u32) }),
0x4971 => Some(unsafe { transmute(0x821eu32) }),
0x4972 => Some(unsafe { transmute(0x8461u32) }),
0x4973 => Some(unsafe { transmute(0x856au32) }),
0x4974 => Some(unsafe { transmute(0x90e8u32) }),
0x4975 => Some(unsafe { transmute(0x5c01u32) }),
0x4976 => Some(unsafe { transmute(0x6953u32) }),
0x4977 => Some(unsafe { transmute(0x98a8u32) }),
0x4978 => Some(unsafe { transmute(0x847au32) }),
0x4979 => Some(unsafe { transmute(0x8557u32) }),
0x497a => Some(unsafe { transmute(0x4f0fu32) }),
0x497b => Some(unsafe { transmute(0x526fu32) }),
0x497c => Some(unsafe { transmute(0x5fa9u32) }),
0x497d => Some(unsafe { transmute(0x5e45u32) }),
0x497e => Some(unsafe { transmute(0x670du32) }),
0x4a21 => Some(unsafe { transmute(0x798fu32) }),
0x4a22 => Some(unsafe { transmute(0x8179u32) }),
0x4a23 => Some(unsafe { transmute(0x8907u32) }),
0x4a24 => Some(unsafe { transmute(0x8986u32) }),
0x4a25 => Some(unsafe { transmute(0x6df5u32) }),
0x4a26 => Some(unsafe { transmute(0x5f17u32) }),
0x4a27 => Some(unsafe { transmute(0x6255u32) }),
0x4a28 => Some(unsafe { transmute(0x6cb8u32) }),
0x4a29 => Some(unsafe { transmute(0x4ecfu32) }),
0x4a2a => Some(unsafe { transmute(0x7269u32) }),
0x4a2b => Some(unsafe { transmute(0x9b92u32) }),
0x4a2c => Some(unsafe { transmute(0x5206u32) }),
0x4a2d => Some(unsafe { transmute(0x543bu32) }),
0x4a2e => Some(unsafe { transmute(0x5674u32) }),
0x4a2f => Some(unsafe { transmute(0x58b3u32) }),
0x4a30 => Some(unsafe { transmute(0x61a4u32) }),
0x4a31 => Some(unsafe { transmute(0x626eu32) }),
0x4a32 => Some(unsafe { transmute(0x711au32) }),
0x4a33 => Some(unsafe { transmute(0x596eu32) }),
0x4a34 => Some(unsafe { transmute(0x7c89u32) }),
0x4a35 => Some(unsafe { transmute(0x7cdeu32) }),
0x4a36 => Some(unsafe { transmute(0x7d1bu32) }),
0x4a37 => Some(unsafe { transmute(0x96f0u32) }),
0x4a38 => Some(unsafe { transmute(0x6587u32) }),
0x4a39 => Some(unsafe { transmute(0x805eu32) }),
0x4a3a => Some(unsafe { transmute(0x4e19u32) }),
0x4a3b => Some(unsafe { transmute(0x4f75u32) }),
0x4a3c => Some(unsafe { transmute(0x5175u32) }),
0x4a3d => Some(unsafe { transmute(0x5840u32) }),
0x4a3e => Some(unsafe { transmute(0x5e63u32) }),
0x4a3f => Some(unsafe { transmute(0x5e73u32) }),
0x4a40 => Some(unsafe { transmute(0x5f0au32) }),
0x4a41 => Some(unsafe { transmute(0x67c4u32) }),
0x4a42 => Some(unsafe { transmute(0x4e26u32) }),
0x4a43 => Some(unsafe { transmute(0x853du32) }),
0x4a44 => Some(unsafe { transmute(0x9589u32) }),
0x4a45 => Some(unsafe { transmute(0x965bu32) }),
0x4a46 => Some(unsafe { transmute(0x7c73u32) }),
0x4a47 => Some(unsafe { transmute(0x9801u32) }),
0x4a48 => Some(unsafe { transmute(0x50fbu32) }),
0x4a49 => Some(unsafe { transmute(0x58c1u32) }),
0x4a4a => Some(unsafe { transmute(0x7656u32) }),
0x4a4b => Some(unsafe { transmute(0x78a7u32) }),
0x4a4c => Some(unsafe { transmute(0x5225u32) }),
0x4a4d => Some(unsafe { transmute(0x77a5u32) }),
0x4a4e => Some(unsafe { transmute(0x8511u32) }),
0x4a4f => Some(unsafe { transmute(0x7b86u32) }),
0x4a50 => Some(unsafe { transmute(0x504fu32) }),
0x4a51 => Some(unsafe { transmute(0x5909u32) }),
0x4a52 => Some(unsafe { transmute(0x7247u32) }),
0x4a53 => Some(unsafe { transmute(0x7bc7u32) }),
0x4a54 => Some(unsafe { transmute(0x7de8u32) }),
0x4a55 => Some(unsafe { transmute(0x8fbau32) }),
0x4a56 => Some(unsafe { transmute(0x8fd4u32) }),
0x4a57 => Some(unsafe { transmute(0x904du32) }),
0x4a58 => Some(unsafe { transmute(0x4fbfu32) }),
0x4a59 => Some(unsafe { transmute(0x52c9u32) }),
0x4a5a => Some(unsafe { transmute(0x5a29u32) }),
0x4a5b => Some(unsafe { transmute(0x5f01u32) }),
0x4a5c => Some(unsafe { transmute(0x97adu32) }),
0x4a5d => Some(unsafe { transmute(0x4fddu32) }),
0x4a5e => Some(unsafe { transmute(0x8217u32) }),
0x4a5f => Some(unsafe { transmute(0x92eau32) }),
0x4a60 => Some(unsafe { transmute(0x5703u32) }),
0x4a61 => Some(unsafe { transmute(0x6355u32) }),
0x4a62 => Some(unsafe { transmute(0x6b69u32) }),
0x4a63 => Some(unsafe { transmute(0x752bu32) }),
0x4a64 => Some(unsafe { transmute(0x88dcu32) }),
0x4a65 => Some(unsafe { transmute(0x8f14u32) }),
0x4a66 => Some(unsafe { transmute(0x7a42u32) }),
0x4a67 => Some(unsafe { transmute(0x52dfu32) }),
0x4a68 => Some(unsafe { transmute(0x5893u32) }),
0x4a69 => Some(unsafe { transmute(0x6155u32) }),
0x4a6a => Some(unsafe { transmute(0x620au32) }),
0x4a6b => Some(unsafe { transmute(0x66aeu32) }),
0x4a6c => Some(unsafe { transmute(0x6bcdu32) }),
0x4a6d => Some(unsafe { transmute(0x7c3fu32) }),
0x4a6e => Some(unsafe { transmute(0x83e9u32) }),
0x4a6f => Some(unsafe { transmute(0x5023u32) }),
0x4a70 => Some(unsafe { transmute(0x4ff8u32) }),
0x4a71 => Some(unsafe { transmute(0x5305u32) }),
0x4a72 => Some(unsafe { transmute(0x5446u32) }),
0x4a73 => Some(unsafe { transmute(0x5831u32) }),
0x4a74 => Some(unsafe { transmute(0x5949u32) }),
0x4a75 => Some(unsafe { transmute(0x5b9du32) }),
0x4a76 => Some(unsafe { transmute(0x5cf0u32) }),
0x4a77 => Some(unsafe { transmute(0x5cefu32) }),
0x4a78 => Some(unsafe { transmute(0x5d29u32) }),
0x4a79 => Some(unsafe { transmute(0x5e96u32) }),
0x4a7a => Some(unsafe { transmute(0x62b1u32) }),
0x4a7b => Some(unsafe { transmute(0x6367u32) }),
0x4a7c => Some(unsafe { transmute(0x653eu32) }),
0x4a7d => Some(unsafe { transmute(0x65b9u32) }),
0x4a7e => Some(unsafe { transmute(0x670bu32) }),
0x4b21 => Some(unsafe { transmute(0x6cd5u32) }),
0x4b22 => Some(unsafe { transmute(0x6ce1u32) }),
0x4b23 => Some(unsafe { transmute(0x70f9u32) }),
0x4b24 => Some(unsafe { transmute(0x7832u32) }),
0x4b25 => Some(unsafe { transmute(0x7e2bu32) }),
0x4b26 => Some(unsafe { transmute(0x80deu32) }),
0x4b27 => Some(unsafe { transmute(0x82b3u32) }),
0x4b28 => Some(unsafe { transmute(0x840cu32) }),
0x4b29 => Some(unsafe { transmute(0x84ecu32) }),
0x4b2a => Some(unsafe { transmute(0x8702u32) }),
0x4b2b => Some(unsafe { transmute(0x8912u32) }),
0x4b2c => Some(unsafe { transmute(0x8a2au32) }),
0x4b2d => Some(unsafe { transmute(0x8c4au32) }),
0x4b2e => Some(unsafe { transmute(0x90a6u32) }),
0x4b2f => Some(unsafe { transmute(0x92d2u32) }),
0x4b30 => Some(unsafe { transmute(0x98fdu32) }),
0x4b31 => Some(unsafe { transmute(0x9cf3u32) }),
0x4b32 => Some(unsafe { transmute(0x9d6cu32) }),
0x4b33 => Some(unsafe { transmute(0x4e4fu32) }),
0x4b34 => Some(unsafe { transmute(0x4ea1u32) }),
0x4b35 => Some(unsafe { transmute(0x508du32) }),
0x4b36 => Some(unsafe { transmute(0x5256u32) }),
0x4b37 => Some(unsafe { transmute(0x574au32) }),
0x4b38 => Some(unsafe { transmute(0x59a8u32) }),
0x4b39 => Some(unsafe { transmute(0x5e3du32) }),
0x4b3a => Some(unsafe { transmute(0x5fd8u32) }),
0x4b3b => Some(unsafe { transmute(0x5fd9u32) }),
0x4b3c => Some(unsafe { transmute(0x623fu32) }),
0x4b3d => Some(unsafe { transmute(0x66b4u32) }),
0x4b3e => Some(unsafe { transmute(0x671bu32) }),
0x4b3f => Some(unsafe { transmute(0x67d0u32) }),
0x4b40 => Some(unsafe { transmute(0x68d2u32) }),
0x4b41 => Some(unsafe { transmute(0x5192u32) }),
0x4b42 => Some(unsafe { transmute(0x7d21u32) }),
0x4b43 => Some(unsafe { transmute(0x80aau32) }),
0x4b44 => Some(unsafe { transmute(0x81a8u32) }),
0x4b45 => Some(unsafe { transmute(0x8b00u32) }),
0x4b46 => Some(unsafe { transmute(0x8c8cu32) }),
0x4b47 => Some(unsafe { transmute(0x8cbfu32) }),
0x4b48 => Some(unsafe { transmute(0x927eu32) }),
0x4b49 => Some(unsafe { transmute(0x9632u32) }),
0x4b4a => Some(unsafe { transmute(0x5420u32) }),
0x4b4b => Some(unsafe { transmute(0x982cu32) }),
0x4b4c => Some(unsafe { transmute(0x5317u32) }),
0x4b4d => Some(unsafe { transmute(0x50d5u32) }),
0x4b4e => Some(unsafe { transmute(0x535cu32) }),
0x4b4f => Some(unsafe { transmute(0x58a8u32) }),
0x4b50 => Some(unsafe { transmute(0x64b2u32) }),
0x4b51 => Some(unsafe { transmute(0x6734u32) }),
0x4b52 => Some(unsafe { transmute(0x7267u32) }),
0x4b53 => Some(unsafe { transmute(0x7766u32) }),
0x4b54 => Some(unsafe { transmute(0x7a46u32) }),
0x4b55 => Some(unsafe { transmute(0x91e6u32) }),
0x4b56 => Some(unsafe { transmute(0x52c3u32) }),
0x4b57 => Some(unsafe { transmute(0x6ca1u32) }),
0x4b58 => Some(unsafe { transmute(0x6b86u32) }),
0x4b59 => Some(unsafe { transmute(0x5800u32) }),
0x4b5a => Some(unsafe { transmute(0x5e4cu32) }),
0x4b5b => Some(unsafe { transmute(0x5954u32) }),
0x4b5c => Some(unsafe { transmute(0x672cu32) }),
0x4b5d => Some(unsafe { transmute(0x7ffbu32) }),
0x4b5e => Some(unsafe { transmute(0x51e1u32) }),
0x4b5f => Some(unsafe { transmute(0x76c6u32) }),
0x4b60 => Some(unsafe { transmute(0x6469u32) }),
0x4b61 => Some(unsafe { transmute(0x78e8u32) }),
0x4b62 => Some(unsafe { transmute(0x9b54u32) }),
0x4b63 => Some(unsafe { transmute(0x9ebbu32) }),
0x4b64 => Some(unsafe { transmute(0x57cbu32) }),
0x4b65 => Some(unsafe { transmute(0x59b9u32) }),
0x4b66 => Some(unsafe { transmute(0x6627u32) }),
0x4b67 => Some(unsafe { transmute(0x679au32) }),
0x4b68 => Some(unsafe { transmute(0x6bceu32) }),
0x4b69 => Some(unsafe { transmute(0x54e9u32) }),
0x4b6a => Some(unsafe { transmute(0x69d9u32) }),
0x4b6b => Some(unsafe { transmute(0x5e55u32) }),
0x4b6c => Some(unsafe { transmute(0x819cu32) }),
0x4b6d => Some(unsafe { transmute(0x6795u32) }),
0x4b6e => Some(unsafe { transmute(0x9baau32) }),
0x4b6f => Some(unsafe { transmute(0x67feu32) }),
0x4b70 => Some(unsafe { transmute(0x9c52u32) }),
0x4b71 => Some(unsafe { transmute(0x685du32) }),
0x4b72 => Some(unsafe { transmute(0x4ea6u32) }),
0x4b73 => Some(unsafe { transmute(0x4fe3u32) }),
0x4b74 => Some(unsafe { transmute(0x53c8u32) }),
0x4b75 => Some(unsafe { transmute(0x62b9u32) }),
0x4b76 => Some(unsafe { transmute(0x672bu32) }),
0x4b77 => Some(unsafe { transmute(0x6cabu32) }),
0x4b78 => Some(unsafe { transmute(0x8fc4u32) }),
0x4b79 => Some(unsafe { transmute(0x4fadu32) }),
0x4b7a => Some(unsafe { transmute(0x7e6du32) }),
0x4b7b => Some(unsafe { transmute(0x9ebfu32) }),
0x4b7c => Some(unsafe { transmute(0x4e07u32) }),
0x4b7d => Some(unsafe { transmute(0x6162u32) }),
0x4b7e => Some(unsafe { transmute(0x6e80u32) }),
0x4c21 => Some(unsafe { transmute(0x6f2bu32) }),
0x4c22 => Some(unsafe { transmute(0x8513u32) }),
0x4c23 => Some(unsafe { transmute(0x5473u32) }),
0x4c24 => Some(unsafe { transmute(0x672au32) }),
0x4c25 => Some(unsafe { transmute(0x9b45u32) }),
0x4c26 => Some(unsafe { transmute(0x5df3u32) }),
0x4c27 => Some(unsafe { transmute(0x7b95u32) }),
0x4c28 => Some(unsafe { transmute(0x5cacu32) }),
0x4c29 => Some(unsafe { transmute(0x5bc6u32) }),
0x4c2a => Some(unsafe { transmute(0x871cu32) }),
0x4c2b => Some(unsafe { transmute(0x6e4au32) }),
0x4c2c => Some(unsafe { transmute(0x84d1u32) }),
0x4c2d => Some(unsafe { transmute(0x7a14u32) }),
0x4c2e => Some(unsafe { transmute(0x8108u32) }),
0x4c2f => Some(unsafe { transmute(0x5999u32) }),
0x4c30 => Some(unsafe { transmute(0x7c8du32) }),
0x4c31 => Some(unsafe { transmute(0x6c11u32) }),
0x4c32 => Some(unsafe { transmute(0x7720u32) }),
0x4c33 => Some(unsafe { transmute(0x52d9u32) }),
0x4c34 => Some(unsafe { transmute(0x5922u32) }),
0x4c35 => Some(unsafe { transmute(0x7121u32) }),
0x4c36 => Some(unsafe { transmute(0x725fu32) }),
0x4c37 => Some(unsafe { transmute(0x77dbu32) }),
0x4c38 => Some(unsafe { transmute(0x9727u32) }),
0x4c39 => Some(unsafe { transmute(0x9d61u32) }),
0x4c3a => Some(unsafe { transmute(0x690bu32) }),
0x4c3b => Some(unsafe { transmute(0x5a7fu32) }),
0x4c3c => Some(unsafe { transmute(0x5a18u32) }),
0x4c3d => Some(unsafe { transmute(0x51a5u32) }),
0x4c3e => Some(unsafe { transmute(0x540du32) }),
0x4c3f => Some(unsafe { transmute(0x547du32) }),
0x4c40 => Some(unsafe { transmute(0x660eu32) }),
0x4c41 => Some(unsafe { transmute(0x76dfu32) }),
0x4c42 => Some(unsafe { transmute(0x8ff7u32) }),
0x4c43 => Some(unsafe { transmute(0x9298u32) }),
0x4c44 => Some(unsafe { transmute(0x9cf4u32) }),
0x4c45 => Some(unsafe { transmute(0x59eau32) }),
0x4c46 => Some(unsafe { transmute(0x725du32) }),
0x4c47 => Some(unsafe { transmute(0x6ec5u32) }),
0x4c48 => Some(unsafe { transmute(0x514du32) }),
0x4c49 => Some(unsafe { transmute(0x68c9u32) }),
0x4c4a => Some(unsafe { transmute(0x7dbfu32) }),
0x4c4b => Some(unsafe { transmute(0x7decu32) }),
0x4c4c => Some(unsafe { transmute(0x9762u32) }),
0x4c4d => Some(unsafe { transmute(0x9ebau32) }),
0x4c4e => Some(unsafe { transmute(0x6478u32) }),
0x4c4f => Some(unsafe { transmute(0x6a21u32) }),
0x4c50 => Some(unsafe { transmute(0x8302u32) }),
0x4c51 => Some(unsafe { transmute(0x5984u32) }),
0x4c52 => Some(unsafe { transmute(0x5b5fu32) }),
0x4c53 => Some(unsafe { transmute(0x6bdbu32) }),
0x4c54 => Some(unsafe { transmute(0x731bu32) }),
0x4c55 => Some(unsafe { transmute(0x76f2u32) }),
0x4c56 => Some(unsafe { transmute(0x7db2u32) }),
0x4c57 => Some(unsafe { transmute(0x8017u32) }),
0x4c58 => Some(unsafe { transmute(0x8499u32) }),
0x4c59 => Some(unsafe { transmute(0x5132u32) }),
0x4c5a => Some(unsafe { transmute(0x6728u32) }),
0x4c5b => Some(unsafe { transmute(0x9ed9u32) }),
0x4c5c => Some(unsafe { transmute(0x76eeu32) }),
0x4c5d => Some(unsafe { transmute(0x6762u32) }),
0x4c5e => Some(unsafe { transmute(0x52ffu32) }),
0x4c5f => Some(unsafe { transmute(0x9905u32) }),
0x4c60 => Some(unsafe { transmute(0x5c24u32) }),
0x4c61 => Some(unsafe { transmute(0x623bu32) }),
0x4c62 => Some(unsafe { transmute(0x7c7eu32) }),
0x4c63 => Some(unsafe { transmute(0x8cb0u32) }),
0x4c64 => Some(unsafe { transmute(0x554fu32) }),
0x4c65 => Some(unsafe { transmute(0x60b6u32) }),
0x4c66 => Some(unsafe { transmute(0x7d0bu32) }),
0x4c67 => Some(unsafe { transmute(0x9580u32) }),
0x4c68 => Some(unsafe { transmute(0x5301u32) }),
0x4c69 => Some(unsafe { transmute(0x4e5fu32) }),
0x4c6a => Some(unsafe { transmute(0x51b6u32) }),
0x4c6b => Some(unsafe { transmute(0x591cu32) }),
0x4c6c => Some(unsafe { transmute(0x723au32) }),
0x4c6d => Some(unsafe { transmute(0x8036u32) }),
0x4c6e => Some(unsafe { transmute(0x91ceu32) }),
0x4c6f => Some(unsafe { transmute(0x5f25u32) }),
0x4c70 => Some(unsafe { transmute(0x77e2u32) }),
0x4c71 => Some(unsafe { transmute(0x5384u32) }),
0x4c72 => Some(unsafe { transmute(0x5f79u32) }),
0x4c73 => Some(unsafe { transmute(0x7d04u32) }),
0x4c74 => Some(unsafe { transmute(0x85acu32) }),
0x4c75 => Some(unsafe { transmute(0x8a33u32) }),
0x4c76 => Some(unsafe { transmute(0x8e8du32) }),
0x4c77 => Some(unsafe { transmute(0x9756u32) }),
0x4c78 => Some(unsafe { transmute(0x67f3u32) }),
0x4c79 => Some(unsafe { transmute(0x85aeu32) }),
0x4c7a => Some(unsafe { transmute(0x9453u32) }),
0x4c7b => Some(unsafe { transmute(0x6109u32) }),
0x4c7c => Some(unsafe { transmute(0x6108u32) }),
0x4c7d => Some(unsafe { transmute(0x6cb9u32) }),
0x4c7e => Some(unsafe { transmute(0x7652u32) }),
0x4d21 => Some(unsafe { transmute(0x8aedu32) }),
0x4d22 => Some(unsafe { transmute(0x8f38u32) }),
0x4d23 => Some(unsafe { transmute(0x552fu32) }),
0x4d24 => Some(unsafe { transmute(0x4f51u32) }),
0x4d25 => Some(unsafe { transmute(0x512au32) }),
0x4d26 => Some(unsafe { transmute(0x52c7u32) }),
0x4d27 => Some(unsafe { transmute(0x53cbu32) }),
0x4d28 => Some(unsafe { transmute(0x5ba5u32) }),
0x4d29 => Some(unsafe { transmute(0x5e7du32) }),
0x4d2a => Some(unsafe { transmute(0x60a0u32) }),
0x4d2b => Some(unsafe { transmute(0x6182u32) }),
0x4d2c => Some(unsafe { transmute(0x63d6u32) }),
0x4d2d => Some(unsafe { transmute(0x6709u32) }),
0x4d2e => Some(unsafe { transmute(0x67dau32) }),
0x4d2f => Some(unsafe { transmute(0x6e67u32) }),
0x4d30 => Some(unsafe { transmute(0x6d8cu32) }),
0x4d31 => Some(unsafe { transmute(0x7336u32) }),
0x4d32 => Some(unsafe { transmute(0x7337u32) }),
0x4d33 => Some(unsafe { transmute(0x7531u32) }),
0x4d34 => Some(unsafe { transmute(0x7950u32) }),
0x4d35 => Some(unsafe { transmute(0x88d5u32) }),
0x4d36 => Some(unsafe { transmute(0x8a98u32) }),
0x4d37 => Some(unsafe { transmute(0x904au32) }),
0x4d38 => Some(unsafe { transmute(0x9091u32) }),
0x4d39 => Some(unsafe { transmute(0x90f5u32) }),
0x4d3a => Some(unsafe { transmute(0x96c4u32) }),
0x4d3b => Some(unsafe { transmute(0x878du32) }),
0x4d3c => Some(unsafe { transmute(0x5915u32) }),
0x4d3d => Some(unsafe { transmute(0x4e88u32) }),
0x4d3e => Some(unsafe { transmute(0x4f59u32) }),
0x4d3f => Some(unsafe { transmute(0x4e0eu32) }),
0x4d40 => Some(unsafe { transmute(0x8a89u32) }),
0x4d41 => Some(unsafe { transmute(0x8f3fu32) }),
0x4d42 => Some(unsafe { transmute(0x9810u32) }),
0x4d43 => Some(unsafe { transmute(0x50adu32) }),
0x4d44 => Some(unsafe { transmute(0x5e7cu32) }),
0x4d45 => Some(unsafe { transmute(0x5996u32) }),
0x4d46 => Some(unsafe { transmute(0x5bb9u32) }),
0x4d47 => Some(unsafe { transmute(0x5eb8u32) }),
0x4d48 => Some(unsafe { transmute(0x63dau32) }),
0x4d49 => Some(unsafe { transmute(0x63fau32) }),
0x4d4a => Some(unsafe { transmute(0x64c1u32) }),
0x4d4b => Some(unsafe { transmute(0x66dcu32) }),
0x4d4c => Some(unsafe { transmute(0x694au32) }),
0x4d4d => Some(unsafe { transmute(0x69d8u32) }),
0x4d4e => Some(unsafe { transmute(0x6d0bu32) }),
0x4d4f => Some(unsafe { transmute(0x6eb6u32) }),
0x4d50 => Some(unsafe { transmute(0x7194u32) }),
0x4d51 => Some(unsafe { transmute(0x7528u32) }),
0x4d52 => Some(unsafe { transmute(0x7aafu32) }),
0x4d53 => Some(unsafe { transmute(0x7f8au32) }),
0x4d54 => Some(unsafe { transmute(0x8000u32) }),
0x4d55 => Some(unsafe { transmute(0x8449u32) }),
0x4d56 => Some(unsafe { transmute(0x84c9u32) }),
0x4d57 => Some(unsafe { transmute(0x8981u32) }),
0x4d58 => Some(unsafe { transmute(0x8b21u32) }),
0x4d59 => Some(unsafe { transmute(0x8e0au32) }),
0x4d5a => Some(unsafe { transmute(0x9065u32) }),
0x4d5b => Some(unsafe { transmute(0x967du32) }),
0x4d5c => Some(unsafe { transmute(0x990au32) }),
0x4d5d => Some(unsafe { transmute(0x617eu32) }),
0x4d5e => Some(unsafe { transmute(0x6291u32) }),
0x4d5f => Some(unsafe { transmute(0x6b32u32) }),
0x4d60 => Some(unsafe { transmute(0x6c83u32) }),
0x4d61 => Some(unsafe { transmute(0x6d74u32) }),
0x4d62 => Some(unsafe { transmute(0x7fccu32) }),
0x4d63 => Some(unsafe { transmute(0x7ffcu32) }),
0x4d64 => Some(unsafe { transmute(0x6dc0u32) }),
0x4d65 => Some(unsafe { transmute(0x7f85u32) }),
0x4d66 => Some(unsafe { transmute(0x87bau32) }),
0x4d67 => Some(unsafe { transmute(0x88f8u32) }),
0x4d68 => Some(unsafe { transmute(0x6765u32) }),
0x4d69 => Some(unsafe { transmute(0x83b1u32) }),
0x4d6a => Some(unsafe { transmute(0x983cu32) }),
0x4d6b => Some(unsafe { transmute(0x96f7u32) }),
0x4d6c => Some(unsafe { transmute(0x6d1bu32) }),
0x4d6d => Some(unsafe { transmute(0x7d61u32) }),
0x4d6e => Some(unsafe { transmute(0x843du32) }),
0x4d6f => Some(unsafe { transmute(0x916au32) }),
0x4d70 => Some(unsafe { transmute(0x4e71u32) }),
0x4d71 => Some(unsafe { transmute(0x5375u32) }),
0x4d72 => Some(unsafe { transmute(0x5d50u32) }),
0x4d73 => Some(unsafe { transmute(0x6b04u32) }),
0x4d74 => Some(unsafe { transmute(0x6febu32) }),
0x4d75 => Some(unsafe { transmute(0x85cdu32) }),
0x4d76 => Some(unsafe { transmute(0x862du32) }),
0x4d77 => Some(unsafe { transmute(0x89a7u32) }),
0x4d78 => Some(unsafe { transmute(0x5229u32) }),
0x4d79 => Some(unsafe { transmute(0x540fu32) }),
0x4d7a => Some(unsafe { transmute(0x5c65u32) }),
0x4d7b => Some(unsafe { transmute(0x674eu32) }),
0x4d7c => Some(unsafe { transmute(0x68a8u32) }),
0x4d7d => Some(unsafe { transmute(0x7406u32) }),
0x4d7e => Some(unsafe { transmute(0x7483u32) }),
0x4e21 => Some(unsafe { transmute(0x75e2u32) }),
0x4e22 => Some(unsafe { transmute(0x88cfu32) }),
0x4e23 => Some(unsafe { transmute(0x88e1u32) }),
0x4e24 => Some(unsafe { transmute(0x91ccu32) }),
0x4e25 => Some(unsafe { transmute(0x96e2u32) }),
0x4e26 => Some(unsafe { transmute(0x9678u32) }),
0x4e27 => Some(unsafe { transmute(0x5f8bu32) }),
0x4e28 => Some(unsafe { transmute(0x7387u32) }),
0x4e29 => Some(unsafe { transmute(0x7acbu32) }),
0x4e2a => Some(unsafe { transmute(0x844eu32) }),
0x4e2b => Some(unsafe { transmute(0x63a0u32) }),
0x4e2c => Some(unsafe { transmute(0x7565u32) }),
0x4e2d => Some(unsafe { transmute(0x5289u32) }),
0x4e2e => Some(unsafe { transmute(0x6d41u32) }),
0x4e2f => Some(unsafe { transmute(0x6e9cu32) }),
0x4e30 => Some(unsafe { transmute(0x7409u32) }),
0x4e31 => Some(unsafe { transmute(0x7559u32) }),
0x4e32 => Some(unsafe { transmute(0x786bu32) }),
0x4e33 => Some(unsafe { transmute(0x7c92u32) }),
0x4e34 => Some(unsafe { transmute(0x9686u32) }),
0x4e35 => Some(unsafe { transmute(0x7adcu32) }),
0x4e36 => Some(unsafe { transmute(0x9f8du32) }),
0x4e37 => Some(unsafe { transmute(0x4fb6u32) }),
0x4e38 => Some(unsafe { transmute(0x616eu32) }),
0x4e39 => Some(unsafe { transmute(0x65c5u32) }),
0x4e3a => Some(unsafe { transmute(0x865cu32) }),
0x4e3b => Some(unsafe { transmute(0x4e86u32) }),
0x4e3c => Some(unsafe { transmute(0x4eaeu32) }),
0x4e3d => Some(unsafe { transmute(0x50dau32) }),
0x4e3e => Some(unsafe { transmute(0x4e21u32) }),
0x4e3f => Some(unsafe { transmute(0x51ccu32) }),
0x4e40 => Some(unsafe { transmute(0x5beeu32) }),
0x4e41 => Some(unsafe { transmute(0x6599u32) }),
0x4e42 => Some(unsafe { transmute(0x6881u32) }),
0x4e43 => Some(unsafe { transmute(0x6dbcu32) }),
0x4e44 => Some(unsafe { transmute(0x731fu32) }),
0x4e45 => Some(unsafe { transmute(0x7642u32) }),
0x4e46 => Some(unsafe { transmute(0x77adu32) }),
0x4e47 => Some(unsafe { transmute(0x7a1cu32) }),
0x4e48 => Some(unsafe { transmute(0x7ce7u32) }),
0x4e49 => Some(unsafe { transmute(0x826fu32) }),
0x4e4a => Some(unsafe { transmute(0x8ad2u32) }),
0x4e4b => Some(unsafe { transmute(0x907cu32) }),
0x4e4c => Some(unsafe { transmute(0x91cfu32) }),
0x4e4d => Some(unsafe { transmute(0x9675u32) }),
0x4e4e => Some(unsafe { transmute(0x9818u32) }),
0x4e4f => Some(unsafe { transmute(0x529bu32) }),
0x4e50 => Some(unsafe { transmute(0x7dd1u32) }),
0x4e51 => Some(unsafe { transmute(0x502bu32) }),
0x4e52 => Some(unsafe { transmute(0x5398u32) }),
0x4e53 => Some(unsafe { transmute(0x6797u32) }),
0x4e54 => Some(unsafe { transmute(0x6dcbu32) }),
0x4e55 => Some(unsafe { transmute(0x71d0u32) }),
0x4e56 => Some(unsafe { transmute(0x7433u32) }),
0x4e57 => Some(unsafe { transmute(0x81e8u32) }),
0x4e58 => Some(unsafe { transmute(0x8f2au32) }),
0x4e59 => Some(unsafe { transmute(0x96a3u32) }),
0x4e5a => Some(unsafe { transmute(0x9c57u32) }),
0x4e5b => Some(unsafe { transmute(0x9e9fu32) }),
0x4e5c => Some(unsafe { transmute(0x7460u32) }),
0x4e5d => Some(unsafe { transmute(0x5841u32) }),
0x4e5e => Some(unsafe { transmute(0x6d99u32) }),
0x4e5f => Some(unsafe { transmute(0x7d2fu32) }),
0x4e60 => Some(unsafe { transmute(0x985eu32) }),
0x4e61 => Some(unsafe { transmute(0x4ee4u32) }),
0x4e62 => Some(unsafe { transmute(0x4f36u32) }),
0x4e63 => Some(unsafe { transmute(0x4f8bu32) }),
0x4e64 => Some(unsafe { transmute(0x51b7u32) }),
0x4e65 => Some(unsafe { transmute(0x52b1u32) }),
0x4e66 => Some(unsafe { transmute(0x5dbau32) }),
0x4e67 => Some(unsafe { transmute(0x601cu32) }),
0x4e68 => Some(unsafe { transmute(0x73b2u32) }),
0x4e69 => Some(unsafe { transmute(0x793cu32) }),
0x4e6a => Some(unsafe { transmute(0x82d3u32) }),
0x4e6b => Some(unsafe { transmute(0x9234u32) }),
0x4e6c => Some(unsafe { transmute(0x96b7u32) }),
0x4e6d => Some(unsafe { transmute(0x96f6u32) }),
0x4e6e => Some(unsafe { transmute(0x970au32) }),
0x4e6f => Some(unsafe { transmute(0x9e97u32) }),
0x4e70 => Some(unsafe { transmute(0x9f62u32) }),
0x4e71 => Some(unsafe { transmute(0x66a6u32) }),
0x4e72 => Some(unsafe { transmute(0x6b74u32) }),
0x4e73 => Some(unsafe { transmute(0x5217u32) }),
0x4e74 => Some(unsafe { transmute(0x52a3u32) }),
0x4e75 => Some(unsafe { transmute(0x70c8u32) }),
0x4e76 => Some(unsafe { transmute(0x88c2u32) }),
0x4e77 => Some(unsafe { transmute(0x5ec9u32) }),
0x4e78 => Some(unsafe { transmute(0x604bu32) }),
0x4e79 => Some(unsafe { transmute(0x6190u32) }),
0x4e7a => Some(unsafe { transmute(0x6f23u32) }),
0x4e7b => Some(unsafe { transmute(0x7149u32) }),
0x4e7c => Some(unsafe { transmute(0x7c3eu32) }),
0x4e7d => Some(unsafe { transmute(0x7df4u32) }),
0x4e7e => Some(unsafe { transmute(0x806fu32) }),
0x4f21 => Some(unsafe { transmute(0x84eeu32) }),
0x4f22 => Some(unsafe { transmute(0x9023u32) }),
0x4f23 => Some(unsafe { transmute(0x932cu32) }),
0x4f24 => Some(unsafe { transmute(0x5442u32) }),
0x4f25 => Some(unsafe { transmute(0x9b6fu32) }),
0x4f26 => Some(unsafe { transmute(0x6ad3u32) }),
0x4f27 => Some(unsafe { transmute(0x7089u32) }),
0x4f28 => Some(unsafe { transmute(0x8cc2u32) }),
0x4f29 => Some(unsafe { transmute(0x8defu32) }),
0x4f2a => Some(unsafe { transmute(0x9732u32) }),
0x4f2b => Some(unsafe { transmute(0x52b4u32) }),
0x4f2c => Some(unsafe { transmute(0x5a41u32) }),
0x4f2d => Some(unsafe { transmute(0x5ecau32) }),
0x4f2e => Some(unsafe { transmute(0x5f04u32) }),
0x4f2f => Some(unsafe { transmute(0x6717u32) }),
0x4f30 => Some(unsafe { transmute(0x697cu32) }),
0x4f31 => Some(unsafe { transmute(0x6994u32) }),
0x4f32 => Some(unsafe { transmute(0x6d6au32) }),
0x4f33 => Some(unsafe { transmute(0x6f0fu32) }),
0x4f34 => Some(unsafe { transmute(0x7262u32) }),
0x4f35 => Some(unsafe { transmute(0x72fcu32) }),
0x4f36 => Some(unsafe { transmute(0x7bedu32) }),
0x4f37 => Some(unsafe { transmute(0x8001u32) }),
0x4f38 => Some(unsafe { transmute(0x807eu32) }),
0x4f39 => Some(unsafe { transmute(0x874bu32) }),
0x4f3a => Some(unsafe { transmute(0x90ceu32) }),
0x4f3b => Some(unsafe { transmute(0x516du32) }),
0x4f3c => Some(unsafe { transmute(0x9e93u32) }),
0x4f3d => Some(unsafe { transmute(0x7984u32) }),
0x4f3e => Some(unsafe { transmute(0x808bu32) }),
0x4f3f => Some(unsafe { transmute(0x9332u32) }),
0x4f40 => Some(unsafe { transmute(0x8ad6u32) }),
0x4f41 => Some(unsafe { transmute(0x502du32) }),
0x4f42 => Some(unsafe { transmute(0x548cu32) }),
0x4f43 => Some(unsafe { transmute(0x8a71u32) }),
0x4f44 => Some(unsafe { transmute(0x6b6au32) }),
0x4f45 => Some(unsafe { transmute(0x8cc4u32) }),
0x4f46 => Some(unsafe { transmute(0x8107u32) }),
0x4f47 => Some(unsafe { transmute(0x60d1u32) }),
0x4f48 => Some(unsafe { transmute(0x67a0u32) }),
0x4f49 => Some(unsafe { transmute(0x9df2u32) }),
0x4f4a => Some(unsafe { transmute(0x4e99u32) }),
0x4f4b => Some(unsafe { transmute(0x4e98u32) }),
0x4f4c => Some(unsafe { transmute(0x9c10u32) }),
0x4f4d => Some(unsafe { transmute(0x8a6bu32) }),
0x4f4e => Some(unsafe { transmute(0x85c1u32) }),
0x4f4f => Some(unsafe { transmute(0x8568u32) }),
0x4f50 => Some(unsafe { transmute(0x6900u32) }),
0x4f51 => Some(unsafe { transmute(0x6e7eu32) }),
0x4f52 => Some(unsafe { transmute(0x7897u32) }),
0x4f53 => Some(unsafe { transmute(0x8155u32) }),
0x5021 => Some(unsafe { transmute(0x5f0cu32) }),
0x5022 => Some(unsafe { transmute(0x4e10u32) }),
0x5023 => Some(unsafe { transmute(0x4e15u32) }),
0x5024 => Some(unsafe { transmute(0x4e2au32) }),
0x5025 => Some(unsafe { transmute(0x4e31u32) }),
0x5026 => Some(unsafe { transmute(0x4e36u32) }),
0x5027 => Some(unsafe { transmute(0x4e3cu32) }),
0x5028 => Some(unsafe { transmute(0x4e3fu32) }),
0x5029 => Some(unsafe { transmute(0x4e42u32) }),
0x502a => Some(unsafe { transmute(0x4e56u32) }),
0x502b => Some(unsafe { transmute(0x4e58u32) }),
0x502c => Some(unsafe { transmute(0x4e82u32) }),
0x502d => Some(unsafe { transmute(0x4e85u32) }),
0x502e => Some(unsafe { transmute(0x8c6bu32) }),
0x502f => Some(unsafe { transmute(0x4e8au32) }),
0x5030 => Some(unsafe { transmute(0x8212u32) }),
0x5031 => Some(unsafe { transmute(0x5f0du32) }),
0x5032 => Some(unsafe { transmute(0x4e8eu32) }),
0x5033 => Some(unsafe { transmute(0x4e9eu32) }),
0x5034 => Some(unsafe { transmute(0x4e9fu32) }),
0x5035 => Some(unsafe { transmute(0x4ea0u32) }),
0x5036 => Some(unsafe { transmute(0x4ea2u32) }),
0x5037 => Some(unsafe { transmute(0x4eb0u32) }),
0x5038 => Some(unsafe { transmute(0x4eb3u32) }),
0x5039 => Some(unsafe { transmute(0x4eb6u32) }),
0x503a => Some(unsafe { transmute(0x4eceu32) }),
0x503b => Some(unsafe { transmute(0x4ecdu32) }),
0x503c => Some(unsafe { transmute(0x4ec4u32) }),
0x503d => Some(unsafe { transmute(0x4ec6u32) }),
0x503e => Some(unsafe { transmute(0x4ec2u32) }),
0x503f => Some(unsafe { transmute(0x4ed7u32) }),
0x5040 => Some(unsafe { transmute(0x4edeu32) }),
0x5041 => Some(unsafe { transmute(0x4eedu32) }),
0x5042 => Some(unsafe { transmute(0x4edfu32) }),
0x5043 => Some(unsafe { transmute(0x4ef7u32) }),
0x5044 => Some(unsafe { transmute(0x4f09u32) }),
0x5045 => Some(unsafe { transmute(0x4f5au32) }),
0x5046 => Some(unsafe { transmute(0x4f30u32) }),
0x5047 => Some(unsafe { transmute(0x4f5bu32) }),
0x5048 => Some(unsafe { transmute(0x4f5du32) }),
0x5049 => Some(unsafe { transmute(0x4f57u32) }),
0x504a => Some(unsafe { transmute(0x4f47u32) }),
0x504b => Some(unsafe { transmute(0x4f76u32) }),
0x504c => Some(unsafe { transmute(0x4f88u32) }),
0x504d => Some(unsafe { transmute(0x4f8fu32) }),
0x504e => Some(unsafe { transmute(0x4f98u32) }),
0x504f => Some(unsafe { transmute(0x4f7bu32) }),
0x5050 => Some(unsafe { transmute(0x4f69u32) }),
0x5051 => Some(unsafe { transmute(0x4f70u32) }),
0x5052 => Some(unsafe { transmute(0x4f91u32) }),
0x5053 => Some(unsafe { transmute(0x4f6fu32) }),
0x5054 => Some(unsafe { transmute(0x4f86u32) }),
0x5055 => Some(unsafe { transmute(0x4f96u32) }),
0x5056 => Some(unsafe { transmute(0x5118u32) }),
0x5057 => Some(unsafe { transmute(0x4fd4u32) }),
0x5058 => Some(unsafe { transmute(0x4fdfu32) }),
0x5059 => Some(unsafe { transmute(0x4fceu32) }),
0x505a => Some(unsafe { transmute(0x4fd8u32) }),
0x505b => Some(unsafe { transmute(0x4fdbu32) }),
0x505c => Some(unsafe { transmute(0x4fd1u32) }),
0x505d => Some(unsafe { transmute(0x4fdau32) }),
0x505e => Some(unsafe { transmute(0x4fd0u32) }),
0x505f => Some(unsafe { transmute(0x4fe4u32) }),
0x5060 => Some(unsafe { transmute(0x4fe5u32) }),
0x5061 => Some(unsafe { transmute(0x501au32) }),
0x5062 => Some(unsafe { transmute(0x5028u32) }),
0x5063 => Some(unsafe { transmute(0x5014u32) }),
0x5064 => Some(unsafe { transmute(0x502au32) }),
0x5065 => Some(unsafe { transmute(0x5025u32) }),
0x5066 => Some(unsafe { transmute(0x5005u32) }),
0x5067 => Some(unsafe { transmute(0x4f1cu32) }),
0x5068 => Some(unsafe { transmute(0x4ff6u32) }),
0x5069 => Some(unsafe { transmute(0x5021u32) }),
0x506a => Some(unsafe { transmute(0x5029u32) }),
0x506b => Some(unsafe { transmute(0x502cu32) }),
0x506c => Some(unsafe { transmute(0x4ffeu32) }),
0x506d => Some(unsafe { transmute(0x4fefu32) }),
0x506e => Some(unsafe { transmute(0x5011u32) }),
0x506f => Some(unsafe { transmute(0x5006u32) }),
0x5070 => Some(unsafe { transmute(0x5043u32) }),
0x5071 => Some(unsafe { transmute(0x5047u32) }),
0x5072 => Some(unsafe { transmute(0x6703u32) }),
0x5073 => Some(unsafe { transmute(0x5055u32) }),
0x5074 => Some(unsafe { transmute(0x5050u32) }),
0x5075 => Some(unsafe { transmute(0x5048u32) }),
0x5076 => Some(unsafe { transmute(0x505au32) }),
0x5077 => Some(unsafe { transmute(0x5056u32) }),
0x5078 => Some(unsafe { transmute(0x506cu32) }),
0x5079 => Some(unsafe { transmute(0x5078u32) }),
0x507a => Some(unsafe { transmute(0x5080u32) }),
0x507b => Some(unsafe { transmute(0x509au32) }),
0x507c => Some(unsafe { transmute(0x5085u32) }),
0x507d => Some(unsafe { transmute(0x50b4u32) }),
0x507e => Some(unsafe { transmute(0x50b2u32) }),
0x5121 => Some(unsafe { transmute(0x50c9u32) }),
0x5122 => Some(unsafe { transmute(0x50cau32) }),
0x5123 => Some(unsafe { transmute(0x50b3u32) }),
0x5124 => Some(unsafe { transmute(0x50c2u32) }),
0x5125 => Some(unsafe { transmute(0x50d6u32) }),
0x5126 => Some(unsafe { transmute(0x50deu32) }),
0x5127 => Some(unsafe { transmute(0x50e5u32) }),
0x5128 => Some(unsafe { transmute(0x50edu32) }),
0x5129 => Some(unsafe { transmute(0x50e3u32) }),
0x512a => Some(unsafe { transmute(0x50eeu32) }),
0x512b => Some(unsafe { transmute(0x50f9u32) }),
0x512c => Some(unsafe { transmute(0x50f5u32) }),
0x512d => Some(unsafe { transmute(0x5109u32) }),
0x512e => Some(unsafe { transmute(0x5101u32) }),
0x512f => Some(unsafe { transmute(0x5102u32) }),
0x5130 => Some(unsafe { transmute(0x5116u32) }),
0x5131 => Some(unsafe { transmute(0x5115u32) }),
0x5132 => Some(unsafe { transmute(0x5114u32) }),
0x5133 => Some(unsafe { transmute(0x511au32) }),
0x5134 => Some(unsafe { transmute(0x5121u32) }),
0x5135 => Some(unsafe { transmute(0x513au32) }),
0x5136 => Some(unsafe { transmute(0x5137u32) }),
0x5137 => Some(unsafe { transmute(0x513cu32) }),
0x5138 => Some(unsafe { transmute(0x513bu32) }),
0x5139 => Some(unsafe { transmute(0x513fu32) }),
0x513a => Some(unsafe { transmute(0x5140u32) }),
0x513b => Some(unsafe { transmute(0x5152u32) }),
0x513c => Some(unsafe { transmute(0x514cu32) }),
0x513d => Some(unsafe { transmute(0x5154u32) }),
0x513e => Some(unsafe { transmute(0x5162u32) }),
0x513f => Some(unsafe { transmute(0x7af8u32) }),
0x5140 => Some(unsafe { transmute(0x5169u32) }),
0x5141 => Some(unsafe { transmute(0x516au32) }),
0x5142 => Some(unsafe { transmute(0x516eu32) }),
0x5143 => Some(unsafe { transmute(0x5180u32) }),
0x5144 => Some(unsafe { transmute(0x5182u32) }),
0x5145 => Some(unsafe { transmute(0x56d8u32) }),
0x5146 => Some(unsafe { transmute(0x518cu32) }),
0x5147 => Some(unsafe { transmute(0x5189u32) }),
0x5148 => Some(unsafe { transmute(0x518fu32) }),
0x5149 => Some(unsafe { transmute(0x5191u32) }),
0x514a => Some(unsafe { transmute(0x5193u32) }),
0x514b => Some(unsafe { transmute(0x5195u32) }),
0x514c => Some(unsafe { transmute(0x5196u32) }),
0x514d => Some(unsafe { transmute(0x51a4u32) }),
0x514e => Some(unsafe { transmute(0x51a6u32) }),
0x514f => Some(unsafe { transmute(0x51a2u32) }),
0x5150 => Some(unsafe { transmute(0x51a9u32) }),
0x5151 => Some(unsafe { transmute(0x51aau32) }),
0x5152 => Some(unsafe { transmute(0x51abu32) }),
0x5153 => Some(unsafe { transmute(0x51b3u32) }),
0x5154 => Some(unsafe { transmute(0x51b1u32) }),
0x5155 => Some(unsafe { transmute(0x51b2u32) }),
0x5156 => Some(unsafe { transmute(0x51b0u32) }),
0x5157 => Some(unsafe { transmute(0x51b5u32) }),
0x5158 => Some(unsafe { transmute(0x51bdu32) }),
0x5159 => Some(unsafe { transmute(0x51c5u32) }),
0x515a => Some(unsafe { transmute(0x51c9u32) }),
0x515b => Some(unsafe { transmute(0x51dbu32) }),
0x515c => Some(unsafe { transmute(0x51e0u32) }),
0x515d => Some(unsafe { transmute(0x8655u32) }),
0x515e => Some(unsafe { transmute(0x51e9u32) }),
0x515f => Some(unsafe { transmute(0x51edu32) }),
0x5160 => Some(unsafe { transmute(0x51f0u32) }),
0x5161 => Some(unsafe { transmute(0x51f5u32) }),
0x5162 => Some(unsafe { transmute(0x51feu32) }),
0x5163 => Some(unsafe { transmute(0x5204u32) }),
0x5164 => Some(unsafe { transmute(0x520bu32) }),
0x5165 => Some(unsafe { transmute(0x5214u32) }),
0x5166 => Some(unsafe { transmute(0x520eu32) }),
0x5167 => Some(unsafe { transmute(0x5227u32) }),
0x5168 => Some(unsafe { transmute(0x522au32) }),
0x5169 => Some(unsafe { transmute(0x522eu32) }),
0x516a => Some(unsafe { transmute(0x5233u32) }),
0x516b => Some(unsafe { transmute(0x5239u32) }),
0x516c => Some(unsafe { transmute(0x524fu32) }),
0x516d => Some(unsafe { transmute(0x5244u32) }),
0x516e => Some(unsafe { transmute(0x524bu32) }),
0x516f => Some(unsafe { transmute(0x524cu32) }),
0x5170 => Some(unsafe { transmute(0x525eu32) }),
0x5171 => Some(unsafe { transmute(0x5254u32) }),
0x5172 => Some(unsafe { transmute(0x526au32) }),
0x5173 => Some(unsafe { transmute(0x5274u32) }),
0x5174 => Some(unsafe { transmute(0x5269u32) }),
0x5175 => Some(unsafe { transmute(0x5273u32) }),
0x5176 => Some(unsafe { transmute(0x527fu32) }),
0x5177 => Some(unsafe { transmute(0x527du32) }),
0x5178 => Some(unsafe { transmute(0x528du32) }),
0x5179 => Some(unsafe { transmute(0x5294u32) }),
0x517a => Some(unsafe { transmute(0x5292u32) }),
0x517b => Some(unsafe { transmute(0x5271u32) }),
0x517c => Some(unsafe { transmute(0x5288u32) }),
0x517d => Some(unsafe { transmute(0x5291u32) }),
0x517e => Some(unsafe { transmute(0x8fa8u32) }),
0x5221 => Some(unsafe { transmute(0x8fa7u32) }),
0x5222 => Some(unsafe { transmute(0x52acu32) }),
0x5223 => Some(unsafe { transmute(0x52adu32) }),
0x5224 => Some(unsafe { transmute(0x52bcu32) }),
0x5225 => Some(unsafe { transmute(0x52b5u32) }),
0x5226 => Some(unsafe { transmute(0x52c1u32) }),
0x5227 => Some(unsafe { transmute(0x52cdu32) }),
0x5228 => Some(unsafe { transmute(0x52d7u32) }),
0x5229 => Some(unsafe { transmute(0x52deu32) }),
0x522a => Some(unsafe { transmute(0x52e3u32) }),
0x522b => Some(unsafe { transmute(0x52e6u32) }),
0x522c => Some(unsafe { transmute(0x98edu32) }),
0x522d => Some(unsafe { transmute(0x52e0u32) }),
0x522e => Some(unsafe { transmute(0x52f3u32) }),
0x522f => Some(unsafe { transmute(0x52f5u32) }),
0x5230 => Some(unsafe { transmute(0x52f8u32) }),
0x5231 => Some(unsafe { transmute(0x52f9u32) }),
0x5232 => Some(unsafe { transmute(0x5306u32) }),
0x5233 => Some(unsafe { transmute(0x5308u32) }),
0x5234 => Some(unsafe { transmute(0x7538u32) }),
0x5235 => Some(unsafe { transmute(0x530du32) }),
0x5236 => Some(unsafe { transmute(0x5310u32) }),
0x5237 => Some(unsafe { transmute(0x530fu32) }),
0x5238 => Some(unsafe { transmute(0x5315u32) }),
0x5239 => Some(unsafe { transmute(0x531au32) }),
0x523a => Some(unsafe { transmute(0x5323u32) }),
0x523b => Some(unsafe { transmute(0x532fu32) }),
0x523c => Some(unsafe { transmute(0x5331u32) }),
0x523d => Some(unsafe { transmute(0x5333u32) }),
0x523e => Some(unsafe { transmute(0x5338u32) }),
0x523f => Some(unsafe { transmute(0x5340u32) }),
0x5240 => Some(unsafe { transmute(0x5346u32) }),
0x5241 => Some(unsafe { transmute(0x5345u32) }),
0x5242 => Some(unsafe { transmute(0x4e17u32) }),
0x5243 => Some(unsafe { transmute(0x5349u32) }),
0x5244 => Some(unsafe { transmute(0x534du32) }),
0x5245 => Some(unsafe { transmute(0x51d6u32) }),
0x5246 => Some(unsafe { transmute(0x535eu32) }),
0x5247 => Some(unsafe { transmute(0x5369u32) }),
0x5248 => Some(unsafe { transmute(0x536eu32) }),
0x5249 => Some(unsafe { transmute(0x5918u32) }),
0x524a => Some(unsafe { transmute(0x537bu32) }),
0x524b => Some(unsafe { transmute(0x5377u32) }),
0x524c => Some(unsafe { transmute(0x5382u32) }),
0x524d => Some(unsafe { transmute(0x5396u32) }),
0x524e => Some(unsafe { transmute(0x53a0u32) }),
0x524f => Some(unsafe { transmute(0x53a6u32) }),
0x5250 => Some(unsafe { transmute(0x53a5u32) }),
0x5251 => Some(unsafe { transmute(0x53aeu32) }),
0x5252 => Some(unsafe { transmute(0x53b0u32) }),
0x5253 => Some(unsafe { transmute(0x53b6u32) }),
0x5254 => Some(unsafe { transmute(0x53c3u32) }),
0x5255 => Some(unsafe { transmute(0x7c12u32) }),
0x5256 => Some(unsafe { transmute(0x96d9u32) }),
0x5257 => Some(unsafe { transmute(0x53dfu32) }),
0x5258 => Some(unsafe { transmute(0x66fcu32) }),
0x5259 => Some(unsafe { transmute(0x71eeu32) }),
0x525a => Some(unsafe { transmute(0x53eeu32) }),
0x525b => Some(unsafe { transmute(0x53e8u32) }),
0x525c => Some(unsafe { transmute(0x53edu32) }),
0x525d => Some(unsafe { transmute(0x53fau32) }),
0x525e => Some(unsafe { transmute(0x5401u32) }),
0x525f => Some(unsafe { transmute(0x543du32) }),
0x5260 => Some(unsafe { transmute(0x5440u32) }),
0x5261 => Some(unsafe { transmute(0x542cu32) }),
0x5262 => Some(unsafe { transmute(0x542du32) }),
0x5263 => Some(unsafe { transmute(0x543cu32) }),
0x5264 => Some(unsafe { transmute(0x542eu32) }),
0x5265 => Some(unsafe { transmute(0x5436u32) }),
0x5266 => Some(unsafe { transmute(0x5429u32) }),
0x5267 => Some(unsafe { transmute(0x541du32) }),
0x5268 => Some(unsafe { transmute(0x544eu32) }),
0x5269 => Some(unsafe { transmute(0x548fu32) }),
0x526a => Some(unsafe { transmute(0x5475u32) }),
0x526b => Some(unsafe { transmute(0x548eu32) }),
0x526c => Some(unsafe { transmute(0x545fu32) }),
0x526d => Some(unsafe { transmute(0x5471u32) }),
0x526e => Some(unsafe { transmute(0x5477u32) }),
0x526f => Some(unsafe { transmute(0x5470u32) }),
0x5270 => Some(unsafe { transmute(0x5492u32) }),
0x5271 => Some(unsafe { transmute(0x547bu32) }),
0x5272 => Some(unsafe { transmute(0x5480u32) }),
0x5273 => Some(unsafe { transmute(0x5476u32) }),
0x5274 => Some(unsafe { transmute(0x5484u32) }),
0x5275 => Some(unsafe { transmute(0x5490u32) }),
0x5276 => Some(unsafe { transmute(0x5486u32) }),
0x5277 => Some(unsafe { transmute(0x54c7u32) }),
0x5278 => Some(unsafe { transmute(0x54a2u32) }),
0x5279 => Some(unsafe { transmute(0x54b8u32) }),
0x527a => Some(unsafe { transmute(0x54a5u32) }),
0x527b => Some(unsafe { transmute(0x54acu32) }),
0x527c => Some(unsafe { transmute(0x54c4u32) }),
0x527d => Some(unsafe { transmute(0x54c8u32) }),
0x527e => Some(unsafe { transmute(0x54a8u32) }),
0x5321 => Some(unsafe { transmute(0x54abu32) }),
0x5322 => Some(unsafe { transmute(0x54c2u32) }),
0x5323 => Some(unsafe { transmute(0x54a4u32) }),
0x5324 => Some(unsafe { transmute(0x54beu32) }),
0x5325 => Some(unsafe { transmute(0x54bcu32) }),
0x5326 => Some(unsafe { transmute(0x54d8u32) }),
0x5327 => Some(unsafe { transmute(0x54e5u32) }),
0x5328 => Some(unsafe { transmute(0x54e6u32) }),
0x5329 => Some(unsafe { transmute(0x550fu32) }),
0x532a => Some(unsafe { transmute(0x5514u32) }),
0x532b => Some(unsafe { transmute(0x54fdu32) }),
0x532c => Some(unsafe { transmute(0x54eeu32) }),
0x532d => Some(unsafe { transmute(0x54edu32) }),
0x532e => Some(unsafe { transmute(0x54fau32) }),
0x532f => Some(unsafe { transmute(0x54e2u32) }),
0x5330 => Some(unsafe { transmute(0x5539u32) }),
0x5331 => Some(unsafe { transmute(0x5540u32) }),
0x5332 => Some(unsafe { transmute(0x5563u32) }),
0x5333 => Some(unsafe { transmute(0x554cu32) }),
0x5334 => Some(unsafe { transmute(0x552eu32) }),
0x5335 => Some(unsafe { transmute(0x555cu32) }),
0x5336 => Some(unsafe { transmute(0x5545u32) }),
0x5337 => Some(unsafe { transmute(0x5556u32) }),
0x5338 => Some(unsafe { transmute(0x5557u32) }),
0x5339 => Some(unsafe { transmute(0x5538u32) }),
0x533a => Some(unsafe { transmute(0x5533u32) }),
0x533b => Some(unsafe { transmute(0x555du32) }),
0x533c => Some(unsafe { transmute(0x5599u32) }),
0x533d => Some(unsafe { transmute(0x5580u32) }),
0x533e => Some(unsafe { transmute(0x54afu32) }),
0x533f => Some(unsafe { transmute(0x558au32) }),
0x5340 => Some(unsafe { transmute(0x559fu32) }),
0x5341 => Some(unsafe { transmute(0x557bu32) }),
0x5342 => Some(unsafe { transmute(0x557eu32) }),
0x5343 => Some(unsafe { transmute(0x5598u32) }),
0x5344 => Some(unsafe { transmute(0x559eu32) }),
0x5345 => Some(unsafe { transmute(0x55aeu32) }),
0x5346 => Some(unsafe { transmute(0x557cu32) }),
0x5347 => Some(unsafe { transmute(0x5583u32) }),
0x5348 => Some(unsafe { transmute(0x55a9u32) }),
0x5349 => Some(unsafe { transmute(0x5587u32) }),
0x534a => Some(unsafe { transmute(0x55a8u32) }),
0x534b => Some(unsafe { transmute(0x55dau32) }),
0x534c => Some(unsafe { transmute(0x55c5u32) }),
0x534d => Some(unsafe { transmute(0x55dfu32) }),
0x534e => Some(unsafe { transmute(0x55c4u32) }),
0x534f => Some(unsafe { transmute(0x55dcu32) }),
0x5350 => Some(unsafe { transmute(0x55e4u32) }),
0x5351 => Some(unsafe { transmute(0x55d4u32) }),
0x5352 => Some(unsafe { transmute(0x5614u32) }),
0x5353 => Some(unsafe { transmute(0x55f7u32) }),
0x5354 => Some(unsafe { transmute(0x5616u32) }),
0x5355 => Some(unsafe { transmute(0x55feu32) }),
0x5356 => Some(unsafe { transmute(0x55fdu32) }),
0x5357 => Some(unsafe { transmute(0x561bu32) }),
0x5358 => Some(unsafe { transmute(0x55f9u32) }),
0x5359 => Some(unsafe { transmute(0x564eu32) }),
0x535a => Some(unsafe { transmute(0x5650u32) }),
0x535b => Some(unsafe { transmute(0x71dfu32) }),
0x535c => Some(unsafe { transmute(0x5634u32) }),
0x535d => Some(unsafe { transmute(0x5636u32) }),
0x535e => Some(unsafe { transmute(0x5632u32) }),
0x535f => Some(unsafe { transmute(0x5638u32) }),
0x5360 => Some(unsafe { transmute(0x566bu32) }),
0x5361 => Some(unsafe { transmute(0x5664u32) }),
0x5362 => Some(unsafe { transmute(0x562fu32) }),
0x5363 => Some(unsafe { transmute(0x566cu32) }),
0x5364 => Some(unsafe { transmute(0x566au32) }),
0x5365 => Some(unsafe { transmute(0x5686u32) }),
0x5366 => Some(unsafe { transmute(0x5680u32) }),
0x5367 => Some(unsafe { transmute(0x568au32) }),
0x5368 => Some(unsafe { transmute(0x56a0u32) }),
0x5369 => Some(unsafe { transmute(0x5694u32) }),
0x536a => Some(unsafe { transmute(0x568fu32) }),
0x536b => Some(unsafe { transmute(0x56a5u32) }),
0x536c => Some(unsafe { transmute(0x56aeu32) }),
0x536d => Some(unsafe { transmute(0x56b6u32) }),
0x536e => Some(unsafe { transmute(0x56b4u32) }),
0x536f => Some(unsafe { transmute(0x56c2u32) }),
0x5370 => Some(unsafe { transmute(0x56bcu32) }),
0x5371 => Some(unsafe { transmute(0x56c1u32) }),
0x5372 => Some(unsafe { transmute(0x56c3u32) }),
0x5373 => Some(unsafe { transmute(0x56c0u32) }),
0x5374 => Some(unsafe { transmute(0x56c8u32) }),
0x5375 => Some(unsafe { transmute(0x56ceu32) }),
0x5376 => Some(unsafe { transmute(0x56d1u32) }),
0x5377 => Some(unsafe { transmute(0x56d3u32) }),
0x5378 => Some(unsafe { transmute(0x56d7u32) }),
0x5379 => Some(unsafe { transmute(0x56eeu32) }),
0x537a => Some(unsafe { transmute(0x56f9u32) }),
0x537b => Some(unsafe { transmute(0x5700u32) }),
0x537c => Some(unsafe { transmute(0x56ffu32) }),
0x537d => Some(unsafe { transmute(0x5704u32) }),
0x537e => Some(unsafe { transmute(0x5709u32) }),
0x5421 => Some(unsafe { transmute(0x5708u32) }),
0x5422 => Some(unsafe { transmute(0x570bu32) }),
0x5423 => Some(unsafe { transmute(0x570du32) }),
0x5424 => Some(unsafe { transmute(0x5713u32) }),
0x5425 => Some(unsafe { transmute(0x5718u32) }),
0x5426 => Some(unsafe { transmute(0x5716u32) }),
0x5427 => Some(unsafe { transmute(0x55c7u32) }),
0x5428 => Some(unsafe { transmute(0x571cu32) }),
0x5429 => Some(unsafe { transmute(0x5726u32) }),
0x542a => Some(unsafe { transmute(0x5737u32) }),
0x542b => Some(unsafe { transmute(0x5738u32) }),
0x542c => Some(unsafe { transmute(0x574eu32) }),
0x542d => Some(unsafe { transmute(0x573bu32) }),
0x542e => Some(unsafe { transmute(0x5740u32) }),
0x542f => Some(unsafe { transmute(0x574fu32) }),
0x5430 => Some(unsafe { transmute(0x5769u32) }),
0x5431 => Some(unsafe { transmute(0x57c0u32) }),
0x5432 => Some(unsafe { transmute(0x5788u32) }),
0x5433 => Some(unsafe { transmute(0x5761u32) }),
0x5434 => Some(unsafe { transmute(0x577fu32) }),
0x5435 => Some(unsafe { transmute(0x5789u32) }),
0x5436 => Some(unsafe { transmute(0x5793u32) }),
0x5437 => Some(unsafe { transmute(0x57a0u32) }),
0x5438 => Some(unsafe { transmute(0x57b3u32) }),
0x5439 => Some(unsafe { transmute(0x57a4u32) }),
0x543a => Some(unsafe { transmute(0x57aau32) }),
0x543b => Some(unsafe { transmute(0x57b0u32) }),
0x543c => Some(unsafe { transmute(0x57c3u32) }),
0x543d => Some(unsafe { transmute(0x57c6u32) }),
0x543e => Some(unsafe { transmute(0x57d4u32) }),
0x543f => Some(unsafe { transmute(0x57d2u32) }),
0x5440 => Some(unsafe { transmute(0x57d3u32) }),
0x5441 => Some(unsafe { transmute(0x580au32) }),
0x5442 => Some(unsafe { transmute(0x57d6u32) }),
0x5443 => Some(unsafe { transmute(0x57e3u32) }),
0x5444 => Some(unsafe { transmute(0x580bu32) }),
0x5445 => Some(unsafe { transmute(0x5819u32) }),
0x5446 => Some(unsafe { transmute(0x581du32) }),
0x5447 => Some(unsafe { transmute(0x5872u32) }),
0x5448 => Some(unsafe { transmute(0x5821u32) }),
0x5449 => Some(unsafe { transmute(0x5862u32) }),
0x544a => Some(unsafe { transmute(0x584bu32) }),
0x544b => Some(unsafe { transmute(0x5870u32) }),
0x544c => Some(unsafe { transmute(0x6bc0u32) }),
0x544d => Some(unsafe { transmute(0x5852u32) }),
0x544e => Some(unsafe { transmute(0x583du32) }),
0x544f => Some(unsafe { transmute(0x5879u32) }),
0x5450 => Some(unsafe { transmute(0x5885u32) }),
0x5451 => Some(unsafe { transmute(0x58b9u32) }),
0x5452 => Some(unsafe { transmute(0x589fu32) }),
0x5453 => Some(unsafe { transmute(0x58abu32) }),
0x5454 => Some(unsafe { transmute(0x58bau32) }),
0x5455 => Some(unsafe { transmute(0x58deu32) }),
0x5456 => Some(unsafe { transmute(0x58bbu32) }),
0x5457 => Some(unsafe { transmute(0x58b8u32) }),
0x5458 => Some(unsafe { transmute(0x58aeu32) }),
0x5459 => Some(unsafe { transmute(0x58c5u32) }),
0x545a => Some(unsafe { transmute(0x58d3u32) }),
0x545b => Some(unsafe { transmute(0x58d1u32) }),
0x545c => Some(unsafe { transmute(0x58d7u32) }),
0x545d => Some(unsafe { transmute(0x58d9u32) }),
0x545e => Some(unsafe { transmute(0x58d8u32) }),
0x545f => Some(unsafe { transmute(0x58e5u32) }),
0x5460 => Some(unsafe { transmute(0x58dcu32) }),
0x5461 => Some(unsafe { transmute(0x58e4u32) }),
0x5462 => Some(unsafe { transmute(0x58dfu32) }),
0x5463 => Some(unsafe { transmute(0x58efu32) }),
0x5464 => Some(unsafe { transmute(0x58fau32) }),
0x5465 => Some(unsafe { transmute(0x58f9u32) }),
0x5466 => Some(unsafe { transmute(0x58fbu32) }),
0x5467 => Some(unsafe { transmute(0x58fcu32) }),
0x5468 => Some(unsafe { transmute(0x58fdu32) }),
0x5469 => Some(unsafe { transmute(0x5902u32) }),
0x546a => Some(unsafe { transmute(0x590au32) }),
0x546b => Some(unsafe { transmute(0x5910u32) }),
0x546c => Some(unsafe { transmute(0x591bu32) }),
0x546d => Some(unsafe { transmute(0x68a6u32) }),
0x546e => Some(unsafe { transmute(0x5925u32) }),
0x546f => Some(unsafe { transmute(0x592cu32) }),
0x5470 => Some(unsafe { transmute(0x592du32) }),
0x5471 => Some(unsafe { transmute(0x5932u32) }),
0x5472 => Some(unsafe { transmute(0x5938u32) }),
0x5473 => Some(unsafe { transmute(0x593eu32) }),
0x5474 => Some(unsafe { transmute(0x7ad2u32) }),
0x5475 => Some(unsafe { transmute(0x5955u32) }),
0x5476 => Some(unsafe { transmute(0x5950u32) }),
0x5477 => Some(unsafe { transmute(0x594eu32) }),
0x5478 => Some(unsafe { transmute(0x595au32) }),
0x5479 => Some(unsafe { transmute(0x5958u32) }),
0x547a => Some(unsafe { transmute(0x5962u32) }),
0x547b => Some(unsafe { transmute(0x5960u32) }),
0x547c => Some(unsafe { transmute(0x5967u32) }),
0x547d => Some(unsafe { transmute(0x596cu32) }),
0x547e => Some(unsafe { transmute(0x5969u32) }),
0x5521 => Some(unsafe { transmute(0x5978u32) }),
0x5522 => Some(unsafe { transmute(0x5981u32) }),
0x5523 => Some(unsafe { transmute(0x599du32) }),
0x5524 => Some(unsafe { transmute(0x4f5eu32) }),
0x5525 => Some(unsafe { transmute(0x4fabu32) }),
0x5526 => Some(unsafe { transmute(0x59a3u32) }),
0x5527 => Some(unsafe { transmute(0x59b2u32) }),
0x5528 => Some(unsafe { transmute(0x59c6u32) }),
0x5529 => Some(unsafe { transmute(0x59e8u32) }),
0x552a => Some(unsafe { transmute(0x59dcu32) }),
0x552b => Some(unsafe { transmute(0x598du32) }),
0x552c => Some(unsafe { transmute(0x59d9u32) }),
0x552d => Some(unsafe { transmute(0x59dau32) }),
0x552e => Some(unsafe { transmute(0x5a25u32) }),
0x552f => Some(unsafe { transmute(0x5a1fu32) }),
0x5530 => Some(unsafe { transmute(0x5a11u32) }),
0x5531 => Some(unsafe { transmute(0x5a1cu32) }),
0x5532 => Some(unsafe { transmute(0x5a09u32) }),
0x5533 => Some(unsafe { transmute(0x5a1au32) }),
0x5534 => Some(unsafe { transmute(0x5a40u32) }),
0x5535 => Some(unsafe { transmute(0x5a6cu32) }),
0x5536 => Some(unsafe { transmute(0x5a49u32) }),
0x5537 => Some(unsafe { transmute(0x5a35u32) }),
0x5538 => Some(unsafe { transmute(0x5a36u32) }),
0x5539 => Some(unsafe { transmute(0x5a62u32) }),
0x553a => Some(unsafe { transmute(0x5a6au32) }),
0x553b => Some(unsafe { transmute(0x5a9au32) }),
0x553c => Some(unsafe { transmute(0x5abcu32) }),
0x553d => Some(unsafe { transmute(0x5abeu32) }),
0x553e => Some(unsafe { transmute(0x5acbu32) }),
0x553f => Some(unsafe { transmute(0x5ac2u32) }),
0x5540 => Some(unsafe { transmute(0x5abdu32) }),
0x5541 => Some(unsafe { transmute(0x5ae3u32) }),
0x5542 => Some(unsafe { transmute(0x5ad7u32) }),
0x5543 => Some(unsafe { transmute(0x5ae6u32) }),
0x5544 => Some(unsafe { transmute(0x5ae9u32) }),
0x5545 => Some(unsafe { transmute(0x5ad6u32) }),
0x5546 => Some(unsafe { transmute(0x5afau32) }),
0x5547 => Some(unsafe { transmute(0x5afbu32) }),
0x5548 => Some(unsafe { transmute(0x5b0cu32) }),
0x5549 => Some(unsafe { transmute(0x5b0bu32) }),
0x554a => Some(unsafe { transmute(0x5b16u32) }),
0x554b => Some(unsafe { transmute(0x5b32u32) }),
0x554c => Some(unsafe { transmute(0x5ad0u32) }),
0x554d => Some(unsafe { transmute(0x5b2au32) }),
0x554e => Some(unsafe { transmute(0x5b36u32) }),
0x554f => Some(unsafe { transmute(0x5b3eu32) }),
0x5550 => Some(unsafe { transmute(0x5b43u32) }),
0x5551 => Some(unsafe { transmute(0x5b45u32) }),
0x5552 => Some(unsafe { transmute(0x5b40u32) }),
0x5553 => Some(unsafe { transmute(0x5b51u32) }),
0x5554 => Some(unsafe { transmute(0x5b55u32) }),
0x5555 => Some(unsafe { transmute(0x5b5au32) }),
0x5556 => Some(unsafe { transmute(0x5b5bu32) }),
0x5557 => Some(unsafe { transmute(0x5b65u32) }),
0x5558 => Some(unsafe { transmute(0x5b69u32) }),
0x5559 => Some(unsafe { transmute(0x5b70u32) }),
0x555a => Some(unsafe { transmute(0x5b73u32) }),
0x555b => Some(unsafe { transmute(0x5b75u32) }),
0x555c => Some(unsafe { transmute(0x5b78u32) }),
0x555d => Some(unsafe { transmute(0x6588u32) }),
0x555e => Some(unsafe { transmute(0x5b7au32) }),
0x555f => Some(unsafe { transmute(0x5b80u32) }),
0x5560 => Some(unsafe { transmute(0x5b83u32) }),
0x5561 => Some(unsafe { transmute(0x5ba6u32) }),
0x5562 => Some(unsafe { transmute(0x5bb8u32) }),
0x5563 => Some(unsafe { transmute(0x5bc3u32) }),
0x5564 => Some(unsafe { transmute(0x5bc7u32) }),
0x5565 => Some(unsafe { transmute(0x5bc9u32) }),
0x5566 => Some(unsafe { transmute(0x5bd4u32) }),
0x5567 => Some(unsafe { transmute(0x5bd0u32) }),
0x5568 => Some(unsafe { transmute(0x5be4u32) }),
0x5569 => Some(unsafe { transmute(0x5be6u32) }),
0x556a => Some(unsafe { transmute(0x5be2u32) }),
0x556b => Some(unsafe { transmute(0x5bdeu32) }),
0x556c => Some(unsafe { transmute(0x5be5u32) }),
0x556d => Some(unsafe { transmute(0x5bebu32) }),
0x556e => Some(unsafe { transmute(0x5bf0u32) }),
0x556f => Some(unsafe { transmute(0x5bf6u32) }),
0x5570 => Some(unsafe { transmute(0x5bf3u32) }),
0x5571 => Some(unsafe { transmute(0x5c05u32) }),
0x5572 => Some(unsafe { transmute(0x5c07u32) }),
0x5573 => Some(unsafe { transmute(0x5c08u32) }),
0x5574 => Some(unsafe { transmute(0x5c0du32) }),
0x5575 => Some(unsafe { transmute(0x5c13u32) }),
0x5576 => Some(unsafe { transmute(0x5c20u32) }),
0x5577 => Some(unsafe { transmute(0x5c22u32) }),
0x5578 => Some(unsafe { transmute(0x5c28u32) }),
0x5579 => Some(unsafe { transmute(0x5c38u32) }),
0x557a => Some(unsafe { transmute(0x5c39u32) }),
0x557b => Some(unsafe { transmute(0x5c41u32) }),
0x557c => Some(unsafe { transmute(0x5c46u32) }),
0x557d => Some(unsafe { transmute(0x5c4eu32) }),
0x557e => Some(unsafe { transmute(0x5c53u32) }),
0x5621 => Some(unsafe { transmute(0x5c50u32) }),
0x5622 => Some(unsafe { transmute(0x5c4fu32) }),
0x5623 => Some(unsafe { transmute(0x5b71u32) }),
0x5624 => Some(unsafe { transmute(0x5c6cu32) }),
0x5625 => Some(unsafe { transmute(0x5c6eu32) }),
0x5626 => Some(unsafe { transmute(0x4e62u32) }),
0x5627 => Some(unsafe { transmute(0x5c76u32) }),
0x5628 => Some(unsafe { transmute(0x5c79u32) }),
0x5629 => Some(unsafe { transmute(0x5c8cu32) }),
0x562a => Some(unsafe { transmute(0x5c91u32) }),
0x562b => Some(unsafe { transmute(0x5c94u32) }),
0x562c => Some(unsafe { transmute(0x599bu32) }),
0x562d => Some(unsafe { transmute(0x5cabu32) }),
0x562e => Some(unsafe { transmute(0x5cbbu32) }),
0x562f => Some(unsafe { transmute(0x5cb6u32) }),
0x5630 => Some(unsafe { transmute(0x5cbcu32) }),
0x5631 => Some(unsafe { transmute(0x5cb7u32) }),
0x5632 => Some(unsafe { transmute(0x5cc5u32) }),
0x5633 => Some(unsafe { transmute(0x5cbeu32) }),
0x5634 => Some(unsafe { transmute(0x5cc7u32) }),
0x5635 => Some(unsafe { transmute(0x5cd9u32) }),
0x5636 => Some(unsafe { transmute(0x5ce9u32) }),
0x5637 => Some(unsafe { transmute(0x5cfdu32) }),
0x5638 => Some(unsafe { transmute(0x5cfau32) }),
0x5639 => Some(unsafe { transmute(0x5cedu32) }),
0x563a => Some(unsafe { transmute(0x5d8cu32) }),
0x563b => Some(unsafe { transmute(0x5ceau32) }),
0x563c => Some(unsafe { transmute(0x5d0bu32) }),
0x563d => Some(unsafe { transmute(0x5d15u32) }),
0x563e => Some(unsafe { transmute(0x5d17u32) }),
0x563f => Some(unsafe { transmute(0x5d5cu32) }),
0x5640 => Some(unsafe { transmute(0x5d1fu32) }),
0x5641 => Some(unsafe { transmute(0x5d1bu32) }),
0x5642 => Some(unsafe { transmute(0x5d11u32) }),
0x5643 => Some(unsafe { transmute(0x5d14u32) }),
0x5644 => Some(unsafe { transmute(0x5d22u32) }),
0x5645 => Some(unsafe { transmute(0x5d1au32) }),
0x5646 => Some(unsafe { transmute(0x5d19u32) }),
0x5647 => Some(unsafe { transmute(0x5d18u32) }),
0x5648 => Some(unsafe { transmute(0x5d4cu32) }),
0x5649 => Some(unsafe { transmute(0x5d52u32) }),
0x564a => Some(unsafe { transmute(0x5d4eu32) }),
0x564b => Some(unsafe { transmute(0x5d4bu32) }),
0x564c => Some(unsafe { transmute(0x5d6cu32) }),
0x564d => Some(unsafe { transmute(0x5d73u32) }),
0x564e => Some(unsafe { transmute(0x5d76u32) }),
0x564f => Some(unsafe { transmute(0x5d87u32) }),
0x5650 => Some(unsafe { transmute(0x5d84u32) }),
0x5651 => Some(unsafe { transmute(0x5d82u32) }),
0x5652 => Some(unsafe { transmute(0x5da2u32) }),
0x5653 => Some(unsafe { transmute(0x5d9du32) }),
0x5654 => Some(unsafe { transmute(0x5dacu32) }),
0x5655 => Some(unsafe { transmute(0x5daeu32) }),
0x5656 => Some(unsafe { transmute(0x5dbdu32) }),
0x5657 => Some(unsafe { transmute(0x5d90u32) }),
0x5658 => Some(unsafe { transmute(0x5db7u32) }),
0x5659 => Some(unsafe { transmute(0x5dbcu32) }),
0x565a => Some(unsafe { transmute(0x5dc9u32) }),
0x565b => Some(unsafe { transmute(0x5dcdu32) }),
0x565c => Some(unsafe { transmute(0x5dd3u32) }),
0x565d => Some(unsafe { transmute(0x5dd2u32) }),
0x565e => Some(unsafe { transmute(0x5dd6u32) }),
0x565f => Some(unsafe { transmute(0x5ddbu32) }),
0x5660 => Some(unsafe { transmute(0x5debu32) }),
0x5661 => Some(unsafe { transmute(0x5df2u32) }),
0x5662 => Some(unsafe { transmute(0x5df5u32) }),
0x5663 => Some(unsafe { transmute(0x5e0bu32) }),
0x5664 => Some(unsafe { transmute(0x5e1au32) }),
0x5665 => Some(unsafe { transmute(0x5e19u32) }),
0x5666 => Some(unsafe { transmute(0x5e11u32) }),
0x5667 => Some(unsafe { transmute(0x5e1bu32) }),
0x5668 => Some(unsafe { transmute(0x5e36u32) }),
0x5669 => Some(unsafe { transmute(0x5e37u32) }),
0x566a => Some(unsafe { transmute(0x5e44u32) }),
0x566b => Some(unsafe { transmute(0x5e43u32) }),
0x566c => Some(unsafe { transmute(0x5e40u32) }),
0x566d => Some(unsafe { transmute(0x5e4eu32) }),
0x566e => Some(unsafe { transmute(0x5e57u32) }),
0x566f => Some(unsafe { transmute(0x5e54u32) }),
0x5670 => Some(unsafe { transmute(0x5e5fu32) }),
0x5671 => Some(unsafe { transmute(0x5e62u32) }),
0x5672 => Some(unsafe { transmute(0x5e64u32) }),
0x5673 => Some(unsafe { transmute(0x5e47u32) }),
0x5674 => Some(unsafe { transmute(0x5e75u32) }),
0x5675 => Some(unsafe { transmute(0x5e76u32) }),
0x5676 => Some(unsafe { transmute(0x5e7au32) }),
0x5677 => Some(unsafe { transmute(0x9ebcu32) }),
0x5678 => Some(unsafe { transmute(0x5e7fu32) }),
0x5679 => Some(unsafe { transmute(0x5ea0u32) }),
0x567a => Some(unsafe { transmute(0x5ec1u32) }),
0x567b => Some(unsafe { transmute(0x5ec2u32) }),
0x567c => Some(unsafe { transmute(0x5ec8u32) }),
0x567d => Some(unsafe { transmute(0x5ed0u32) }),
0x567e => Some(unsafe { transmute(0x5ecfu32) }),
0x5721 => Some(unsafe { transmute(0x5ed6u32) }),
0x5722 => Some(unsafe { transmute(0x5ee3u32) }),
0x5723 => Some(unsafe { transmute(0x5eddu32) }),
0x5724 => Some(unsafe { transmute(0x5edau32) }),
0x5725 => Some(unsafe { transmute(0x5edbu32) }),
0x5726 => Some(unsafe { transmute(0x5ee2u32) }),
0x5727 => Some(unsafe { transmute(0x5ee1u32) }),
0x5728 => Some(unsafe { transmute(0x5ee8u32) }),
0x5729 => Some(unsafe { transmute(0x5ee9u32) }),
0x572a => Some(unsafe { transmute(0x5eecu32) }),
0x572b => Some(unsafe { transmute(0x5ef1u32) }),
0x572c => Some(unsafe { transmute(0x5ef3u32) }),
0x572d => Some(unsafe { transmute(0x5ef0u32) }),
0x572e => Some(unsafe { transmute(0x5ef4u32) }),
0x572f => Some(unsafe { transmute(0x5ef8u32) }),
0x5730 => Some(unsafe { transmute(0x5efeu32) }),
0x5731 => Some(unsafe { transmute(0x5f03u32) }),
0x5732 => Some(unsafe { transmute(0x5f09u32) }),
0x5733 => Some(unsafe { transmute(0x5f5du32) }),
0x5734 => Some(unsafe { transmute(0x5f5cu32) }),
0x5735 => Some(unsafe { transmute(0x5f0bu32) }),
0x5736 => Some(unsafe { transmute(0x5f11u32) }),
0x5737 => Some(unsafe { transmute(0x5f16u32) }),
0x5738 => Some(unsafe { transmute(0x5f29u32) }),
0x5739 => Some(unsafe { transmute(0x5f2du32) }),
0x573a => Some(unsafe { transmute(0x5f38u32) }),
0x573b => Some(unsafe { transmute(0x5f41u32) }),
0x573c => Some(unsafe { transmute(0x5f48u32) }),
0x573d => Some(unsafe { transmute(0x5f4cu32) }),
0x573e => Some(unsafe { transmute(0x5f4eu32) }),
0x573f => Some(unsafe { transmute(0x5f2fu32) }),
0x5740 => Some(unsafe { transmute(0x5f51u32) }),
0x5741 => Some(unsafe { transmute(0x5f56u32) }),
0x5742 => Some(unsafe { transmute(0x5f57u32) }),
0x5743 => Some(unsafe { transmute(0x5f59u32) }),
0x5744 => Some(unsafe { transmute(0x5f61u32) }),
0x5745 => Some(unsafe { transmute(0x5f6du32) }),
0x5746 => Some(unsafe { transmute(0x5f73u32) }),
0x5747 => Some(unsafe { transmute(0x5f77u32) }),
0x5748 => Some(unsafe { transmute(0x5f83u32) }),
0x5749 => Some(unsafe { transmute(0x5f82u32) }),
0x574a => Some(unsafe { transmute(0x5f7fu32) }),
0x574b => Some(unsafe { transmute(0x5f8au32) }),
0x574c => Some(unsafe { transmute(0x5f88u32) }),
0x574d => Some(unsafe { transmute(0x5f91u32) }),
0x574e => Some(unsafe { transmute(0x5f87u32) }),
0x574f => Some(unsafe { transmute(0x5f9eu32) }),
0x5750 => Some(unsafe { transmute(0x5f99u32) }),
0x5751 => Some(unsafe { transmute(0x5f98u32) }),
0x5752 => Some(unsafe { transmute(0x5fa0u32) }),
0x5753 => Some(unsafe { transmute(0x5fa8u32) }),
0x5754 => Some(unsafe { transmute(0x5fadu32) }),
0x5755 => Some(unsafe { transmute(0x5fbcu32) }),
0x5756 => Some(unsafe { transmute(0x5fd6u32) }),
0x5757 => Some(unsafe { transmute(0x5ffbu32) }),
0x5758 => Some(unsafe { transmute(0x5fe4u32) }),
0x5759 => Some(unsafe { transmute(0x5ff8u32) }),
0x575a => Some(unsafe { transmute(0x5ff1u32) }),
0x575b => Some(unsafe { transmute(0x5fddu32) }),
0x575c => Some(unsafe { transmute(0x60b3u32) }),
0x575d => Some(unsafe { transmute(0x5fffu32) }),
0x575e => Some(unsafe { transmute(0x6021u32) }),
0x575f => Some(unsafe { transmute(0x6060u32) }),
0x5760 => Some(unsafe { transmute(0x6019u32) }),
0x5761 => Some(unsafe { transmute(0x6010u32) }),
0x5762 => Some(unsafe { transmute(0x6029u32) }),
0x5763 => Some(unsafe { transmute(0x600eu32) }),
0x5764 => Some(unsafe { transmute(0x6031u32) }),
0x5765 => Some(unsafe { transmute(0x601bu32) }),
0x5766 => Some(unsafe { transmute(0x6015u32) }),
0x5767 => Some(unsafe { transmute(0x602bu32) }),
0x5768 => Some(unsafe { transmute(0x6026u32) }),
0x5769 => Some(unsafe { transmute(0x600fu32) }),
0x576a => Some(unsafe { transmute(0x603au32) }),
0x576b => Some(unsafe { transmute(0x605au32) }),
0x576c => Some(unsafe { transmute(0x6041u32) }),
0x576d => Some(unsafe { transmute(0x606au32) }),
0x576e => Some(unsafe { transmute(0x6077u32) }),
0x576f => Some(unsafe { transmute(0x605fu32) }),
0x5770 => Some(unsafe { transmute(0x604au32) }),
0x5771 => Some(unsafe { transmute(0x6046u32) }),
0x5772 => Some(unsafe { transmute(0x604du32) }),
0x5773 => Some(unsafe { transmute(0x6063u32) }),
0x5774 => Some(unsafe { transmute(0x6043u32) }),
0x5775 => Some(unsafe { transmute(0x6064u32) }),
0x5776 => Some(unsafe { transmute(0x6042u32) }),
0x5777 => Some(unsafe { transmute(0x606cu32) }),
0x5778 => Some(unsafe { transmute(0x606bu32) }),
0x5779 => Some(unsafe { transmute(0x6059u32) }),
0x577a => Some(unsafe { transmute(0x6081u32) }),
0x577b => Some(unsafe { transmute(0x608du32) }),
0x577c => Some(unsafe { transmute(0x60e7u32) }),
0x577d => Some(unsafe { transmute(0x6083u32) }),
0x577e => Some(unsafe { transmute(0x609au32) }),
0x5821 => Some(unsafe { transmute(0x6084u32) }),
0x5822 => Some(unsafe { transmute(0x609bu32) }),
0x5823 => Some(unsafe { transmute(0x6096u32) }),
0x5824 => Some(unsafe { transmute(0x6097u32) }),
0x5825 => Some(unsafe { transmute(0x6092u32) }),
0x5826 => Some(unsafe { transmute(0x60a7u32) }),
0x5827 => Some(unsafe { transmute(0x608bu32) }),
0x5828 => Some(unsafe { transmute(0x60e1u32) }),
0x5829 => Some(unsafe { transmute(0x60b8u32) }),
0x582a => Some(unsafe { transmute(0x60e0u32) }),
0x582b => Some(unsafe { transmute(0x60d3u32) }),
0x582c => Some(unsafe { transmute(0x60b4u32) }),
0x582d => Some(unsafe { transmute(0x5ff0u32) }),
0x582e => Some(unsafe { transmute(0x60bdu32) }),
0x582f => Some(unsafe { transmute(0x60c6u32) }),
0x5830 => Some(unsafe { transmute(0x60b5u32) }),
0x5831 => Some(unsafe { transmute(0x60d8u32) }),
0x5832 => Some(unsafe { transmute(0x614du32) }),
0x5833 => Some(unsafe { transmute(0x6115u32) }),
0x5834 => Some(unsafe { transmute(0x6106u32) }),
0x5835 => Some(unsafe { transmute(0x60f6u32) }),
0x5836 => Some(unsafe { transmute(0x60f7u32) }),
0x5837 => Some(unsafe { transmute(0x6100u32) }),
0x5838 => Some(unsafe { transmute(0x60f4u32) }),
0x5839 => Some(unsafe { transmute(0x60fau32) }),
0x583a => Some(unsafe { transmute(0x6103u32) }),
0x583b => Some(unsafe { transmute(0x6121u32) }),
0x583c => Some(unsafe { transmute(0x60fbu32) }),
0x583d => Some(unsafe { transmute(0x60f1u32) }),
0x583e => Some(unsafe { transmute(0x610du32) }),
0x583f => Some(unsafe { transmute(0x610eu32) }),
0x5840 => Some(unsafe { transmute(0x6147u32) }),
0x5841 => Some(unsafe { transmute(0x613eu32) }),
0x5842 => Some(unsafe { transmute(0x6128u32) }),
0x5843 => Some(unsafe { transmute(0x6127u32) }),
0x5844 => Some(unsafe { transmute(0x614au32) }),
0x5845 => Some(unsafe { transmute(0x613fu32) }),
0x5846 => Some(unsafe { transmute(0x613cu32) }),
0x5847 => Some(unsafe { transmute(0x612cu32) }),
0x5848 => Some(unsafe { transmute(0x6134u32) }),
0x5849 => Some(unsafe { transmute(0x613du32) }),
0x584a => Some(unsafe { transmute(0x6142u32) }),
0x584b => Some(unsafe { transmute(0x6144u32) }),
0x584c => Some(unsafe { transmute(0x6173u32) }),
0x584d => Some(unsafe { transmute(0x6177u32) }),
0x584e => Some(unsafe { transmute(0x6158u32) }),
0x584f => Some(unsafe { transmute(0x6159u32) }),
0x5850 => Some(unsafe { transmute(0x615au32) }),
0x5851 => Some(unsafe { transmute(0x616bu32) }),
0x5852 => Some(unsafe { transmute(0x6174u32) }),
0x5853 => Some(unsafe { transmute(0x616fu32) }),
0x5854 => Some(unsafe { transmute(0x6165u32) }),
0x5855 => Some(unsafe { transmute(0x6171u32) }),
0x5856 => Some(unsafe { transmute(0x615fu32) }),
0x5857 => Some(unsafe { transmute(0x615du32) }),
0x5858 => Some(unsafe { transmute(0x6153u32) }),
0x5859 => Some(unsafe { transmute(0x6175u32) }),
0x585a => Some(unsafe { transmute(0x6199u32) }),
0x585b => Some(unsafe { transmute(0x6196u32) }),
0x585c => Some(unsafe { transmute(0x6187u32) }),
0x585d => Some(unsafe { transmute(0x61acu32) }),
0x585e => Some(unsafe { transmute(0x6194u32) }),
0x585f => Some(unsafe { transmute(0x619au32) }),
0x5860 => Some(unsafe { transmute(0x618au32) }),
0x5861 => Some(unsafe { transmute(0x6191u32) }),
0x5862 => Some(unsafe { transmute(0x61abu32) }),
0x5863 => Some(unsafe { transmute(0x61aeu32) }),
0x5864 => Some(unsafe { transmute(0x61ccu32) }),
0x5865 => Some(unsafe { transmute(0x61cau32) }),
0x5866 => Some(unsafe { transmute(0x61c9u32) }),
0x5867 => Some(unsafe { transmute(0x61f7u32) }),
0x5868 => Some(unsafe { transmute(0x61c8u32) }),
0x5869 => Some(unsafe { transmute(0x61c3u32) }),
0x586a => Some(unsafe { transmute(0x61c6u32) }),
0x586b => Some(unsafe { transmute(0x61bau32) }),
0x586c => Some(unsafe { transmute(0x61cbu32) }),
0x586d => Some(unsafe { transmute(0x7f79u32) }),
0x586e => Some(unsafe { transmute(0x61cdu32) }),
0x586f => Some(unsafe { transmute(0x61e6u32) }),
0x5870 => Some(unsafe { transmute(0x61e3u32) }),
0x5871 => Some(unsafe { transmute(0x61f6u32) }),
0x5872 => Some(unsafe { transmute(0x61fau32) }),
0x5873 => Some(unsafe { transmute(0x61f4u32) }),
0x5874 => Some(unsafe { transmute(0x61ffu32) }),
0x5875 => Some(unsafe { transmute(0x61fdu32) }),
0x5876 => Some(unsafe { transmute(0x61fcu32) }),
0x5877 => Some(unsafe { transmute(0x61feu32) }),
0x5878 => Some(unsafe { transmute(0x6200u32) }),
0x5879 => Some(unsafe { transmute(0x6208u32) }),
0x587a => Some(unsafe { transmute(0x6209u32) }),
0x587b => Some(unsafe { transmute(0x620du32) }),
0x587c => Some(unsafe { transmute(0x620cu32) }),
0x587d => Some(unsafe { transmute(0x6214u32) }),
0x587e => Some(unsafe { transmute(0x621bu32) }),
0x5921 => Some(unsafe { transmute(0x621eu32) }),
0x5922 => Some(unsafe { transmute(0x6221u32) }),
0x5923 => Some(unsafe { transmute(0x622au32) }),
0x5924 => Some(unsafe { transmute(0x622eu32) }),
0x5925 => Some(unsafe { transmute(0x6230u32) }),
0x5926 => Some(unsafe { transmute(0x6232u32) }),
0x5927 => Some(unsafe { transmute(0x6233u32) }),
0x5928 => Some(unsafe { transmute(0x6241u32) }),
0x5929 => Some(unsafe { transmute(0x624eu32) }),
0x592a => Some(unsafe { transmute(0x625eu32) }),
0x592b => Some(unsafe { transmute(0x6263u32) }),
0x592c => Some(unsafe { transmute(0x625bu32) }),
0x592d => Some(unsafe { transmute(0x6260u32) }),
0x592e => Some(unsafe { transmute(0x6268u32) }),
0x592f => Some(unsafe { transmute(0x627cu32) }),
0x5930 => Some(unsafe { transmute(0x6282u32) }),
0x5931 => Some(unsafe { transmute(0x6289u32) }),
0x5932 => Some(unsafe { transmute(0x627eu32) }),
0x5933 => Some(unsafe { transmute(0x6292u32) }),
0x5934 => Some(unsafe { transmute(0x6293u32) }),
0x5935 => Some(unsafe { transmute(0x6296u32) }),
0x5936 => Some(unsafe { transmute(0x62d4u32) }),
0x5937 => Some(unsafe { transmute(0x6283u32) }),
0x5938 => Some(unsafe { transmute(0x6294u32) }),
0x5939 => Some(unsafe { transmute(0x62d7u32) }),
0x593a => Some(unsafe { transmute(0x62d1u32) }),
0x593b => Some(unsafe { transmute(0x62bbu32) }),
0x593c => Some(unsafe { transmute(0x62cfu32) }),
0x593d => Some(unsafe { transmute(0x62ffu32) }),
0x593e => Some(unsafe { transmute(0x62c6u32) }),
0x593f => Some(unsafe { transmute(0x64d4u32) }),
0x5940 => Some(unsafe { transmute(0x62c8u32) }),
0x5941 => Some(unsafe { transmute(0x62dcu32) }),
0x5942 => Some(unsafe { transmute(0x62ccu32) }),
0x5943 => Some(unsafe { transmute(0x62cau32) }),
0x5944 => Some(unsafe { transmute(0x62c2u32) }),
0x5945 => Some(unsafe { transmute(0x62c7u32) }),
0x5946 => Some(unsafe { transmute(0x629bu32) }),
0x5947 => Some(unsafe { transmute(0x62c9u32) }),
0x5948 => Some(unsafe { transmute(0x630cu32) }),
0x5949 => Some(unsafe { transmute(0x62eeu32) }),
0x594a => Some(unsafe { transmute(0x62f1u32) }),
0x594b => Some(unsafe { transmute(0x6327u32) }),
0x594c => Some(unsafe { transmute(0x6302u32) }),
0x594d => Some(unsafe { transmute(0x6308u32) }),
0x594e => Some(unsafe { transmute(0x62efu32) }),
0x594f => Some(unsafe { transmute(0x62f5u32) }),
0x5950 => Some(unsafe { transmute(0x6350u32) }),
0x5951 => Some(unsafe { transmute(0x633eu32) }),
0x5952 => Some(unsafe { transmute(0x634du32) }),
0x5953 => Some(unsafe { transmute(0x641cu32) }),
0x5954 => Some(unsafe { transmute(0x634fu32) }),
0x5955 => Some(unsafe { transmute(0x6396u32) }),
0x5956 => Some(unsafe { transmute(0x638eu32) }),
0x5957 => Some(unsafe { transmute(0x6380u32) }),
0x5958 => Some(unsafe { transmute(0x63abu32) }),
0x5959 => Some(unsafe { transmute(0x6376u32) }),
0x595a => Some(unsafe { transmute(0x63a3u32) }),
0x595b => Some(unsafe { transmute(0x638fu32) }),
0x595c => Some(unsafe { transmute(0x6389u32) }),
0x595d => Some(unsafe { transmute(0x639fu32) }),
0x595e => Some(unsafe { transmute(0x63b5u32) }),
0x595f => Some(unsafe { transmute(0x636bu32) }),
0x5960 => Some(unsafe { transmute(0x6369u32) }),
0x5961 => Some(unsafe { transmute(0x63beu32) }),
0x5962 => Some(unsafe { transmute(0x63e9u32) }),
0x5963 => Some(unsafe { transmute(0x63c0u32) }),
0x5964 => Some(unsafe { transmute(0x63c6u32) }),
0x5965 => Some(unsafe { transmute(0x63e3u32) }),
0x5966 => Some(unsafe { transmute(0x63c9u32) }),
0x5967 => Some(unsafe { transmute(0x63d2u32) }),
0x5968 => Some(unsafe { transmute(0x63f6u32) }),
0x5969 => Some(unsafe { transmute(0x63c4u32) }),
0x596a => Some(unsafe { transmute(0x6416u32) }),
0x596b => Some(unsafe { transmute(0x6434u32) }),
0x596c => Some(unsafe { transmute(0x6406u32) }),
0x596d => Some(unsafe { transmute(0x6413u32) }),
0x596e => Some(unsafe { transmute(0x6426u32) }),
0x596f => Some(unsafe { transmute(0x6436u32) }),
0x5970 => Some(unsafe { transmute(0x651du32) }),
0x5971 => Some(unsafe { transmute(0x6417u32) }),
0x5972 => Some(unsafe { transmute(0x6428u32) }),
0x5973 => Some(unsafe { transmute(0x640fu32) }),
0x5974 => Some(unsafe { transmute(0x6467u32) }),
0x5975 => Some(unsafe { transmute(0x646fu32) }),
0x5976 => Some(unsafe { transmute(0x6476u32) }),
0x5977 => Some(unsafe { transmute(0x644eu32) }),
0x5978 => Some(unsafe { transmute(0x652au32) }),
0x5979 => Some(unsafe { transmute(0x6495u32) }),
0x597a => Some(unsafe { transmute(0x6493u32) }),
0x597b => Some(unsafe { transmute(0x64a5u32) }),
0x597c => Some(unsafe { transmute(0x64a9u32) }),
0x597d => Some(unsafe { transmute(0x6488u32) }),
0x597e => Some(unsafe { transmute(0x64bcu32) }),
0x5a21 => Some(unsafe { transmute(0x64dau32) }),
0x5a22 => Some(unsafe { transmute(0x64d2u32) }),
0x5a23 => Some(unsafe { transmute(0x64c5u32) }),
0x5a24 => Some(unsafe { transmute(0x64c7u32) }),
0x5a25 => Some(unsafe { transmute(0x64bbu32) }),
0x5a26 => Some(unsafe { transmute(0x64d8u32) }),
0x5a27 => Some(unsafe { transmute(0x64c2u32) }),
0x5a28 => Some(unsafe { transmute(0x64f1u32) }),
0x5a29 => Some(unsafe { transmute(0x64e7u32) }),
0x5a2a => Some(unsafe { transmute(0x8209u32) }),
0x5a2b => Some(unsafe { transmute(0x64e0u32) }),
0x5a2c => Some(unsafe { transmute(0x64e1u32) }),
0x5a2d => Some(unsafe { transmute(0x62acu32) }),
0x5a2e => Some(unsafe { transmute(0x64e3u32) }),
0x5a2f => Some(unsafe { transmute(0x64efu32) }),
0x5a30 => Some(unsafe { transmute(0x652cu32) }),
0x5a31 => Some(unsafe { transmute(0x64f6u32) }),
0x5a32 => Some(unsafe { transmute(0x64f4u32) }),
0x5a33 => Some(unsafe { transmute(0x64f2u32) }),
0x5a34 => Some(unsafe { transmute(0x64fau32) }),
0x5a35 => Some(unsafe { transmute(0x6500u32) }),
0x5a36 => Some(unsafe { transmute(0x64fdu32) }),
0x5a37 => Some(unsafe { transmute(0x6518u32) }),
0x5a38 => Some(unsafe { transmute(0x651cu32) }),
0x5a39 => Some(unsafe { transmute(0x6505u32) }),
0x5a3a => Some(unsafe { transmute(0x6524u32) }),
0x5a3b => Some(unsafe { transmute(0x6523u32) }),
0x5a3c => Some(unsafe { transmute(0x652bu32) }),
0x5a3d => Some(unsafe { transmute(0x6534u32) }),
0x5a3e => Some(unsafe { transmute(0x6535u32) }),
0x5a3f => Some(unsafe { transmute(0x6537u32) }),
0x5a40 => Some(unsafe { transmute(0x6536u32) }),
0x5a41 => Some(unsafe { transmute(0x6538u32) }),
0x5a42 => Some(unsafe { transmute(0x754bu32) }),
0x5a43 => Some(unsafe { transmute(0x6548u32) }),
0x5a44 => Some(unsafe { transmute(0x6556u32) }),
0x5a45 => Some(unsafe { transmute(0x6555u32) }),
0x5a46 => Some(unsafe { transmute(0x654du32) }),
0x5a47 => Some(unsafe { transmute(0x6558u32) }),
0x5a48 => Some(unsafe { transmute(0x655eu32) }),
0x5a49 => Some(unsafe { transmute(0x655du32) }),
0x5a4a => Some(unsafe { transmute(0x6572u32) }),
0x5a4b => Some(unsafe { transmute(0x6578u32) }),
0x5a4c => Some(unsafe { transmute(0x6582u32) }),
0x5a4d => Some(unsafe { transmute(0x6583u32) }),
0x5a4e => Some(unsafe { transmute(0x8b8au32) }),
0x5a4f => Some(unsafe { transmute(0x659bu32) }),
0x5a50 => Some(unsafe { transmute(0x659fu32) }),
0x5a51 => Some(unsafe { transmute(0x65abu32) }),
0x5a52 => Some(unsafe { transmute(0x65b7u32) }),
0x5a53 => Some(unsafe { transmute(0x65c3u32) }),
0x5a54 => Some(unsafe { transmute(0x65c6u32) }),
0x5a55 => Some(unsafe { transmute(0x65c1u32) }),
0x5a56 => Some(unsafe { transmute(0x65c4u32) }),
0x5a57 => Some(unsafe { transmute(0x65ccu32) }),
0x5a58 => Some(unsafe { transmute(0x65d2u32) }),
0x5a59 => Some(unsafe { transmute(0x65dbu32) }),
0x5a5a => Some(unsafe { transmute(0x65d9u32) }),
0x5a5b => Some(unsafe { transmute(0x65e0u32) }),
0x5a5c => Some(unsafe { transmute(0x65e1u32) }),
0x5a5d => Some(unsafe { transmute(0x65f1u32) }),
0x5a5e => Some(unsafe { transmute(0x6772u32) }),
0x5a5f => Some(unsafe { transmute(0x660au32) }),
0x5a60 => Some(unsafe { transmute(0x6603u32) }),
0x5a61 => Some(unsafe { transmute(0x65fbu32) }),
0x5a62 => Some(unsafe { transmute(0x6773u32) }),
0x5a63 => Some(unsafe { transmute(0x6635u32) }),
0x5a64 => Some(unsafe { transmute(0x6636u32) }),
0x5a65 => Some(unsafe { transmute(0x6634u32) }),
0x5a66 => Some(unsafe { transmute(0x661cu32) }),
0x5a67 => Some(unsafe { transmute(0x664fu32) }),
0x5a68 => Some(unsafe { transmute(0x6644u32) }),
0x5a69 => Some(unsafe { transmute(0x6649u32) }),
0x5a6a => Some(unsafe { transmute(0x6641u32) }),
0x5a6b => Some(unsafe { transmute(0x665eu32) }),
0x5a6c => Some(unsafe { transmute(0x665du32) }),
0x5a6d => Some(unsafe { transmute(0x6664u32) }),
0x5a6e => Some(unsafe { transmute(0x6667u32) }),
0x5a6f => Some(unsafe { transmute(0x6668u32) }),
0x5a70 => Some(unsafe { transmute(0x665fu32) }),
0x5a71 => Some(unsafe { transmute(0x6662u32) }),
0x5a72 => Some(unsafe { transmute(0x6670u32) }),
0x5a73 => Some(unsafe { transmute(0x6683u32) }),
0x5a74 => Some(unsafe { transmute(0x6688u32) }),
0x5a75 => Some(unsafe { transmute(0x668eu32) }),
0x5a76 => Some(unsafe { transmute(0x6689u32) }),
0x5a77 => Some(unsafe { transmute(0x6684u32) }),
0x5a78 => Some(unsafe { transmute(0x6698u32) }),
0x5a79 => Some(unsafe { transmute(0x669du32) }),
0x5a7a => Some(unsafe { transmute(0x66c1u32) }),
0x5a7b => Some(unsafe { transmute(0x66b9u32) }),
0x5a7c => Some(unsafe { transmute(0x66c9u32) }),
0x5a7d => Some(unsafe { transmute(0x66beu32) }),
0x5a7e => Some(unsafe { transmute(0x66bcu32) }),
0x5b21 => Some(unsafe { transmute(0x66c4u32) }),
0x5b22 => Some(unsafe { transmute(0x66b8u32) }),
0x5b23 => Some(unsafe { transmute(0x66d6u32) }),
0x5b24 => Some(unsafe { transmute(0x66dau32) }),
0x5b25 => Some(unsafe { transmute(0x66e0u32) }),
0x5b26 => Some(unsafe { transmute(0x663fu32) }),
0x5b27 => Some(unsafe { transmute(0x66e6u32) }),
0x5b28 => Some(unsafe { transmute(0x66e9u32) }),
0x5b29 => Some(unsafe { transmute(0x66f0u32) }),
0x5b2a => Some(unsafe { transmute(0x66f5u32) }),
0x5b2b => Some(unsafe { transmute(0x66f7u32) }),
0x5b2c => Some(unsafe { transmute(0x670fu32) }),
0x5b2d => Some(unsafe { transmute(0x6716u32) }),
0x5b2e => Some(unsafe { transmute(0x671eu32) }),
0x5b2f => Some(unsafe { transmute(0x6726u32) }),
0x5b30 => Some(unsafe { transmute(0x6727u32) }),
0x5b31 => Some(unsafe { transmute(0x9738u32) }),
0x5b32 => Some(unsafe { transmute(0x672eu32) }),
0x5b33 => Some(unsafe { transmute(0x673fu32) }),
0x5b34 => Some(unsafe { transmute(0x6736u32) }),
0x5b35 => Some(unsafe { transmute(0x6741u32) }),
0x5b36 => Some(unsafe { transmute(0x6738u32) }),
0x5b37 => Some(unsafe { transmute(0x6737u32) }),
0x5b38 => Some(unsafe { transmute(0x6746u32) }),
0x5b39 => Some(unsafe { transmute(0x675eu32) }),
0x5b3a => Some(unsafe { transmute(0x6760u32) }),
0x5b3b => Some(unsafe { transmute(0x6759u32) }),
0x5b3c => Some(unsafe { transmute(0x6763u32) }),
0x5b3d => Some(unsafe { transmute(0x6764u32) }),
0x5b3e => Some(unsafe { transmute(0x6789u32) }),
0x5b3f => Some(unsafe { transmute(0x6770u32) }),
0x5b40 => Some(unsafe { transmute(0x67a9u32) }),
0x5b41 => Some(unsafe { transmute(0x677cu32) }),
0x5b42 => Some(unsafe { transmute(0x676au32) }),
0x5b43 => Some(unsafe { transmute(0x678cu32) }),
0x5b44 => Some(unsafe { transmute(0x678bu32) }),
0x5b45 => Some(unsafe { transmute(0x67a6u32) }),
0x5b46 => Some(unsafe { transmute(0x67a1u32) }),
0x5b47 => Some(unsafe { transmute(0x6785u32) }),
0x5b48 => Some(unsafe { transmute(0x67b7u32) }),
0x5b49 => Some(unsafe { transmute(0x67efu32) }),
0x5b4a => Some(unsafe { transmute(0x67b4u32) }),
0x5b4b => Some(unsafe { transmute(0x67ecu32) }),
0x5b4c => Some(unsafe { transmute(0x67b3u32) }),
0x5b4d => Some(unsafe { transmute(0x67e9u32) }),
0x5b4e => Some(unsafe { transmute(0x67b8u32) }),
0x5b4f => Some(unsafe { transmute(0x67e4u32) }),
0x5b50 => Some(unsafe { transmute(0x67deu32) }),
0x5b51 => Some(unsafe { transmute(0x67ddu32) }),
0x5b52 => Some(unsafe { transmute(0x67e2u32) }),
0x5b53 => Some(unsafe { transmute(0x67eeu32) }),
0x5b54 => Some(unsafe { transmute(0x67b9u32) }),
0x5b55 => Some(unsafe { transmute(0x67ceu32) }),
0x5b56 => Some(unsafe { transmute(0x67c6u32) }),
0x5b57 => Some(unsafe { transmute(0x67e7u32) }),
0x5b58 => Some(unsafe { transmute(0x6a9cu32) }),
0x5b59 => Some(unsafe { transmute(0x681eu32) }),
0x5b5a => Some(unsafe { transmute(0x6846u32) }),
0x5b5b => Some(unsafe { transmute(0x6829u32) }),
0x5b5c => Some(unsafe { transmute(0x6840u32) }),
0x5b5d => Some(unsafe { transmute(0x684du32) }),
0x5b5e => Some(unsafe { transmute(0x6832u32) }),
0x5b5f => Some(unsafe { transmute(0x684eu32) }),
0x5b60 => Some(unsafe { transmute(0x68b3u32) }),
0x5b61 => Some(unsafe { transmute(0x682bu32) }),
0x5b62 => Some(unsafe { transmute(0x6859u32) }),
0x5b63 => Some(unsafe { transmute(0x6863u32) }),
0x5b64 => Some(unsafe { transmute(0x6877u32) }),
0x5b65 => Some(unsafe { transmute(0x687fu32) }),
0x5b66 => Some(unsafe { transmute(0x689fu32) }),
0x5b67 => Some(unsafe { transmute(0x688fu32) }),
0x5b68 => Some(unsafe { transmute(0x68adu32) }),
0x5b69 => Some(unsafe { transmute(0x6894u32) }),
0x5b6a => Some(unsafe { transmute(0x689du32) }),
0x5b6b => Some(unsafe { transmute(0x689bu32) }),
0x5b6c => Some(unsafe { transmute(0x6883u32) }),
0x5b6d => Some(unsafe { transmute(0x6aaeu32) }),
0x5b6e => Some(unsafe { transmute(0x68b9u32) }),
0x5b6f => Some(unsafe { transmute(0x6874u32) }),
0x5b70 => Some(unsafe { transmute(0x68b5u32) }),
0x5b71 => Some(unsafe { transmute(0x68a0u32) }),
0x5b72 => Some(unsafe { transmute(0x68bau32) }),
0x5b73 => Some(unsafe { transmute(0x690fu32) }),
0x5b74 => Some(unsafe { transmute(0x688du32) }),
0x5b75 => Some(unsafe { transmute(0x687eu32) }),
0x5b76 => Some(unsafe { transmute(0x6901u32) }),
0x5b77 => Some(unsafe { transmute(0x68cau32) }),
0x5b78 => Some(unsafe { transmute(0x6908u32) }),
0x5b79 => Some(unsafe { transmute(0x68d8u32) }),
0x5b7a => Some(unsafe { transmute(0x6922u32) }),
0x5b7b => Some(unsafe { transmute(0x6926u32) }),
0x5b7c => Some(unsafe { transmute(0x68e1u32) }),
0x5b7d => Some(unsafe { transmute(0x690cu32) }),
0x5b7e => Some(unsafe { transmute(0x68cdu32) }),
0x5c21 => Some(unsafe { transmute(0x68d4u32) }),
0x5c22 => Some(unsafe { transmute(0x68e7u32) }),
0x5c23 => Some(unsafe { transmute(0x68d5u32) }),
0x5c24 => Some(unsafe { transmute(0x6936u32) }),
0x5c25 => Some(unsafe { transmute(0x6912u32) }),
0x5c26 => Some(unsafe { transmute(0x6904u32) }),
0x5c27 => Some(unsafe { transmute(0x68d7u32) }),
0x5c28 => Some(unsafe { transmute(0x68e3u32) }),
0x5c29 => Some(unsafe { transmute(0x6925u32) }),
0x5c2a => Some(unsafe { transmute(0x68f9u32) }),
0x5c2b => Some(unsafe { transmute(0x68e0u32) }),
0x5c2c => Some(unsafe { transmute(0x68efu32) }),
0x5c2d => Some(unsafe { transmute(0x6928u32) }),
0x5c2e => Some(unsafe { transmute(0x692au32) }),
0x5c2f => Some(unsafe { transmute(0x691au32) }),
0x5c30 => Some(unsafe { transmute(0x6923u32) }),
0x5c31 => Some(unsafe { transmute(0x6921u32) }),
0x5c32 => Some(unsafe { transmute(0x68c6u32) }),
0x5c33 => Some(unsafe { transmute(0x6979u32) }),
0x5c34 => Some(unsafe { transmute(0x6977u32) }),
0x5c35 => Some(unsafe { transmute(0x695cu32) }),
0x5c36 => Some(unsafe { transmute(0x6978u32) }),
0x5c37 => Some(unsafe { transmute(0x696bu32) }),
0x5c38 => Some(unsafe { transmute(0x6954u32) }),
0x5c39 => Some(unsafe { transmute(0x697eu32) }),
0x5c3a => Some(unsafe { transmute(0x696eu32) }),
0x5c3b => Some(unsafe { transmute(0x6939u32) }),
0x5c3c => Some(unsafe { transmute(0x6974u32) }),
0x5c3d => Some(unsafe { transmute(0x693du32) }),
0x5c3e => Some(unsafe { transmute(0x6959u32) }),
0x5c3f => Some(unsafe { transmute(0x6930u32) }),
0x5c40 => Some(unsafe { transmute(0x6961u32) }),
0x5c41 => Some(unsafe { transmute(0x695eu32) }),
0x5c42 => Some(unsafe { transmute(0x695du32) }),
0x5c43 => Some(unsafe { transmute(0x6981u32) }),
0x5c44 => Some(unsafe { transmute(0x696au32) }),
0x5c45 => Some(unsafe { transmute(0x69b2u32) }),
0x5c46 => Some(unsafe { transmute(0x69aeu32) }),
0x5c47 => Some(unsafe { transmute(0x69d0u32) }),
0x5c48 => Some(unsafe { transmute(0x69bfu32) }),
0x5c49 => Some(unsafe { transmute(0x69c1u32) }),
0x5c4a => Some(unsafe { transmute(0x69d3u32) }),
0x5c4b => Some(unsafe { transmute(0x69beu32) }),
0x5c4c => Some(unsafe { transmute(0x69ceu32) }),
0x5c4d => Some(unsafe { transmute(0x5be8u32) }),
0x5c4e => Some(unsafe { transmute(0x69cau32) }),
0x5c4f => Some(unsafe { transmute(0x69ddu32) }),
0x5c50 => Some(unsafe { transmute(0x69bbu32) }),
0x5c51 => Some(unsafe { transmute(0x69c3u32) }),
0x5c52 => Some(unsafe { transmute(0x69a7u32) }),
0x5c53 => Some(unsafe { transmute(0x6a2eu32) }),
0x5c54 => Some(unsafe { transmute(0x6991u32) }),
0x5c55 => Some(unsafe { transmute(0x69a0u32) }),
0x5c56 => Some(unsafe { transmute(0x699cu32) }),
0x5c57 => Some(unsafe { transmute(0x6995u32) }),
0x5c58 => Some(unsafe { transmute(0x69b4u32) }),
0x5c59 => Some(unsafe { transmute(0x69deu32) }),
0x5c5a => Some(unsafe { transmute(0x69e8u32) }),
0x5c5b => Some(unsafe { transmute(0x6a02u32) }),
0x5c5c => Some(unsafe { transmute(0x6a1bu32) }),
0x5c5d => Some(unsafe { transmute(0x69ffu32) }),
0x5c5e => Some(unsafe { transmute(0x6b0au32) }),
0x5c5f => Some(unsafe { transmute(0x69f9u32) }),
0x5c60 => Some(unsafe { transmute(0x69f2u32) }),
0x5c61 => Some(unsafe { transmute(0x69e7u32) }),
0x5c62 => Some(unsafe { transmute(0x6a05u32) }),
0x5c63 => Some(unsafe { transmute(0x69b1u32) }),
0x5c64 => Some(unsafe { transmute(0x6a1eu32) }),
0x5c65 => Some(unsafe { transmute(0x69edu32) }),
0x5c66 => Some(unsafe { transmute(0x6a14u32) }),
0x5c67 => Some(unsafe { transmute(0x69ebu32) }),
0x5c68 => Some(unsafe { transmute(0x6a0au32) }),
0x5c69 => Some(unsafe { transmute(0x6a12u32) }),
0x5c6a => Some(unsafe { transmute(0x6ac1u32) }),
0x5c6b => Some(unsafe { transmute(0x6a23u32) }),
0x5c6c => Some(unsafe { transmute(0x6a13u32) }),
0x5c6d => Some(unsafe { transmute(0x6a44u32) }),
0x5c6e => Some(unsafe { transmute(0x6a0cu32) }),
0x5c6f => Some(unsafe { transmute(0x6a72u32) }),
0x5c70 => Some(unsafe { transmute(0x6a36u32) }),
0x5c71 => Some(unsafe { transmute(0x6a78u32) }),
0x5c72 => Some(unsafe { transmute(0x6a47u32) }),
0x5c73 => Some(unsafe { transmute(0x6a62u32) }),
0x5c74 => Some(unsafe { transmute(0x6a59u32) }),
0x5c75 => Some(unsafe { transmute(0x6a66u32) }),
0x5c76 => Some(unsafe { transmute(0x6a48u32) }),
0x5c77 => Some(unsafe { transmute(0x6a38u32) }),
0x5c78 => Some(unsafe { transmute(0x6a22u32) }),
0x5c79 => Some(unsafe { transmute(0x6a90u32) }),
0x5c7a => Some(unsafe { transmute(0x6a8du32) }),
0x5c7b => Some(unsafe { transmute(0x6aa0u32) }),
0x5c7c => Some(unsafe { transmute(0x6a84u32) }),
0x5c7d => Some(unsafe { transmute(0x6aa2u32) }),
0x5c7e => Some(unsafe { transmute(0x6aa3u32) }),
0x5d21 => Some(unsafe { transmute(0x6a97u32) }),
0x5d22 => Some(unsafe { transmute(0x8617u32) }),
0x5d23 => Some(unsafe { transmute(0x6abbu32) }),
0x5d24 => Some(unsafe { transmute(0x6ac3u32) }),
0x5d25 => Some(unsafe { transmute(0x6ac2u32) }),
0x5d26 => Some(unsafe { transmute(0x6ab8u32) }),
0x5d27 => Some(unsafe { transmute(0x6ab3u32) }),
0x5d28 => Some(unsafe { transmute(0x6aacu32) }),
0x5d29 => Some(unsafe { transmute(0x6adeu32) }),
0x5d2a => Some(unsafe { transmute(0x6ad1u32) }),
0x5d2b => Some(unsafe { transmute(0x6adfu32) }),
0x5d2c => Some(unsafe { transmute(0x6aaau32) }),
0x5d2d => Some(unsafe { transmute(0x6adau32) }),
0x5d2e => Some(unsafe { transmute(0x6aeau32) }),
0x5d2f => Some(unsafe { transmute(0x6afbu32) }),
0x5d30 => Some(unsafe { transmute(0x6b05u32) }),
0x5d31 => Some(unsafe { transmute(0x8616u32) }),
0x5d32 => Some(unsafe { transmute(0x6afau32) }),
0x5d33 => Some(unsafe { transmute(0x6b12u32) }),
0x5d34 => Some(unsafe { transmute(0x6b16u32) }),
0x5d35 => Some(unsafe { transmute(0x9b31u32) }),
0x5d36 => Some(unsafe { transmute(0x6b1fu32) }),
0x5d37 => Some(unsafe { transmute(0x6b38u32) }),
0x5d38 => Some(unsafe { transmute(0x6b37u32) }),
0x5d39 => Some(unsafe { transmute(0x76dcu32) }),
0x5d3a => Some(unsafe { transmute(0x6b39u32) }),
0x5d3b => Some(unsafe { transmute(0x98eeu32) }),
0x5d3c => Some(unsafe { transmute(0x6b47u32) }),
0x5d3d => Some(unsafe { transmute(0x6b43u32) }),
0x5d3e => Some(unsafe { transmute(0x6b49u32) }),
0x5d3f => Some(unsafe { transmute(0x6b50u32) }),
0x5d40 => Some(unsafe { transmute(0x6b59u32) }),
0x5d41 => Some(unsafe { transmute(0x6b54u32) }),
0x5d42 => Some(unsafe { transmute(0x6b5bu32) }),
0x5d43 => Some(unsafe { transmute(0x6b5fu32) }),
0x5d44 => Some(unsafe { transmute(0x6b61u32) }),
0x5d45 => Some(unsafe { transmute(0x6b78u32) }),
0x5d46 => Some(unsafe { transmute(0x6b79u32) }),
0x5d47 => Some(unsafe { transmute(0x6b7fu32) }),
0x5d48 => Some(unsafe { transmute(0x6b80u32) }),
0x5d49 => Some(unsafe { transmute(0x6b84u32) }),
0x5d4a => Some(unsafe { transmute(0x6b83u32) }),
0x5d4b => Some(unsafe { transmute(0x6b8du32) }),
0x5d4c => Some(unsafe { transmute(0x6b98u32) }),
0x5d4d => Some(unsafe { transmute(0x6b95u32) }),
0x5d4e => Some(unsafe { transmute(0x6b9eu32) }),
0x5d4f => Some(unsafe { transmute(0x6ba4u32) }),
0x5d50 => Some(unsafe { transmute(0x6baau32) }),
0x5d51 => Some(unsafe { transmute(0x6babu32) }),
0x5d52 => Some(unsafe { transmute(0x6bafu32) }),
0x5d53 => Some(unsafe { transmute(0x6bb2u32) }),
0x5d54 => Some(unsafe { transmute(0x6bb1u32) }),
0x5d55 => Some(unsafe { transmute(0x6bb3u32) }),
0x5d56 => Some(unsafe { transmute(0x6bb7u32) }),
0x5d57 => Some(unsafe { transmute(0x6bbcu32) }),
0x5d58 => Some(unsafe { transmute(0x6bc6u32) }),
0x5d59 => Some(unsafe { transmute(0x6bcbu32) }),
0x5d5a => Some(unsafe { transmute(0x6bd3u32) }),
0x5d5b => Some(unsafe { transmute(0x6bdfu32) }),
0x5d5c => Some(unsafe { transmute(0x6becu32) }),
0x5d5d => Some(unsafe { transmute(0x6bebu32) }),
0x5d5e => Some(unsafe { transmute(0x6bf3u32) }),
0x5d5f => Some(unsafe { transmute(0x6befu32) }),
0x5d60 => Some(unsafe { transmute(0x9ebeu32) }),
0x5d61 => Some(unsafe { transmute(0x6c08u32) }),
0x5d62 => Some(unsafe { transmute(0x6c13u32) }),
0x5d63 => Some(unsafe { transmute(0x6c14u32) }),
0x5d64 => Some(unsafe { transmute(0x6c1bu32) }),
0x5d65 => Some(unsafe { transmute(0x6c24u32) }),
0x5d66 => Some(unsafe { transmute(0x6c23u32) }),
0x5d67 => Some(unsafe { transmute(0x6c5eu32) }),
0x5d68 => Some(unsafe { transmute(0x6c55u32) }),
0x5d69 => Some(unsafe { transmute(0x6c62u32) }),
0x5d6a => Some(unsafe { transmute(0x6c6au32) }),
0x5d6b => Some(unsafe { transmute(0x6c82u32) }),
0x5d6c => Some(unsafe { transmute(0x6c8du32) }),
0x5d6d => Some(unsafe { transmute(0x6c9au32) }),
0x5d6e => Some(unsafe { transmute(0x6c81u32) }),
0x5d6f => Some(unsafe { transmute(0x6c9bu32) }),
0x5d70 => Some(unsafe { transmute(0x6c7eu32) }),
0x5d71 => Some(unsafe { transmute(0x6c68u32) }),
0x5d72 => Some(unsafe { transmute(0x6c73u32) }),
0x5d73 => Some(unsafe { transmute(0x6c92u32) }),
0x5d74 => Some(unsafe { transmute(0x6c90u32) }),
0x5d75 => Some(unsafe { transmute(0x6cc4u32) }),
0x5d76 => Some(unsafe { transmute(0x6cf1u32) }),
0x5d77 => Some(unsafe { transmute(0x6cd3u32) }),
0x5d78 => Some(unsafe { transmute(0x6cbdu32) }),
0x5d79 => Some(unsafe { transmute(0x6cd7u32) }),
0x5d7a => Some(unsafe { transmute(0x6cc5u32) }),
0x5d7b => Some(unsafe { transmute(0x6cddu32) }),
0x5d7c => Some(unsafe { transmute(0x6caeu32) }),
0x5d7d => Some(unsafe { transmute(0x6cb1u32) }),
0x5d7e => Some(unsafe { transmute(0x6cbeu32) }),
0x5e21 => Some(unsafe { transmute(0x6cbau32) }),
0x5e22 => Some(unsafe { transmute(0x6cdbu32) }),
0x5e23 => Some(unsafe { transmute(0x6cefu32) }),
0x5e24 => Some(unsafe { transmute(0x6cd9u32) }),
0x5e25 => Some(unsafe { transmute(0x6ceau32) }),
0x5e26 => Some(unsafe { transmute(0x6d1fu32) }),
0x5e27 => Some(unsafe { transmute(0x884du32) }),
0x5e28 => Some(unsafe { transmute(0x6d36u32) }),
0x5e29 => Some(unsafe { transmute(0x6d2bu32) }),
0x5e2a => Some(unsafe { transmute(0x6d3du32) }),
0x5e2b => Some(unsafe { transmute(0x6d38u32) }),
0x5e2c => Some(unsafe { transmute(0x6d19u32) }),
0x5e2d => Some(unsafe { transmute(0x6d35u32) }),
0x5e2e => Some(unsafe { transmute(0x6d33u32) }),
0x5e2f => Some(unsafe { transmute(0x6d12u32) }),
0x5e30 => Some(unsafe { transmute(0x6d0cu32) }),
0x5e31 => Some(unsafe { transmute(0x6d63u32) }),
0x5e32 => Some(unsafe { transmute(0x6d93u32) }),
0x5e33 => Some(unsafe { transmute(0x6d64u32) }),
0x5e34 => Some(unsafe { transmute(0x6d5au32) }),
0x5e35 => Some(unsafe { transmute(0x6d79u32) }),
0x5e36 => Some(unsafe { transmute(0x6d59u32) }),
0x5e37 => Some(unsafe { transmute(0x6d8eu32) }),
0x5e38 => Some(unsafe { transmute(0x6d95u32) }),
0x5e39 => Some(unsafe { transmute(0x6fe4u32) }),
0x5e3a => Some(unsafe { transmute(0x6d85u32) }),
0x5e3b => Some(unsafe { transmute(0x6df9u32) }),
0x5e3c => Some(unsafe { transmute(0x6e15u32) }),
0x5e3d => Some(unsafe { transmute(0x6e0au32) }),
0x5e3e => Some(unsafe { transmute(0x6db5u32) }),
0x5e3f => Some(unsafe { transmute(0x6dc7u32) }),
0x5e40 => Some(unsafe { transmute(0x6de6u32) }),
0x5e41 => Some(unsafe { transmute(0x6db8u32) }),
0x5e42 => Some(unsafe { transmute(0x6dc6u32) }),
0x5e43 => Some(unsafe { transmute(0x6decu32) }),
0x5e44 => Some(unsafe { transmute(0x6ddeu32) }),
0x5e45 => Some(unsafe { transmute(0x6dccu32) }),
0x5e46 => Some(unsafe { transmute(0x6de8u32) }),
0x5e47 => Some(unsafe { transmute(0x6dd2u32) }),
0x5e48 => Some(unsafe { transmute(0x6dc5u32) }),
0x5e49 => Some(unsafe { transmute(0x6dfau32) }),
0x5e4a => Some(unsafe { transmute(0x6dd9u32) }),
0x5e4b => Some(unsafe { transmute(0x6de4u32) }),
0x5e4c => Some(unsafe { transmute(0x6dd5u32) }),
0x5e4d => Some(unsafe { transmute(0x6deau32) }),
0x5e4e => Some(unsafe { transmute(0x6deeu32) }),
0x5e4f => Some(unsafe { transmute(0x6e2du32) }),
0x5e50 => Some(unsafe { transmute(0x6e6eu32) }),
0x5e51 => Some(unsafe { transmute(0x6e2eu32) }),
0x5e52 => Some(unsafe { transmute(0x6e19u32) }),
0x5e53 => Some(unsafe { transmute(0x6e72u32) }),
0x5e54 => Some(unsafe { transmute(0x6e5fu32) }),
0x5e55 => Some(unsafe { transmute(0x6e3eu32) }),
0x5e56 => Some(unsafe { transmute(0x6e23u32) }),
0x5e57 => Some(unsafe { transmute(0x6e6bu32) }),
0x5e58 => Some(unsafe { transmute(0x6e2bu32) }),
0x5e59 => Some(unsafe { transmute(0x6e76u32) }),
0x5e5a => Some(unsafe { transmute(0x6e4du32) }),
0x5e5b => Some(unsafe { transmute(0x6e1fu32) }),
0x5e5c => Some(unsafe { transmute(0x6e43u32) }),
0x5e5d => Some(unsafe { transmute(0x6e3au32) }),
0x5e5e => Some(unsafe { transmute(0x6e4eu32) }),
0x5e5f => Some(unsafe { transmute(0x6e24u32) }),
0x5e60 => Some(unsafe { transmute(0x6effu32) }),
0x5e61 => Some(unsafe { transmute(0x6e1du32) }),
0x5e62 => Some(unsafe { transmute(0x6e38u32) }),
0x5e63 => Some(unsafe { transmute(0x6e82u32) }),
0x5e64 => Some(unsafe { transmute(0x6eaau32) }),
0x5e65 => Some(unsafe { transmute(0x6e98u32) }),
0x5e66 => Some(unsafe { transmute(0x6ec9u32) }),
0x5e67 => Some(unsafe { transmute(0x6eb7u32) }),
0x5e68 => Some(unsafe { transmute(0x6ed3u32) }),
0x5e69 => Some(unsafe { transmute(0x6ebdu32) }),
0x5e6a => Some(unsafe { transmute(0x6eafu32) }),
0x5e6b => Some(unsafe { transmute(0x6ec4u32) }),
0x5e6c => Some(unsafe { transmute(0x6eb2u32) }),
0x5e6d => Some(unsafe { transmute(0x6ed4u32) }),
0x5e6e => Some(unsafe { transmute(0x6ed5u32) }),
0x5e6f => Some(unsafe { transmute(0x6e8fu32) }),
0x5e70 => Some(unsafe { transmute(0x6ea5u32) }),
0x5e71 => Some(unsafe { transmute(0x6ec2u32) }),
0x5e72 => Some(unsafe { transmute(0x6e9fu32) }),
0x5e73 => Some(unsafe { transmute(0x6f41u32) }),
0x5e74 => Some(unsafe { transmute(0x6f11u32) }),
0x5e75 => Some(unsafe { transmute(0x704cu32) }),
0x5e76 => Some(unsafe { transmute(0x6eecu32) }),
0x5e77 => Some(unsafe { transmute(0x6ef8u32) }),
0x5e78 => Some(unsafe { transmute(0x6efeu32) }),
0x5e79 => Some(unsafe { transmute(0x6f3fu32) }),
0x5e7a => Some(unsafe { transmute(0x6ef2u32) }),
0x5e7b => Some(unsafe { transmute(0x6f31u32) }),
0x5e7c => Some(unsafe { transmute(0x6eefu32) }),
0x5e7d => Some(unsafe { transmute(0x6f32u32) }),
0x5e7e => Some(unsafe { transmute(0x6eccu32) }),
0x5f21 => Some(unsafe { transmute(0x6f3eu32) }),
0x5f22 => Some(unsafe { transmute(0x6f13u32) }),
0x5f23 => Some(unsafe { transmute(0x6ef7u32) }),
0x5f24 => Some(unsafe { transmute(0x6f86u32) }),
0x5f25 => Some(unsafe { transmute(0x6f7au32) }),
0x5f26 => Some(unsafe { transmute(0x6f78u32) }),
0x5f27 => Some(unsafe { transmute(0x6f81u32) }),
0x5f28 => Some(unsafe { transmute(0x6f80u32) }),
0x5f29 => Some(unsafe { transmute(0x6f6fu32) }),
0x5f2a => Some(unsafe { transmute(0x6f5bu32) }),
0x5f2b => Some(unsafe { transmute(0x6ff3u32) }),
0x5f2c => Some(unsafe { transmute(0x6f6du32) }),
0x5f2d => Some(unsafe { transmute(0x6f82u32) }),
0x5f2e => Some(unsafe { transmute(0x6f7cu32) }),
0x5f2f => Some(unsafe { transmute(0x6f58u32) }),
0x5f30 => Some(unsafe { transmute(0x6f8eu32) }),
0x5f31 => Some(unsafe { transmute(0x6f91u32) }),
0x5f32 => Some(unsafe { transmute(0x6fc2u32) }),
0x5f33 => Some(unsafe { transmute(0x6f66u32) }),
0x5f34 => Some(unsafe { transmute(0x6fb3u32) }),
0x5f35 => Some(unsafe { transmute(0x6fa3u32) }),
0x5f36 => Some(unsafe { transmute(0x6fa1u32) }),
0x5f37 => Some(unsafe { transmute(0x6fa4u32) }),
0x5f38 => Some(unsafe { transmute(0x6fb9u32) }),
0x5f39 => Some(unsafe { transmute(0x6fc6u32) }),
0x5f3a => Some(unsafe { transmute(0x6faau32) }),
0x5f3b => Some(unsafe { transmute(0x6fdfu32) }),
0x5f3c => Some(unsafe { transmute(0x6fd5u32) }),
0x5f3d => Some(unsafe { transmute(0x6fecu32) }),
0x5f3e => Some(unsafe { transmute(0x6fd4u32) }),
0x5f3f => Some(unsafe { transmute(0x6fd8u32) }),
0x5f40 => Some(unsafe { transmute(0x6ff1u32) }),
0x5f41 => Some(unsafe { transmute(0x6feeu32) }),
0x5f42 => Some(unsafe { transmute(0x6fdbu32) }),
0x5f43 => Some(unsafe { transmute(0x7009u32) }),
0x5f44 => Some(unsafe { transmute(0x700bu32) }),
0x5f45 => Some(unsafe { transmute(0x6ffau32) }),
0x5f46 => Some(unsafe { transmute(0x7011u32) }),
0x5f47 => Some(unsafe { transmute(0x7001u32) }),
0x5f48 => Some(unsafe { transmute(0x700fu32) }),
0x5f49 => Some(unsafe { transmute(0x6ffeu32) }),
0x5f4a => Some(unsafe { transmute(0x701bu32) }),
0x5f4b => Some(unsafe { transmute(0x701au32) }),
0x5f4c => Some(unsafe { transmute(0x6f74u32) }),
0x5f4d => Some(unsafe { transmute(0x701du32) }),
0x5f4e => Some(unsafe { transmute(0x7018u32) }),
0x5f4f => Some(unsafe { transmute(0x701fu32) }),
0x5f50 => Some(unsafe { transmute(0x7030u32) }),
0x5f51 => Some(unsafe { transmute(0x703eu32) }),
0x5f52 => Some(unsafe { transmute(0x7032u32) }),
0x5f53 => Some(unsafe { transmute(0x7051u32) }),
0x5f54 => Some(unsafe { transmute(0x7063u32) }),
0x5f55 => Some(unsafe { transmute(0x7099u32) }),
0x5f56 => Some(unsafe { transmute(0x7092u32) }),
0x5f57 => Some(unsafe { transmute(0x70afu32) }),
0x5f58 => Some(unsafe { transmute(0x70f1u32) }),
0x5f59 => Some(unsafe { transmute(0x70acu32) }),
0x5f5a => Some(unsafe { transmute(0x70b8u32) }),
0x5f5b => Some(unsafe { transmute(0x70b3u32) }),
0x5f5c => Some(unsafe { transmute(0x70aeu32) }),
0x5f5d => Some(unsafe { transmute(0x70dfu32) }),
0x5f5e => Some(unsafe { transmute(0x70cbu32) }),
0x5f5f => Some(unsafe { transmute(0x70ddu32) }),
0x5f60 => Some(unsafe { transmute(0x70d9u32) }),
0x5f61 => Some(unsafe { transmute(0x7109u32) }),
0x5f62 => Some(unsafe { transmute(0x70fdu32) }),
0x5f63 => Some(unsafe { transmute(0x711cu32) }),
0x5f64 => Some(unsafe { transmute(0x7119u32) }),
0x5f65 => Some(unsafe { transmute(0x7165u32) }),
0x5f66 => Some(unsafe { transmute(0x7155u32) }),
0x5f67 => Some(unsafe { transmute(0x7188u32) }),
0x5f68 => Some(unsafe { transmute(0x7166u32) }),
0x5f69 => Some(unsafe { transmute(0x7162u32) }),
0x5f6a => Some(unsafe { transmute(0x714cu32) }),
0x5f6b => Some(unsafe { transmute(0x7156u32) }),
0x5f6c => Some(unsafe { transmute(0x716cu32) }),
0x5f6d => Some(unsafe { transmute(0x718fu32) }),
0x5f6e => Some(unsafe { transmute(0x71fbu32) }),
0x5f6f => Some(unsafe { transmute(0x7184u32) }),
0x5f70 => Some(unsafe { transmute(0x7195u32) }),
0x5f71 => Some(unsafe { transmute(0x71a8u32) }),
0x5f72 => Some(unsafe { transmute(0x71acu32) }),
0x5f73 => Some(unsafe { transmute(0x71d7u32) }),
0x5f74 => Some(unsafe { transmute(0x71b9u32) }),
0x5f75 => Some(unsafe { transmute(0x71beu32) }),
0x5f76 => Some(unsafe { transmute(0x71d2u32) }),
0x5f77 => Some(unsafe { transmute(0x71c9u32) }),
0x5f78 => Some(unsafe { transmute(0x71d4u32) }),
0x5f79 => Some(unsafe { transmute(0x71ceu32) }),
0x5f7a => Some(unsafe { transmute(0x71e0u32) }),
0x5f7b => Some(unsafe { transmute(0x71ecu32) }),
0x5f7c => Some(unsafe { transmute(0x71e7u32) }),
0x5f7d => Some(unsafe { transmute(0x71f5u32) }),
0x5f7e => Some(unsafe { transmute(0x71fcu32) }),
0x6021 => Some(unsafe { transmute(0x71f9u32) }),
0x6022 => Some(unsafe { transmute(0x71ffu32) }),
0x6023 => Some(unsafe { transmute(0x720du32) }),
0x6024 => Some(unsafe { transmute(0x7210u32) }),
0x6025 => Some(unsafe { transmute(0x721bu32) }),
0x6026 => Some(unsafe { transmute(0x7228u32) }),
0x6027 => Some(unsafe { transmute(0x722du32) }),
0x6028 => Some(unsafe { transmute(0x722cu32) }),
0x6029 => Some(unsafe { transmute(0x7230u32) }),
0x602a => Some(unsafe { transmute(0x7232u32) }),
0x602b => Some(unsafe { transmute(0x723bu32) }),
0x602c => Some(unsafe { transmute(0x723cu32) }),
0x602d => Some(unsafe { transmute(0x723fu32) }),
0x602e => Some(unsafe { transmute(0x7240u32) }),
0x602f => Some(unsafe { transmute(0x7246u32) }),
0x6030 => Some(unsafe { transmute(0x724bu32) }),
0x6031 => Some(unsafe { transmute(0x7258u32) }),
0x6032 => Some(unsafe { transmute(0x7274u32) }),
0x6033 => Some(unsafe { transmute(0x727eu32) }),
0x6034 => Some(unsafe { transmute(0x7282u32) }),
0x6035 => Some(unsafe { transmute(0x7281u32) }),
0x6036 => Some(unsafe { transmute(0x7287u32) }),
0x6037 => Some(unsafe { transmute(0x7292u32) }),
0x6038 => Some(unsafe { transmute(0x7296u32) }),
0x6039 => Some(unsafe { transmute(0x72a2u32) }),
0x603a => Some(unsafe { transmute(0x72a7u32) }),
0x603b => Some(unsafe { transmute(0x72b9u32) }),
0x603c => Some(unsafe { transmute(0x72b2u32) }),
0x603d => Some(unsafe { transmute(0x72c3u32) }),
0x603e => Some(unsafe { transmute(0x72c6u32) }),
0x603f => Some(unsafe { transmute(0x72c4u32) }),
0x6040 => Some(unsafe { transmute(0x72ceu32) }),
0x6041 => Some(unsafe { transmute(0x72d2u32) }),
0x6042 => Some(unsafe { transmute(0x72e2u32) }),
0x6043 => Some(unsafe { transmute(0x72e0u32) }),
0x6044 => Some(unsafe { transmute(0x72e1u32) }),
0x6045 => Some(unsafe { transmute(0x72f9u32) }),
0x6046 => Some(unsafe { transmute(0x72f7u32) }),
0x6047 => Some(unsafe { transmute(0x500fu32) }),
0x6048 => Some(unsafe { transmute(0x7317u32) }),
0x6049 => Some(unsafe { transmute(0x730au32) }),
0x604a => Some(unsafe { transmute(0x731cu32) }),
0x604b => Some(unsafe { transmute(0x7316u32) }),
0x604c => Some(unsafe { transmute(0x731du32) }),
0x604d => Some(unsafe { transmute(0x7334u32) }),
0x604e => Some(unsafe { transmute(0x732fu32) }),
0x604f => Some(unsafe { transmute(0x7329u32) }),
0x6050 => Some(unsafe { transmute(0x7325u32) }),
0x6051 => Some(unsafe { transmute(0x733eu32) }),
0x6052 => Some(unsafe { transmute(0x734eu32) }),
0x6053 => Some(unsafe { transmute(0x734fu32) }),
0x6054 => Some(unsafe { transmute(0x9ed8u32) }),
0x6055 => Some(unsafe { transmute(0x7357u32) }),
0x6056 => Some(unsafe { transmute(0x736au32) }),
0x6057 => Some(unsafe { transmute(0x7368u32) }),
0x6058 => Some(unsafe { transmute(0x7370u32) }),
0x6059 => Some(unsafe { transmute(0x7378u32) }),
0x605a => Some(unsafe { transmute(0x7375u32) }),
0x605b => Some(unsafe { transmute(0x737bu32) }),
0x605c => Some(unsafe { transmute(0x737au32) }),
0x605d => Some(unsafe { transmute(0x73c8u32) }),
0x605e => Some(unsafe { transmute(0x73b3u32) }),
0x605f => Some(unsafe { transmute(0x73ceu32) }),
0x6060 => Some(unsafe { transmute(0x73bbu32) }),
0x6061 => Some(unsafe { transmute(0x73c0u32) }),
0x6062 => Some(unsafe { transmute(0x73e5u32) }),
0x6063 => Some(unsafe { transmute(0x73eeu32) }),
0x6064 => Some(unsafe { transmute(0x73deu32) }),
0x6065 => Some(unsafe { transmute(0x74a2u32) }),
0x6066 => Some(unsafe { transmute(0x7405u32) }),
0x6067 => Some(unsafe { transmute(0x746fu32) }),
0x6068 => Some(unsafe { transmute(0x7425u32) }),
0x6069 => Some(unsafe { transmute(0x73f8u32) }),
0x606a => Some(unsafe { transmute(0x7432u32) }),
0x606b => Some(unsafe { transmute(0x743au32) }),
0x606c => Some(unsafe { transmute(0x7455u32) }),
0x606d => Some(unsafe { transmute(0x743fu32) }),
0x606e => Some(unsafe { transmute(0x745fu32) }),
0x606f => Some(unsafe { transmute(0x7459u32) }),
0x6070 => Some(unsafe { transmute(0x7441u32) }),
0x6071 => Some(unsafe { transmute(0x745cu32) }),
0x6072 => Some(unsafe { transmute(0x7469u32) }),
0x6073 => Some(unsafe { transmute(0x7470u32) }),
0x6074 => Some(unsafe { transmute(0x7463u32) }),
0x6075 => Some(unsafe { transmute(0x746au32) }),
0x6076 => Some(unsafe { transmute(0x7476u32) }),
0x6077 => Some(unsafe { transmute(0x747eu32) }),
0x6078 => Some(unsafe { transmute(0x748bu32) }),
0x6079 => Some(unsafe { transmute(0x749eu32) }),
0x607a => Some(unsafe { transmute(0x74a7u32) }),
0x607b => Some(unsafe { transmute(0x74cau32) }),
0x607c => Some(unsafe { transmute(0x74cfu32) }),
0x607d => Some(unsafe { transmute(0x74d4u32) }),
0x607e => Some(unsafe { transmute(0x73f1u32) }),
0x6121 => Some(unsafe { transmute(0x74e0u32) }),
0x6122 => Some(unsafe { transmute(0x74e3u32) }),
0x6123 => Some(unsafe { transmute(0x74e7u32) }),
0x6124 => Some(unsafe { transmute(0x74e9u32) }),
0x6125 => Some(unsafe { transmute(0x74eeu32) }),
0x6126 => Some(unsafe { transmute(0x74f2u32) }),
0x6127 => Some(unsafe { transmute(0x74f0u32) }),
0x6128 => Some(unsafe { transmute(0x74f1u32) }),
0x6129 => Some(unsafe { transmute(0x74f8u32) }),
0x612a => Some(unsafe { transmute(0x74f7u32) }),
0x612b => Some(unsafe { transmute(0x7504u32) }),
0x612c => Some(unsafe { transmute(0x7503u32) }),
0x612d => Some(unsafe { transmute(0x7505u32) }),
0x612e => Some(unsafe { transmute(0x750cu32) }),
0x612f => Some(unsafe { transmute(0x750eu32) }),
0x6130 => Some(unsafe { transmute(0x750du32) }),
0x6131 => Some(unsafe { transmute(0x7515u32) }),
0x6132 => Some(unsafe { transmute(0x7513u32) }),
0x6133 => Some(unsafe { transmute(0x751eu32) }),
0x6134 => Some(unsafe { transmute(0x7526u32) }),
0x6135 => Some(unsafe { transmute(0x752cu32) }),
0x6136 => Some(unsafe { transmute(0x753cu32) }),
0x6137 => Some(unsafe { transmute(0x7544u32) }),
0x6138 => Some(unsafe { transmute(0x754du32) }),
0x6139 => Some(unsafe { transmute(0x754au32) }),
0x613a => Some(unsafe { transmute(0x7549u32) }),
0x613b => Some(unsafe { transmute(0x755bu32) }),
0x613c => Some(unsafe { transmute(0x7546u32) }),
0x613d => Some(unsafe { transmute(0x755au32) }),
0x613e => Some(unsafe { transmute(0x7569u32) }),
0x613f => Some(unsafe { transmute(0x7564u32) }),
0x6140 => Some(unsafe { transmute(0x7567u32) }),
0x6141 => Some(unsafe { transmute(0x756bu32) }),
0x6142 => Some(unsafe { transmute(0x756du32) }),
0x6143 => Some(unsafe { transmute(0x7578u32) }),
0x6144 => Some(unsafe { transmute(0x7576u32) }),
0x6145 => Some(unsafe { transmute(0x7586u32) }),
0x6146 => Some(unsafe { transmute(0x7587u32) }),
0x6147 => Some(unsafe { transmute(0x7574u32) }),
0x6148 => Some(unsafe { transmute(0x758au32) }),
0x6149 => Some(unsafe { transmute(0x7589u32) }),
0x614a => Some(unsafe { transmute(0x7582u32) }),
0x614b => Some(unsafe { transmute(0x7594u32) }),
0x614c => Some(unsafe { transmute(0x759au32) }),
0x614d => Some(unsafe { transmute(0x759du32) }),
0x614e => Some(unsafe { transmute(0x75a5u32) }),
0x614f => Some(unsafe { transmute(0x75a3u32) }),
0x6150 => Some(unsafe { transmute(0x75c2u32) }),
0x6151 => Some(unsafe { transmute(0x75b3u32) }),
0x6152 => Some(unsafe { transmute(0x75c3u32) }),
0x6153 => Some(unsafe { transmute(0x75b5u32) }),
0x6154 => Some(unsafe { transmute(0x75bdu32) }),
0x6155 => Some(unsafe { transmute(0x75b8u32) }),
0x6156 => Some(unsafe { transmute(0x75bcu32) }),
0x6157 => Some(unsafe { transmute(0x75b1u32) }),
0x6158 => Some(unsafe { transmute(0x75cdu32) }),
0x6159 => Some(unsafe { transmute(0x75cau32) }),
0x615a => Some(unsafe { transmute(0x75d2u32) }),
0x615b => Some(unsafe { transmute(0x75d9u32) }),
0x615c => Some(unsafe { transmute(0x75e3u32) }),
0x615d => Some(unsafe { transmute(0x75deu32) }),
0x615e => Some(unsafe { transmute(0x75feu32) }),
0x615f => Some(unsafe { transmute(0x75ffu32) }),
0x6160 => Some(unsafe { transmute(0x75fcu32) }),
0x6161 => Some(unsafe { transmute(0x7601u32) }),
0x6162 => Some(unsafe { transmute(0x75f0u32) }),
0x6163 => Some(unsafe { transmute(0x75fau32) }),
0x6164 => Some(unsafe { transmute(0x75f2u32) }),
0x6165 => Some(unsafe { transmute(0x75f3u32) }),
0x6166 => Some(unsafe { transmute(0x760bu32) }),
0x6167 => Some(unsafe { transmute(0x760du32) }),
0x6168 => Some(unsafe { transmute(0x7609u32) }),
0x6169 => Some(unsafe { transmute(0x761fu32) }),
0x616a => Some(unsafe { transmute(0x7627u32) }),
0x616b => Some(unsafe { transmute(0x7620u32) }),
0x616c => Some(unsafe { transmute(0x7621u32) }),
0x616d => Some(unsafe { transmute(0x7622u32) }),
0x616e => Some(unsafe { transmute(0x7624u32) }),
0x616f => Some(unsafe { transmute(0x7634u32) }),
0x6170 => Some(unsafe { transmute(0x7630u32) }),
0x6171 => Some(unsafe { transmute(0x763bu32) }),
0x6172 => Some(unsafe { transmute(0x7647u32) }),
0x6173 => Some(unsafe { transmute(0x7648u32) }),
0x6174 => Some(unsafe { transmute(0x7646u32) }),
0x6175 => Some(unsafe { transmute(0x765cu32) }),
0x6176 => Some(unsafe { transmute(0x7658u32) }),
0x6177 => Some(unsafe { transmute(0x7661u32) }),
0x6178 => Some(unsafe { transmute(0x7662u32) }),
0x6179 => Some(unsafe { transmute(0x7668u32) }),
0x617a => Some(unsafe { transmute(0x7669u32) }),
0x617b => Some(unsafe { transmute(0x766au32) }),
0x617c => Some(unsafe { transmute(0x7667u32) }),
0x617d => Some(unsafe { transmute(0x766cu32) }),
0x617e => Some(unsafe { transmute(0x7670u32) }),
0x6221 => Some(unsafe { transmute(0x7672u32) }),
0x6222 => Some(unsafe { transmute(0x7676u32) }),
0x6223 => Some(unsafe { transmute(0x7678u32) }),
0x6224 => Some(unsafe { transmute(0x767cu32) }),
0x6225 => Some(unsafe { transmute(0x7680u32) }),
0x6226 => Some(unsafe { transmute(0x7683u32) }),
0x6227 => Some(unsafe { transmute(0x7688u32) }),
0x6228 => Some(unsafe { transmute(0x768bu32) }),
0x6229 => Some(unsafe { transmute(0x768eu32) }),
0x622a => Some(unsafe { transmute(0x7696u32) }),
0x622b => Some(unsafe { transmute(0x7693u32) }),
0x622c => Some(unsafe { transmute(0x7699u32) }),
0x622d => Some(unsafe { transmute(0x769au32) }),
0x622e => Some(unsafe { transmute(0x76b0u32) }),
0x622f => Some(unsafe { transmute(0x76b4u32) }),
0x6230 => Some(unsafe { transmute(0x76b8u32) }),
0x6231 => Some(unsafe { transmute(0x76b9u32) }),
0x6232 => Some(unsafe { transmute(0x76bau32) }),
0x6233 => Some(unsafe { transmute(0x76c2u32) }),
0x6234 => Some(unsafe { transmute(0x76cdu32) }),
0x6235 => Some(unsafe { transmute(0x76d6u32) }),
0x6236 => Some(unsafe { transmute(0x76d2u32) }),
0x6237 => Some(unsafe { transmute(0x76deu32) }),
0x6238 => Some(unsafe { transmute(0x76e1u32) }),
0x6239 => Some(unsafe { transmute(0x76e5u32) }),
0x623a => Some(unsafe { transmute(0x76e7u32) }),
0x623b => Some(unsafe { transmute(0x76eau32) }),
0x623c => Some(unsafe { transmute(0x862fu32) }),
0x623d => Some(unsafe { transmute(0x76fbu32) }),
0x623e => Some(unsafe { transmute(0x7708u32) }),
0x623f => Some(unsafe { transmute(0x7707u32) }),
0x6240 => Some(unsafe { transmute(0x7704u32) }),
0x6241 => Some(unsafe { transmute(0x7729u32) }),
0x6242 => Some(unsafe { transmute(0x7724u32) }),
0x6243 => Some(unsafe { transmute(0x771eu32) }),
0x6244 => Some(unsafe { transmute(0x7725u32) }),
0x6245 => Some(unsafe { transmute(0x7726u32) }),
0x6246 => Some(unsafe { transmute(0x771bu32) }),
0x6247 => Some(unsafe { transmute(0x7737u32) }),
0x6248 => Some(unsafe { transmute(0x7738u32) }),
0x6249 => Some(unsafe { transmute(0x7747u32) }),
0x624a => Some(unsafe { transmute(0x775au32) }),
0x624b => Some(unsafe { transmute(0x7768u32) }),
0x624c => Some(unsafe { transmute(0x776bu32) }),
0x624d => Some(unsafe { transmute(0x775bu32) }),
0x624e => Some(unsafe { transmute(0x7765u32) }),
0x624f => Some(unsafe { transmute(0x777fu32) }),
0x6250 => Some(unsafe { transmute(0x777eu32) }),
0x6251 => Some(unsafe { transmute(0x7779u32) }),
0x6252 => Some(unsafe { transmute(0x778eu32) }),
0x6253 => Some(unsafe { transmute(0x778bu32) }),
0x6254 => Some(unsafe { transmute(0x7791u32) }),
0x6255 => Some(unsafe { transmute(0x77a0u32) }),
0x6256 => Some(unsafe { transmute(0x779eu32) }),
0x6257 => Some(unsafe { transmute(0x77b0u32) }),
0x6258 => Some(unsafe { transmute(0x77b6u32) }),
0x6259 => Some(unsafe { transmute(0x77b9u32) }),
0x625a => Some(unsafe { transmute(0x77bfu32) }),
0x625b => Some(unsafe { transmute(0x77bcu32) }),
0x625c => Some(unsafe { transmute(0x77bdu32) }),
0x625d => Some(unsafe { transmute(0x77bbu32) }),
0x625e => Some(unsafe { transmute(0x77c7u32) }),
0x625f => Some(unsafe { transmute(0x77cdu32) }),
0x6260 => Some(unsafe { transmute(0x77d7u32) }),
0x6261 => Some(unsafe { transmute(0x77dau32) }),
0x6262 => Some(unsafe { transmute(0x77dcu32) }),
0x6263 => Some(unsafe { transmute(0x77e3u32) }),
0x6264 => Some(unsafe { transmute(0x77eeu32) }),
0x6265 => Some(unsafe { transmute(0x77fcu32) }),
0x6266 => Some(unsafe { transmute(0x780cu32) }),
0x6267 => Some(unsafe { transmute(0x7812u32) }),
0x6268 => Some(unsafe { transmute(0x7926u32) }),
0x6269 => Some(unsafe { transmute(0x7820u32) }),
0x626a => Some(unsafe { transmute(0x792au32) }),
0x626b => Some(unsafe { transmute(0x7845u32) }),
0x626c => Some(unsafe { transmute(0x788eu32) }),
0x626d => Some(unsafe { transmute(0x7874u32) }),
0x626e => Some(unsafe { transmute(0x7886u32) }),
0x626f => Some(unsafe { transmute(0x787cu32) }),
0x6270 => Some(unsafe { transmute(0x789au32) }),
0x6271 => Some(unsafe { transmute(0x788cu32) }),
0x6272 => Some(unsafe { transmute(0x78a3u32) }),
0x6273 => Some(unsafe { transmute(0x78b5u32) }),
0x6274 => Some(unsafe { transmute(0x78aau32) }),
0x6275 => Some(unsafe { transmute(0x78afu32) }),
0x6276 => Some(unsafe { transmute(0x78d1u32) }),
0x6277 => Some(unsafe { transmute(0x78c6u32) }),
0x6278 => Some(unsafe { transmute(0x78cbu32) }),
0x6279 => Some(unsafe { transmute(0x78d4u32) }),
0x627a => Some(unsafe { transmute(0x78beu32) }),
0x627b => Some(unsafe { transmute(0x78bcu32) }),
0x627c => Some(unsafe { transmute(0x78c5u32) }),
0x627d => Some(unsafe { transmute(0x78cau32) }),
0x627e => Some(unsafe { transmute(0x78ecu32) }),
0x6321 => Some(unsafe { transmute(0x78e7u32) }),
0x6322 => Some(unsafe { transmute(0x78dau32) }),
0x6323 => Some(unsafe { transmute(0x78fdu32) }),
0x6324 => Some(unsafe { transmute(0x78f4u32) }),
0x6325 => Some(unsafe { transmute(0x7907u32) }),
0x6326 => Some(unsafe { transmute(0x7912u32) }),
0x6327 => Some(unsafe { transmute(0x7911u32) }),
0x6328 => Some(unsafe { transmute(0x7919u32) }),
0x6329 => Some(unsafe { transmute(0x792cu32) }),
0x632a => Some(unsafe { transmute(0x792bu32) }),
0x632b => Some(unsafe { transmute(0x7940u32) }),
0x632c => Some(unsafe { transmute(0x7960u32) }),
0x632d => Some(unsafe { transmute(0x7957u32) }),
0x632e => Some(unsafe { transmute(0x795fu32) }),
0x632f => Some(unsafe { transmute(0x795au32) }),
0x6330 => Some(unsafe { transmute(0x7955u32) }),
0x6331 => Some(unsafe { transmute(0x7953u32) }),
0x6332 => Some(unsafe { transmute(0x797au32) }),
0x6333 => Some(unsafe { transmute(0x797fu32) }),
0x6334 => Some(unsafe { transmute(0x798au32) }),
0x6335 => Some(unsafe { transmute(0x799du32) }),
0x6336 => Some(unsafe { transmute(0x79a7u32) }),
0x6337 => Some(unsafe { transmute(0x9f4bu32) }),
0x6338 => Some(unsafe { transmute(0x79aau32) }),
0x6339 => Some(unsafe { transmute(0x79aeu32) }),
0x633a => Some(unsafe { transmute(0x79b3u32) }),
0x633b => Some(unsafe { transmute(0x79b9u32) }),
0x633c => Some(unsafe { transmute(0x79bau32) }),
0x633d => Some(unsafe { transmute(0x79c9u32) }),
0x633e => Some(unsafe { transmute(0x79d5u32) }),
0x633f => Some(unsafe { transmute(0x79e7u32) }),
0x6340 => Some(unsafe { transmute(0x79ecu32) }),
0x6341 => Some(unsafe { transmute(0x79e1u32) }),
0x6342 => Some(unsafe { transmute(0x79e3u32) }),
0x6343 => Some(unsafe { transmute(0x7a08u32) }),
0x6344 => Some(unsafe { transmute(0x7a0du32) }),
0x6345 => Some(unsafe { transmute(0x7a18u32) }),
0x6346 => Some(unsafe { transmute(0x7a19u32) }),
0x6347 => Some(unsafe { transmute(0x7a20u32) }),
0x6348 => Some(unsafe { transmute(0x7a1fu32) }),
0x6349 => Some(unsafe { transmute(0x7980u32) }),
0x634a => Some(unsafe { transmute(0x7a31u32) }),
0x634b => Some(unsafe { transmute(0x7a3bu32) }),
0x634c => Some(unsafe { transmute(0x7a3eu32) }),
0x634d => Some(unsafe { transmute(0x7a37u32) }),
0x634e => Some(unsafe { transmute(0x7a43u32) }),
0x634f => Some(unsafe { transmute(0x7a57u32) }),
0x6350 => Some(unsafe { transmute(0x7a49u32) }),
0x6351 => Some(unsafe { transmute(0x7a61u32) }),
0x6352 => Some(unsafe { transmute(0x7a62u32) }),
0x6353 => Some(unsafe { transmute(0x7a69u32) }),
0x6354 => Some(unsafe { transmute(0x9f9du32) }),
0x6355 => Some(unsafe { transmute(0x7a70u32) }),
0x6356 => Some(unsafe { transmute(0x7a79u32) }),
0x6357 => Some(unsafe { transmute(0x7a7du32) }),
0x6358 => Some(unsafe { transmute(0x7a88u32) }),
0x6359 => Some(unsafe { transmute(0x7a97u32) }),
0x635a => Some(unsafe { transmute(0x7a95u32) }),
0x635b => Some(unsafe { transmute(0x7a98u32) }),
0x635c => Some(unsafe { transmute(0x7a96u32) }),
0x635d => Some(unsafe { transmute(0x7aa9u32) }),
0x635e => Some(unsafe { transmute(0x7ac8u32) }),
0x635f => Some(unsafe { transmute(0x7ab0u32) }),
0x6360 => Some(unsafe { transmute(0x7ab6u32) }),
0x6361 => Some(unsafe { transmute(0x7ac5u32) }),
0x6362 => Some(unsafe { transmute(0x7ac4u32) }),
0x6363 => Some(unsafe { transmute(0x7abfu32) }),
0x6364 => Some(unsafe { transmute(0x9083u32) }),
0x6365 => Some(unsafe { transmute(0x7ac7u32) }),
0x6366 => Some(unsafe { transmute(0x7acau32) }),
0x6367 => Some(unsafe { transmute(0x7acdu32) }),
0x6368 => Some(unsafe { transmute(0x7acfu32) }),
0x6369 => Some(unsafe { transmute(0x7ad5u32) }),
0x636a => Some(unsafe { transmute(0x7ad3u32) }),
0x636b => Some(unsafe { transmute(0x7ad9u32) }),
0x636c => Some(unsafe { transmute(0x7adau32) }),
0x636d => Some(unsafe { transmute(0x7addu32) }),
0x636e => Some(unsafe { transmute(0x7ae1u32) }),
0x636f => Some(unsafe { transmute(0x7ae2u32) }),
0x6370 => Some(unsafe { transmute(0x7ae6u32) }),
0x6371 => Some(unsafe { transmute(0x7aedu32) }),
0x6372 => Some(unsafe { transmute(0x7af0u32) }),
0x6373 => Some(unsafe { transmute(0x7b02u32) }),
0x6374 => Some(unsafe { transmute(0x7b0fu32) }),
0x6375 => Some(unsafe { transmute(0x7b0au32) }),
0x6376 => Some(unsafe { transmute(0x7b06u32) }),
0x6377 => Some(unsafe { transmute(0x7b33u32) }),
0x6378 => Some(unsafe { transmute(0x7b18u32) }),
0x6379 => Some(unsafe { transmute(0x7b19u32) }),
0x637a => Some(unsafe { transmute(0x7b1eu32) }),
0x637b => Some(unsafe { transmute(0x7b35u32) }),
0x637c => Some(unsafe { transmute(0x7b28u32) }),
0x637d => Some(unsafe { transmute(0x7b36u32) }),
0x637e => Some(unsafe { transmute(0x7b50u32) }),
0x6421 => Some(unsafe { transmute(0x7b7au32) }),
0x6422 => Some(unsafe { transmute(0x7b04u32) }),
0x6423 => Some(unsafe { transmute(0x7b4du32) }),
0x6424 => Some(unsafe { transmute(0x7b0bu32) }),
0x6425 => Some(unsafe { transmute(0x7b4cu32) }),
0x6426 => Some(unsafe { transmute(0x7b45u32) }),
0x6427 => Some(unsafe { transmute(0x7b75u32) }),
0x6428 => Some(unsafe { transmute(0x7b65u32) }),
0x6429 => Some(unsafe { transmute(0x7b74u32) }),
0x642a => Some(unsafe { transmute(0x7b67u32) }),
0x642b => Some(unsafe { transmute(0x7b70u32) }),
0x642c => Some(unsafe { transmute(0x7b71u32) }),
0x642d => Some(unsafe { transmute(0x7b6cu32) }),
0x642e => Some(unsafe { transmute(0x7b6eu32) }),
0x642f => Some(unsafe { transmute(0x7b9du32) }),
0x6430 => Some(unsafe { transmute(0x7b98u32) }),
0x6431 => Some(unsafe { transmute(0x7b9fu32) }),
0x6432 => Some(unsafe { transmute(0x7b8du32) }),
0x6433 => Some(unsafe { transmute(0x7b9cu32) }),
0x6434 => Some(unsafe { transmute(0x7b9au32) }),
0x6435 => Some(unsafe { transmute(0x7b8bu32) }),
0x6436 => Some(unsafe { transmute(0x7b92u32) }),
0x6437 => Some(unsafe { transmute(0x7b8fu32) }),
0x6438 => Some(unsafe { transmute(0x7b5du32) }),
0x6439 => Some(unsafe { transmute(0x7b99u32) }),
0x643a => Some(unsafe { transmute(0x7bcbu32) }),
0x643b => Some(unsafe { transmute(0x7bc1u32) }),
0x643c => Some(unsafe { transmute(0x7bccu32) }),
0x643d => Some(unsafe { transmute(0x7bcfu32) }),
0x643e => Some(unsafe { transmute(0x7bb4u32) }),
0x643f => Some(unsafe { transmute(0x7bc6u32) }),
0x6440 => Some(unsafe { transmute(0x7bddu32) }),
0x6441 => Some(unsafe { transmute(0x7be9u32) }),
0x6442 => Some(unsafe { transmute(0x7c11u32) }),
0x6443 => Some(unsafe { transmute(0x7c14u32) }),
0x6444 => Some(unsafe { transmute(0x7be6u32) }),
0x6445 => Some(unsafe { transmute(0x7be5u32) }),
0x6446 => Some(unsafe { transmute(0x7c60u32) }),
0x6447 => Some(unsafe { transmute(0x7c00u32) }),
0x6448 => Some(unsafe { transmute(0x7c07u32) }),
0x6449 => Some(unsafe { transmute(0x7c13u32) }),
0x644a => Some(unsafe { transmute(0x7bf3u32) }),
0x644b => Some(unsafe { transmute(0x7bf7u32) }),
0x644c => Some(unsafe { transmute(0x7c17u32) }),
0x644d => Some(unsafe { transmute(0x7c0du32) }),
0x644e => Some(unsafe { transmute(0x7bf6u32) }),
0x644f => Some(unsafe { transmute(0x7c23u32) }),
0x6450 => Some(unsafe { transmute(0x7c27u32) }),
0x6451 => Some(unsafe { transmute(0x7c2au32) }),
0x6452 => Some(unsafe { transmute(0x7c1fu32) }),
0x6453 => Some(unsafe { transmute(0x7c37u32) }),
0x6454 => Some(unsafe { transmute(0x7c2bu32) }),
0x6455 => Some(unsafe { transmute(0x7c3du32) }),
0x6456 => Some(unsafe { transmute(0x7c4cu32) }),
0x6457 => Some(unsafe { transmute(0x7c43u32) }),
0x6458 => Some(unsafe { transmute(0x7c54u32) }),
0x6459 => Some(unsafe { transmute(0x7c4fu32) }),
0x645a => Some(unsafe { transmute(0x7c40u32) }),
0x645b => Some(unsafe { transmute(0x7c50u32) }),
0x645c => Some(unsafe { transmute(0x7c58u32) }),
0x645d => Some(unsafe { transmute(0x7c5fu32) }),
0x645e => Some(unsafe { transmute(0x7c64u32) }),
0x645f => Some(unsafe { transmute(0x7c56u32) }),
0x6460 => Some(unsafe { transmute(0x7c65u32) }),
0x6461 => Some(unsafe { transmute(0x7c6cu32) }),
0x6462 => Some(unsafe { transmute(0x7c75u32) }),
0x6463 => Some(unsafe { transmute(0x7c83u32) }),
0x6464 => Some(unsafe { transmute(0x7c90u32) }),
0x6465 => Some(unsafe { transmute(0x7ca4u32) }),
0x6466 => Some(unsafe { transmute(0x7cadu32) }),
0x6467 => Some(unsafe { transmute(0x7ca2u32) }),
0x6468 => Some(unsafe { transmute(0x7cabu32) }),
0x6469 => Some(unsafe { transmute(0x7ca1u32) }),
0x646a => Some(unsafe { transmute(0x7ca8u32) }),
0x646b => Some(unsafe { transmute(0x7cb3u32) }),
0x646c => Some(unsafe { transmute(0x7cb2u32) }),
0x646d => Some(unsafe { transmute(0x7cb1u32) }),
0x646e => Some(unsafe { transmute(0x7caeu32) }),
0x646f => Some(unsafe { transmute(0x7cb9u32) }),
0x6470 => Some(unsafe { transmute(0x7cbdu32) }),
0x6471 => Some(unsafe { transmute(0x7cc0u32) }),
0x6472 => Some(unsafe { transmute(0x7cc5u32) }),
0x6473 => Some(unsafe { transmute(0x7cc2u32) }),
0x6474 => Some(unsafe { transmute(0x7cd8u32) }),
0x6475 => Some(unsafe { transmute(0x7cd2u32) }),
0x6476 => Some(unsafe { transmute(0x7cdcu32) }),
0x6477 => Some(unsafe { transmute(0x7ce2u32) }),
0x6478 => Some(unsafe { transmute(0x9b3bu32) }),
0x6479 => Some(unsafe { transmute(0x7cefu32) }),
0x647a => Some(unsafe { transmute(0x7cf2u32) }),
0x647b => Some(unsafe { transmute(0x7cf4u32) }),
0x647c => Some(unsafe { transmute(0x7cf6u32) }),
0x647d => Some(unsafe { transmute(0x7cfau32) }),
0x647e => Some(unsafe { transmute(0x7d06u32) }),
0x6521 => Some(unsafe { transmute(0x7d02u32) }),
0x6522 => Some(unsafe { transmute(0x7d1cu32) }),
0x6523 => Some(unsafe { transmute(0x7d15u32) }),
0x6524 => Some(unsafe { transmute(0x7d0au32) }),
0x6525 => Some(unsafe { transmute(0x7d45u32) }),
0x6526 => Some(unsafe { transmute(0x7d4bu32) }),
0x6527 => Some(unsafe { transmute(0x7d2eu32) }),
0x6528 => Some(unsafe { transmute(0x7d32u32) }),
0x6529 => Some(unsafe { transmute(0x7d3fu32) }),
0x652a => Some(unsafe { transmute(0x7d35u32) }),
0x652b => Some(unsafe { transmute(0x7d46u32) }),
0x652c => Some(unsafe { transmute(0x7d73u32) }),
0x652d => Some(unsafe { transmute(0x7d56u32) }),
0x652e => Some(unsafe { transmute(0x7d4eu32) }),
0x652f => Some(unsafe { transmute(0x7d72u32) }),
0x6530 => Some(unsafe { transmute(0x7d68u32) }),
0x6531 => Some(unsafe { transmute(0x7d6eu32) }),
0x6532 => Some(unsafe { transmute(0x7d4fu32) }),
0x6533 => Some(unsafe { transmute(0x7d63u32) }),
0x6534 => Some(unsafe { transmute(0x7d93u32) }),
0x6535 => Some(unsafe { transmute(0x7d89u32) }),
0x6536 => Some(unsafe { transmute(0x7d5bu32) }),
0x6537 => Some(unsafe { transmute(0x7d8fu32) }),
0x6538 => Some(unsafe { transmute(0x7d7du32) }),
0x6539 => Some(unsafe { transmute(0x7d9bu32) }),
0x653a => Some(unsafe { transmute(0x7dbau32) }),
0x653b => Some(unsafe { transmute(0x7daeu32) }),
0x653c => Some(unsafe { transmute(0x7da3u32) }),
0x653d => Some(unsafe { transmute(0x7db5u32) }),
0x653e => Some(unsafe { transmute(0x7dc7u32) }),
0x653f => Some(unsafe { transmute(0x7dbdu32) }),
0x6540 => Some(unsafe { transmute(0x7dabu32) }),
0x6541 => Some(unsafe { transmute(0x7e3du32) }),
0x6542 => Some(unsafe { transmute(0x7da2u32) }),
0x6543 => Some(unsafe { transmute(0x7dafu32) }),
0x6544 => Some(unsafe { transmute(0x7ddcu32) }),
0x6545 => Some(unsafe { transmute(0x7db8u32) }),
0x6546 => Some(unsafe { transmute(0x7d9fu32) }),
0x6547 => Some(unsafe { transmute(0x7db0u32) }),
0x6548 => Some(unsafe { transmute(0x7dd8u32) }),
0x6549 => Some(unsafe { transmute(0x7dddu32) }),
0x654a => Some(unsafe { transmute(0x7de4u32) }),
0x654b => Some(unsafe { transmute(0x7ddeu32) }),
0x654c => Some(unsafe { transmute(0x7dfbu32) }),
0x654d => Some(unsafe { transmute(0x7df2u32) }),
0x654e => Some(unsafe { transmute(0x7de1u32) }),
0x654f => Some(unsafe { transmute(0x7e05u32) }),
0x6550 => Some(unsafe { transmute(0x7e0au32) }),
0x6551 => Some(unsafe { transmute(0x7e23u32) }),
0x6552 => Some(unsafe { transmute(0x7e21u32) }),
0x6553 => Some(unsafe { transmute(0x7e12u32) }),
0x6554 => Some(unsafe { transmute(0x7e31u32) }),
0x6555 => Some(unsafe { transmute(0x7e1fu32) }),
0x6556 => Some(unsafe { transmute(0x7e09u32) }),
0x6557 => Some(unsafe { transmute(0x7e0bu32) }),
0x6558 => Some(unsafe { transmute(0x7e22u32) }),
0x6559 => Some(unsafe { transmute(0x7e46u32) }),
0x655a => Some(unsafe { transmute(0x7e66u32) }),
0x655b => Some(unsafe { transmute(0x7e3bu32) }),
0x655c => Some(unsafe { transmute(0x7e35u32) }),
0x655d => Some(unsafe { transmute(0x7e39u32) }),
0x655e => Some(unsafe { transmute(0x7e43u32) }),
0x655f => Some(unsafe { transmute(0x7e37u32) }),
0x6560 => Some(unsafe { transmute(0x7e32u32) }),
0x6561 => Some(unsafe { transmute(0x7e3au32) }),
0x6562 => Some(unsafe { transmute(0x7e67u32) }),
0x6563 => Some(unsafe { transmute(0x7e5du32) }),
0x6564 => Some(unsafe { transmute(0x7e56u32) }),
0x6565 => Some(unsafe { transmute(0x7e5eu32) }),
0x6566 => Some(unsafe { transmute(0x7e59u32) }),
0x6567 => Some(unsafe { transmute(0x7e5au32) }),
0x6568 => Some(unsafe { transmute(0x7e79u32) }),
0x6569 => Some(unsafe { transmute(0x7e6au32) }),
0x656a => Some(unsafe { transmute(0x7e69u32) }),
0x656b => Some(unsafe { transmute(0x7e7cu32) }),
0x656c => Some(unsafe { transmute(0x7e7bu32) }),
0x656d => Some(unsafe { transmute(0x7e83u32) }),
0x656e => Some(unsafe { transmute(0x7dd5u32) }),
0x656f => Some(unsafe { transmute(0x7e7du32) }),
0x6570 => Some(unsafe { transmute(0x8faeu32) }),
0x6571 => Some(unsafe { transmute(0x7e7fu32) }),
0x6572 => Some(unsafe { transmute(0x7e88u32) }),
0x6573 => Some(unsafe { transmute(0x7e89u32) }),
0x6574 => Some(unsafe { transmute(0x7e8cu32) }),
0x6575 => Some(unsafe { transmute(0x7e92u32) }),
0x6576 => Some(unsafe { transmute(0x7e90u32) }),
0x6577 => Some(unsafe { transmute(0x7e93u32) }),
0x6578 => Some(unsafe { transmute(0x7e94u32) }),
0x6579 => Some(unsafe { transmute(0x7e96u32) }),
0x657a => Some(unsafe { transmute(0x7e8eu32) }),
0x657b => Some(unsafe { transmute(0x7e9bu32) }),
0x657c => Some(unsafe { transmute(0x7e9cu32) }),
0x657d => Some(unsafe { transmute(0x7f38u32) }),
0x657e => Some(unsafe { transmute(0x7f3au32) }),
0x6621 => Some(unsafe { transmute(0x7f45u32) }),
0x6622 => Some(unsafe { transmute(0x7f4cu32) }),
0x6623 => Some(unsafe { transmute(0x7f4du32) }),
0x6624 => Some(unsafe { transmute(0x7f4eu32) }),
0x6625 => Some(unsafe { transmute(0x7f50u32) }),
0x6626 => Some(unsafe { transmute(0x7f51u32) }),
0x6627 => Some(unsafe { transmute(0x7f55u32) }),
0x6628 => Some(unsafe { transmute(0x7f54u32) }),
0x6629 => Some(unsafe { transmute(0x7f58u32) }),
0x662a => Some(unsafe { transmute(0x7f5fu32) }),
0x662b => Some(unsafe { transmute(0x7f60u32) }),
0x662c => Some(unsafe { transmute(0x7f68u32) }),
0x662d => Some(unsafe { transmute(0x7f69u32) }),
0x662e => Some(unsafe { transmute(0x7f67u32) }),
0x662f => Some(unsafe { transmute(0x7f78u32) }),
0x6630 => Some(unsafe { transmute(0x7f82u32) }),
0x6631 => Some(unsafe { transmute(0x7f86u32) }),
0x6632 => Some(unsafe { transmute(0x7f83u32) }),
0x6633 => Some(unsafe { transmute(0x7f88u32) }),
0x6634 => Some(unsafe { transmute(0x7f87u32) }),
0x6635 => Some(unsafe { transmute(0x7f8cu32) }),
0x6636 => Some(unsafe { transmute(0x7f94u32) }),
0x6637 => Some(unsafe { transmute(0x7f9eu32) }),
0x6638 => Some(unsafe { transmute(0x7f9du32) }),
0x6639 => Some(unsafe { transmute(0x7f9au32) }),
0x663a => Some(unsafe { transmute(0x7fa3u32) }),
0x663b => Some(unsafe { transmute(0x7fafu32) }),
0x663c => Some(unsafe { transmute(0x7fb2u32) }),
0x663d => Some(unsafe { transmute(0x7fb9u32) }),
0x663e => Some(unsafe { transmute(0x7faeu32) }),
0x663f => Some(unsafe { transmute(0x7fb6u32) }),
0x6640 => Some(unsafe { transmute(0x7fb8u32) }),
0x6641 => Some(unsafe { transmute(0x8b71u32) }),
0x6642 => Some(unsafe { transmute(0x7fc5u32) }),
0x6643 => Some(unsafe { transmute(0x7fc6u32) }),
0x6644 => Some(unsafe { transmute(0x7fcau32) }),
0x6645 => Some(unsafe { transmute(0x7fd5u32) }),
0x6646 => Some(unsafe { transmute(0x7fd4u32) }),
0x6647 => Some(unsafe { transmute(0x7fe1u32) }),
0x6648 => Some(unsafe { transmute(0x7fe6u32) }),
0x6649 => Some(unsafe { transmute(0x7fe9u32) }),
0x664a => Some(unsafe { transmute(0x7ff3u32) }),
0x664b => Some(unsafe { transmute(0x7ff9u32) }),
0x664c => Some(unsafe { transmute(0x98dcu32) }),
0x664d => Some(unsafe { transmute(0x8006u32) }),
0x664e => Some(unsafe { transmute(0x8004u32) }),
0x664f => Some(unsafe { transmute(0x800bu32) }),
0x6650 => Some(unsafe { transmute(0x8012u32) }),
0x6651 => Some(unsafe { transmute(0x8018u32) }),
0x6652 => Some(unsafe { transmute(0x8019u32) }),
0x6653 => Some(unsafe { transmute(0x801cu32) }),
0x6654 => Some(unsafe { transmute(0x8021u32) }),
0x6655 => Some(unsafe { transmute(0x8028u32) }),
0x6656 => Some(unsafe { transmute(0x803fu32) }),
0x6657 => Some(unsafe { transmute(0x803bu32) }),
0x6658 => Some(unsafe { transmute(0x804au32) }),
0x6659 => Some(unsafe { transmute(0x8046u32) }),
0x665a => Some(unsafe { transmute(0x8052u32) }),
0x665b => Some(unsafe { transmute(0x8058u32) }),
0x665c => Some(unsafe { transmute(0x805au32) }),
0x665d => Some(unsafe { transmute(0x805fu32) }),
0x665e => Some(unsafe { transmute(0x8062u32) }),
0x665f => Some(unsafe { transmute(0x8068u32) }),
0x6660 => Some(unsafe { transmute(0x8073u32) }),
0x6661 => Some(unsafe { transmute(0x8072u32) }),
0x6662 => Some(unsafe { transmute(0x8070u32) }),
0x6663 => Some(unsafe { transmute(0x8076u32) }),
0x6664 => Some(unsafe { transmute(0x8079u32) }),
0x6665 => Some(unsafe { transmute(0x807du32) }),
0x6666 => Some(unsafe { transmute(0x807fu32) }),
0x6667 => Some(unsafe { transmute(0x8084u32) }),
0x6668 => Some(unsafe { transmute(0x8086u32) }),
0x6669 => Some(unsafe { transmute(0x8085u32) }),
0x666a => Some(unsafe { transmute(0x809bu32) }),
0x666b => Some(unsafe { transmute(0x8093u32) }),
0x666c => Some(unsafe { transmute(0x809au32) }),
0x666d => Some(unsafe { transmute(0x80adu32) }),
0x666e => Some(unsafe { transmute(0x5190u32) }),
0x666f => Some(unsafe { transmute(0x80acu32) }),
0x6670 => Some(unsafe { transmute(0x80dbu32) }),
0x6671 => Some(unsafe { transmute(0x80e5u32) }),
0x6672 => Some(unsafe { transmute(0x80d9u32) }),
0x6673 => Some(unsafe { transmute(0x80ddu32) }),
0x6674 => Some(unsafe { transmute(0x80c4u32) }),
0x6675 => Some(unsafe { transmute(0x80dau32) }),
0x6676 => Some(unsafe { transmute(0x80d6u32) }),
0x6677 => Some(unsafe { transmute(0x8109u32) }),
0x6678 => Some(unsafe { transmute(0x80efu32) }),
0x6679 => Some(unsafe { transmute(0x80f1u32) }),
0x667a => Some(unsafe { transmute(0x811bu32) }),
0x667b => Some(unsafe { transmute(0x8129u32) }),
0x667c => Some(unsafe { transmute(0x8123u32) }),
0x667d => Some(unsafe { transmute(0x812fu32) }),
0x667e => Some(unsafe { transmute(0x814bu32) }),
0x6721 => Some(unsafe { transmute(0x968bu32) }),
0x6722 => Some(unsafe { transmute(0x8146u32) }),
0x6723 => Some(unsafe { transmute(0x813eu32) }),
0x6724 => Some(unsafe { transmute(0x8153u32) }),
0x6725 => Some(unsafe { transmute(0x8151u32) }),
0x6726 => Some(unsafe { transmute(0x80fcu32) }),
0x6727 => Some(unsafe { transmute(0x8171u32) }),
0x6728 => Some(unsafe { transmute(0x816eu32) }),
0x6729 => Some(unsafe { transmute(0x8165u32) }),
0x672a => Some(unsafe { transmute(0x8166u32) }),
0x672b => Some(unsafe { transmute(0x8174u32) }),
0x672c => Some(unsafe { transmute(0x8183u32) }),
0x672d => Some(unsafe { transmute(0x8188u32) }),
0x672e => Some(unsafe { transmute(0x818au32) }),
0x672f => Some(unsafe { transmute(0x8180u32) }),
0x6730 => Some(unsafe { transmute(0x8182u32) }),
0x6731 => Some(unsafe { transmute(0x81a0u32) }),
0x6732 => Some(unsafe { transmute(0x8195u32) }),
0x6733 => Some(unsafe { transmute(0x81a4u32) }),
0x6734 => Some(unsafe { transmute(0x81a3u32) }),
0x6735 => Some(unsafe { transmute(0x815fu32) }),
0x6736 => Some(unsafe { transmute(0x8193u32) }),
0x6737 => Some(unsafe { transmute(0x81a9u32) }),
0x6738 => Some(unsafe { transmute(0x81b0u32) }),
0x6739 => Some(unsafe { transmute(0x81b5u32) }),
0x673a => Some(unsafe { transmute(0x81beu32) }),
0x673b => Some(unsafe { transmute(0x81b8u32) }),
0x673c => Some(unsafe { transmute(0x81bdu32) }),
0x673d => Some(unsafe { transmute(0x81c0u32) }),
0x673e => Some(unsafe { transmute(0x81c2u32) }),
0x673f => Some(unsafe { transmute(0x81bau32) }),
0x6740 => Some(unsafe { transmute(0x81c9u32) }),
0x6741 => Some(unsafe { transmute(0x81cdu32) }),
0x6742 => Some(unsafe { transmute(0x81d1u32) }),
0x6743 => Some(unsafe { transmute(0x81d9u32) }),
0x6744 => Some(unsafe { transmute(0x81d8u32) }),
0x6745 => Some(unsafe { transmute(0x81c8u32) }),
0x6746 => Some(unsafe { transmute(0x81dau32) }),
0x6747 => Some(unsafe { transmute(0x81dfu32) }),
0x6748 => Some(unsafe { transmute(0x81e0u32) }),
0x6749 => Some(unsafe { transmute(0x81e7u32) }),
0x674a => Some(unsafe { transmute(0x81fau32) }),
0x674b => Some(unsafe { transmute(0x81fbu32) }),
0x674c => Some(unsafe { transmute(0x81feu32) }),
0x674d => Some(unsafe { transmute(0x8201u32) }),
0x674e => Some(unsafe { transmute(0x8202u32) }),
0x674f => Some(unsafe { transmute(0x8205u32) }),
0x6750 => Some(unsafe { transmute(0x8207u32) }),
0x6751 => Some(unsafe { transmute(0x820au32) }),
0x6752 => Some(unsafe { transmute(0x820du32) }),
0x6753 => Some(unsafe { transmute(0x8210u32) }),
0x6754 => Some(unsafe { transmute(0x8216u32) }),
0x6755 => Some(unsafe { transmute(0x8229u32) }),
0x6756 => Some(unsafe { transmute(0x822bu32) }),
0x6757 => Some(unsafe { transmute(0x8238u32) }),
0x6758 => Some(unsafe { transmute(0x8233u32) }),
0x6759 => Some(unsafe { transmute(0x8240u32) }),
0x675a => Some(unsafe { transmute(0x8259u32) }),
0x675b => Some(unsafe { transmute(0x8258u32) }),
0x675c => Some(unsafe { transmute(0x825du32) }),
0x675d => Some(unsafe { transmute(0x825au32) }),
0x675e => Some(unsafe { transmute(0x825fu32) }),
0x675f => Some(unsafe { transmute(0x8264u32) }),
0x6760 => Some(unsafe { transmute(0x8262u32) }),
0x6761 => Some(unsafe { transmute(0x8268u32) }),
0x6762 => Some(unsafe { transmute(0x826au32) }),
0x6763 => Some(unsafe { transmute(0x826bu32) }),
0x6764 => Some(unsafe { transmute(0x822eu32) }),
0x6765 => Some(unsafe { transmute(0x8271u32) }),
0x6766 => Some(unsafe { transmute(0x8277u32) }),
0x6767 => Some(unsafe { transmute(0x8278u32) }),
0x6768 => Some(unsafe { transmute(0x827eu32) }),
0x6769 => Some(unsafe { transmute(0x828du32) }),
0x676a => Some(unsafe { transmute(0x8292u32) }),
0x676b => Some(unsafe { transmute(0x82abu32) }),
0x676c => Some(unsafe { transmute(0x829fu32) }),
0x676d => Some(unsafe { transmute(0x82bbu32) }),
0x676e => Some(unsafe { transmute(0x82acu32) }),
0x676f => Some(unsafe { transmute(0x82e1u32) }),
0x6770 => Some(unsafe { transmute(0x82e3u32) }),
0x6771 => Some(unsafe { transmute(0x82dfu32) }),
0x6772 => Some(unsafe { transmute(0x82d2u32) }),
0x6773 => Some(unsafe { transmute(0x82f4u32) }),
0x6774 => Some(unsafe { transmute(0x82f3u32) }),
0x6775 => Some(unsafe { transmute(0x82fau32) }),
0x6776 => Some(unsafe { transmute(0x8393u32) }),
0x6777 => Some(unsafe { transmute(0x8303u32) }),
0x6778 => Some(unsafe { transmute(0x82fbu32) }),
0x6779 => Some(unsafe { transmute(0x82f9u32) }),
0x677a => Some(unsafe { transmute(0x82deu32) }),
0x677b => Some(unsafe { transmute(0x8306u32) }),
0x677c => Some(unsafe { transmute(0x82dcu32) }),
0x677d => Some(unsafe { transmute(0x8309u32) }),
0x677e => Some(unsafe { transmute(0x82d9u32) }),
0x6821 => Some(unsafe { transmute(0x8335u32) }),
0x6822 => Some(unsafe { transmute(0x8334u32) }),
0x6823 => Some(unsafe { transmute(0x8316u32) }),
0x6824 => Some(unsafe { transmute(0x8332u32) }),
0x6825 => Some(unsafe { transmute(0x8331u32) }),
0x6826 => Some(unsafe { transmute(0x8340u32) }),
0x6827 => Some(unsafe { transmute(0x8339u32) }),
0x6828 => Some(unsafe { transmute(0x8350u32) }),
0x6829 => Some(unsafe { transmute(0x8345u32) }),
0x682a => Some(unsafe { transmute(0x832fu32) }),
0x682b => Some(unsafe { transmute(0x832bu32) }),
0x682c => Some(unsafe { transmute(0x8317u32) }),
0x682d => Some(unsafe { transmute(0x8318u32) }),
0x682e => Some(unsafe { transmute(0x8385u32) }),
0x682f => Some(unsafe { transmute(0x839au32) }),
0x6830 => Some(unsafe { transmute(0x83aau32) }),
0x6831 => Some(unsafe { transmute(0x839fu32) }),
0x6832 => Some(unsafe { transmute(0x83a2u32) }),
0x6833 => Some(unsafe { transmute(0x8396u32) }),
0x6834 => Some(unsafe { transmute(0x8323u32) }),
0x6835 => Some(unsafe { transmute(0x838eu32) }),
0x6836 => Some(unsafe { transmute(0x8387u32) }),
0x6837 => Some(unsafe { transmute(0x838au32) }),
0x6838 => Some(unsafe { transmute(0x837cu32) }),
0x6839 => Some(unsafe { transmute(0x83b5u32) }),
0x683a => Some(unsafe { transmute(0x8373u32) }),
0x683b => Some(unsafe { transmute(0x8375u32) }),
0x683c => Some(unsafe { transmute(0x83a0u32) }),
0x683d => Some(unsafe { transmute(0x8389u32) }),
0x683e => Some(unsafe { transmute(0x83a8u32) }),
0x683f => Some(unsafe { transmute(0x83f4u32) }),
0x6840 => Some(unsafe { transmute(0x8413u32) }),
0x6841 => Some(unsafe { transmute(0x83ebu32) }),
0x6842 => Some(unsafe { transmute(0x83ceu32) }),
0x6843 => Some(unsafe { transmute(0x83fdu32) }),
0x6844 => Some(unsafe { transmute(0x8403u32) }),
0x6845 => Some(unsafe { transmute(0x83d8u32) }),
0x6846 => Some(unsafe { transmute(0x840bu32) }),
0x6847 => Some(unsafe { transmute(0x83c1u32) }),
0x6848 => Some(unsafe { transmute(0x83f7u32) }),
0x6849 => Some(unsafe { transmute(0x8407u32) }),
0x684a => Some(unsafe { transmute(0x83e0u32) }),
0x684b => Some(unsafe { transmute(0x83f2u32) }),
0x684c => Some(unsafe { transmute(0x840du32) }),
0x684d => Some(unsafe { transmute(0x8422u32) }),
0x684e => Some(unsafe { transmute(0x8420u32) }),
0x684f => Some(unsafe { transmute(0x83bdu32) }),
0x6850 => Some(unsafe { transmute(0x8438u32) }),
0x6851 => Some(unsafe { transmute(0x8506u32) }),
0x6852 => Some(unsafe { transmute(0x83fbu32) }),
0x6853 => Some(unsafe { transmute(0x846du32) }),
0x6854 => Some(unsafe { transmute(0x842au32) }),
0x6855 => Some(unsafe { transmute(0x843cu32) }),
0x6856 => Some(unsafe { transmute(0x855au32) }),
0x6857 => Some(unsafe { transmute(0x8484u32) }),
0x6858 => Some(unsafe { transmute(0x8477u32) }),
0x6859 => Some(unsafe { transmute(0x846bu32) }),
0x685a => Some(unsafe { transmute(0x84adu32) }),
0x685b => Some(unsafe { transmute(0x846eu32) }),
0x685c => Some(unsafe { transmute(0x8482u32) }),
0x685d => Some(unsafe { transmute(0x8469u32) }),
0x685e => Some(unsafe { transmute(0x8446u32) }),
0x685f => Some(unsafe { transmute(0x842cu32) }),
0x6860 => Some(unsafe { transmute(0x846fu32) }),
0x6861 => Some(unsafe { transmute(0x8479u32) }),
0x6862 => Some(unsafe { transmute(0x8435u32) }),
0x6863 => Some(unsafe { transmute(0x84cau32) }),
0x6864 => Some(unsafe { transmute(0x8462u32) }),
0x6865 => Some(unsafe { transmute(0x84b9u32) }),
0x6866 => Some(unsafe { transmute(0x84bfu32) }),
0x6867 => Some(unsafe { transmute(0x849fu32) }),
0x6868 => Some(unsafe { transmute(0x84d9u32) }),
0x6869 => Some(unsafe { transmute(0x84cdu32) }),
0x686a => Some(unsafe { transmute(0x84bbu32) }),
0x686b => Some(unsafe { transmute(0x84dau32) }),
0x686c => Some(unsafe { transmute(0x84d0u32) }),
0x686d => Some(unsafe { transmute(0x84c1u32) }),
0x686e => Some(unsafe { transmute(0x84c6u32) }),
0x686f => Some(unsafe { transmute(0x84d6u32) }),
0x6870 => Some(unsafe { transmute(0x84a1u32) }),
0x6871 => Some(unsafe { transmute(0x8521u32) }),
0x6872 => Some(unsafe { transmute(0x84ffu32) }),
0x6873 => Some(unsafe { transmute(0x84f4u32) }),
0x6874 => Some(unsafe { transmute(0x8517u32) }),
0x6875 => Some(unsafe { transmute(0x8518u32) }),
0x6876 => Some(unsafe { transmute(0x852cu32) }),
0x6877 => Some(unsafe { transmute(0x851fu32) }),
0x6878 => Some(unsafe { transmute(0x8515u32) }),
0x6879 => Some(unsafe { transmute(0x8514u32) }),
0x687a => Some(unsafe { transmute(0x84fcu32) }),
0x687b => Some(unsafe { transmute(0x8540u32) }),
0x687c => Some(unsafe { transmute(0x8563u32) }),
0x687d => Some(unsafe { transmute(0x8558u32) }),
0x687e => Some(unsafe { transmute(0x8548u32) }),
0x6921 => Some(unsafe { transmute(0x8541u32) }),
0x6922 => Some(unsafe { transmute(0x8602u32) }),
0x6923 => Some(unsafe { transmute(0x854bu32) }),
0x6924 => Some(unsafe { transmute(0x8555u32) }),
0x6925 => Some(unsafe { transmute(0x8580u32) }),
0x6926 => Some(unsafe { transmute(0x85a4u32) }),
0x6927 => Some(unsafe { transmute(0x8588u32) }),
0x6928 => Some(unsafe { transmute(0x8591u32) }),
0x6929 => Some(unsafe { transmute(0x858au32) }),
0x692a => Some(unsafe { transmute(0x85a8u32) }),
0x692b => Some(unsafe { transmute(0x856du32) }),
0x692c => Some(unsafe { transmute(0x8594u32) }),
0x692d => Some(unsafe { transmute(0x859bu32) }),
0x692e => Some(unsafe { transmute(0x85eau32) }),
0x692f => Some(unsafe { transmute(0x8587u32) }),
0x6930 => Some(unsafe { transmute(0x859cu32) }),
0x6931 => Some(unsafe { transmute(0x8577u32) }),
0x6932 => Some(unsafe { transmute(0x857eu32) }),
0x6933 => Some(unsafe { transmute(0x8590u32) }),
0x6934 => Some(unsafe { transmute(0x85c9u32) }),
0x6935 => Some(unsafe { transmute(0x85bau32) }),
0x6936 => Some(unsafe { transmute(0x85cfu32) }),
0x6937 => Some(unsafe { transmute(0x85b9u32) }),
0x6938 => Some(unsafe { transmute(0x85d0u32) }),
0x6939 => Some(unsafe { transmute(0x85d5u32) }),
0x693a => Some(unsafe { transmute(0x85ddu32) }),
0x693b => Some(unsafe { transmute(0x85e5u32) }),
0x693c => Some(unsafe { transmute(0x85dcu32) }),
0x693d => Some(unsafe { transmute(0x85f9u32) }),
0x693e => Some(unsafe { transmute(0x860au32) }),
0x693f => Some(unsafe { transmute(0x8613u32) }),
0x6940 => Some(unsafe { transmute(0x860bu32) }),
0x6941 => Some(unsafe { transmute(0x85feu32) }),
0x6942 => Some(unsafe { transmute(0x85fau32) }),
0x6943 => Some(unsafe { transmute(0x8606u32) }),
0x6944 => Some(unsafe { transmute(0x8622u32) }),
0x6945 => Some(unsafe { transmute(0x861au32) }),
0x6946 => Some(unsafe { transmute(0x8630u32) }),
0x6947 => Some(unsafe { transmute(0x863fu32) }),
0x6948 => Some(unsafe { transmute(0x864du32) }),
0x6949 => Some(unsafe { transmute(0x4e55u32) }),
0x694a => Some(unsafe { transmute(0x8654u32) }),
0x694b => Some(unsafe { transmute(0x865fu32) }),
0x694c => Some(unsafe { transmute(0x8667u32) }),
0x694d => Some(unsafe { transmute(0x8671u32) }),
0x694e => Some(unsafe { transmute(0x8693u32) }),
0x694f => Some(unsafe { transmute(0x86a3u32) }),
0x6950 => Some(unsafe { transmute(0x86a9u32) }),
0x6951 => Some(unsafe { transmute(0x86aau32) }),
0x6952 => Some(unsafe { transmute(0x868bu32) }),
0x6953 => Some(unsafe { transmute(0x868cu32) }),
0x6954 => Some(unsafe { transmute(0x86b6u32) }),
0x6955 => Some(unsafe { transmute(0x86afu32) }),
0x6956 => Some(unsafe { transmute(0x86c4u32) }),
0x6957 => Some(unsafe { transmute(0x86c6u32) }),
0x6958 => Some(unsafe { transmute(0x86b0u32) }),
0x6959 => Some(unsafe { transmute(0x86c9u32) }),
0x695a => Some(unsafe { transmute(0x8823u32) }),
0x695b => Some(unsafe { transmute(0x86abu32) }),
0x695c => Some(unsafe { transmute(0x86d4u32) }),
0x695d => Some(unsafe { transmute(0x86deu32) }),
0x695e => Some(unsafe { transmute(0x86e9u32) }),
0x695f => Some(unsafe { transmute(0x86ecu32) }),
0x6960 => Some(unsafe { transmute(0x86dfu32) }),
0x6961 => Some(unsafe { transmute(0x86dbu32) }),
0x6962 => Some(unsafe { transmute(0x86efu32) }),
0x6963 => Some(unsafe { transmute(0x8712u32) }),
0x6964 => Some(unsafe { transmute(0x8706u32) }),
0x6965 => Some(unsafe { transmute(0x8708u32) }),
0x6966 => Some(unsafe { transmute(0x8700u32) }),
0x6967 => Some(unsafe { transmute(0x8703u32) }),
0x6968 => Some(unsafe { transmute(0x86fbu32) }),
0x6969 => Some(unsafe { transmute(0x8711u32) }),
0x696a => Some(unsafe { transmute(0x8709u32) }),
0x696b => Some(unsafe { transmute(0x870du32) }),
0x696c => Some(unsafe { transmute(0x86f9u32) }),
0x696d => Some(unsafe { transmute(0x870au32) }),
0x696e => Some(unsafe { transmute(0x8734u32) }),
0x696f => Some(unsafe { transmute(0x873fu32) }),
0x6970 => Some(unsafe { transmute(0x8737u32) }),
0x6971 => Some(unsafe { transmute(0x873bu32) }),
0x6972 => Some(unsafe { transmute(0x8725u32) }),
0x6973 => Some(unsafe { transmute(0x8729u32) }),
0x6974 => Some(unsafe { transmute(0x871au32) }),
0x6975 => Some(unsafe { transmute(0x8760u32) }),
0x6976 => Some(unsafe { transmute(0x875fu32) }),
0x6977 => Some(unsafe { transmute(0x8778u32) }),
0x6978 => Some(unsafe { transmute(0x874cu32) }),
0x6979 => Some(unsafe { transmute(0x874eu32) }),
0x697a => Some(unsafe { transmute(0x8774u32) }),
0x697b => Some(unsafe { transmute(0x8757u32) }),
0x697c => Some(unsafe { transmute(0x8768u32) }),
0x697d => Some(unsafe { transmute(0x876eu32) }),
0x697e => Some(unsafe { transmute(0x8759u32) }),
0x6a21 => Some(unsafe { transmute(0x8753u32) }),
0x6a22 => Some(unsafe { transmute(0x8763u32) }),
0x6a23 => Some(unsafe { transmute(0x876au32) }),
0x6a24 => Some(unsafe { transmute(0x8805u32) }),
0x6a25 => Some(unsafe { transmute(0x87a2u32) }),
0x6a26 => Some(unsafe { transmute(0x879fu32) }),
0x6a27 => Some(unsafe { transmute(0x8782u32) }),
0x6a28 => Some(unsafe { transmute(0x87afu32) }),
0x6a29 => Some(unsafe { transmute(0x87cbu32) }),
0x6a2a => Some(unsafe { transmute(0x87bdu32) }),
0x6a2b => Some(unsafe { transmute(0x87c0u32) }),
0x6a2c => Some(unsafe { transmute(0x87d0u32) }),
0x6a2d => Some(unsafe { transmute(0x96d6u32) }),
0x6a2e => Some(unsafe { transmute(0x87abu32) }),
0x6a2f => Some(unsafe { transmute(0x87c4u32) }),
0x6a30 => Some(unsafe { transmute(0x87b3u32) }),
0x6a31 => Some(unsafe { transmute(0x87c7u32) }),
0x6a32 => Some(unsafe { transmute(0x87c6u32) }),
0x6a33 => Some(unsafe { transmute(0x87bbu32) }),
0x6a34 => Some(unsafe { transmute(0x87efu32) }),
0x6a35 => Some(unsafe { transmute(0x87f2u32) }),
0x6a36 => Some(unsafe { transmute(0x87e0u32) }),
0x6a37 => Some(unsafe { transmute(0x880fu32) }),
0x6a38 => Some(unsafe { transmute(0x880du32) }),
0x6a39 => Some(unsafe { transmute(0x87feu32) }),
0x6a3a => Some(unsafe { transmute(0x87f6u32) }),
0x6a3b => Some(unsafe { transmute(0x87f7u32) }),
0x6a3c => Some(unsafe { transmute(0x880eu32) }),
0x6a3d => Some(unsafe { transmute(0x87d2u32) }),
0x6a3e => Some(unsafe { transmute(0x8811u32) }),
0x6a3f => Some(unsafe { transmute(0x8816u32) }),
0x6a40 => Some(unsafe { transmute(0x8815u32) }),
0x6a41 => Some(unsafe { transmute(0x8822u32) }),
0x6a42 => Some(unsafe { transmute(0x8821u32) }),
0x6a43 => Some(unsafe { transmute(0x8831u32) }),
0x6a44 => Some(unsafe { transmute(0x8836u32) }),
0x6a45 => Some(unsafe { transmute(0x8839u32) }),
0x6a46 => Some(unsafe { transmute(0x8827u32) }),
0x6a47 => Some(unsafe { transmute(0x883bu32) }),
0x6a48 => Some(unsafe { transmute(0x8844u32) }),
0x6a49 => Some(unsafe { transmute(0x8842u32) }),
0x6a4a => Some(unsafe { transmute(0x8852u32) }),
0x6a4b => Some(unsafe { transmute(0x8859u32) }),
0x6a4c => Some(unsafe { transmute(0x885eu32) }),
0x6a4d => Some(unsafe { transmute(0x8862u32) }),
0x6a4e => Some(unsafe { transmute(0x886bu32) }),
0x6a4f => Some(unsafe { transmute(0x8881u32) }),
0x6a50 => Some(unsafe { transmute(0x887eu32) }),
0x6a51 => Some(unsafe { transmute(0x889eu32) }),
0x6a52 => Some(unsafe { transmute(0x8875u32) }),
0x6a53 => Some(unsafe { transmute(0x887du32) }),
0x6a54 => Some(unsafe { transmute(0x88b5u32) }),
0x6a55 => Some(unsafe { transmute(0x8872u32) }),
0x6a56 => Some(unsafe { transmute(0x8882u32) }),
0x6a57 => Some(unsafe { transmute(0x8897u32) }),
0x6a58 => Some(unsafe { transmute(0x8892u32) }),
0x6a59 => Some(unsafe { transmute(0x88aeu32) }),
0x6a5a => Some(unsafe { transmute(0x8899u32) }),
0x6a5b => Some(unsafe { transmute(0x88a2u32) }),
0x6a5c => Some(unsafe { transmute(0x888du32) }),
0x6a5d => Some(unsafe { transmute(0x88a4u32) }),
0x6a5e => Some(unsafe { transmute(0x88b0u32) }),
0x6a5f => Some(unsafe { transmute(0x88bfu32) }),
0x6a60 => Some(unsafe { transmute(0x88b1u32) }),
0x6a61 => Some(unsafe { transmute(0x88c3u32) }),
0x6a62 => Some(unsafe { transmute(0x88c4u32) }),
0x6a63 => Some(unsafe { transmute(0x88d4u32) }),
0x6a64 => Some(unsafe { transmute(0x88d8u32) }),
0x6a65 => Some(unsafe { transmute(0x88d9u32) }),
0x6a66 => Some(unsafe { transmute(0x88ddu32) }),
0x6a67 => Some(unsafe { transmute(0x88f9u32) }),
0x6a68 => Some(unsafe { transmute(0x8902u32) }),
0x6a69 => Some(unsafe { transmute(0x88fcu32) }),
0x6a6a => Some(unsafe { transmute(0x88f4u32) }),
0x6a6b => Some(unsafe { transmute(0x88e8u32) }),
0x6a6c => Some(unsafe { transmute(0x88f2u32) }),
0x6a6d => Some(unsafe { transmute(0x8904u32) }),
0x6a6e => Some(unsafe { transmute(0x890cu32) }),
0x6a6f => Some(unsafe { transmute(0x890au32) }),
0x6a70 => Some(unsafe { transmute(0x8913u32) }),
0x6a71 => Some(unsafe { transmute(0x8943u32) }),
0x6a72 => Some(unsafe { transmute(0x891eu32) }),
0x6a73 => Some(unsafe { transmute(0x8925u32) }),
0x6a74 => Some(unsafe { transmute(0x892au32) }),
0x6a75 => Some(unsafe { transmute(0x892bu32) }),
0x6a76 => Some(unsafe { transmute(0x8941u32) }),
0x6a77 => Some(unsafe { transmute(0x8944u32) }),
0x6a78 => Some(unsafe { transmute(0x893bu32) }),
0x6a79 => Some(unsafe { transmute(0x8936u32) }),
0x6a7a => Some(unsafe { transmute(0x8938u32) }),
0x6a7b => Some(unsafe { transmute(0x894cu32) }),
0x6a7c => Some(unsafe { transmute(0x891du32) }),
0x6a7d => Some(unsafe { transmute(0x8960u32) }),
0x6a7e => Some(unsafe { transmute(0x895eu32) }),
0x6b21 => Some(unsafe { transmute(0x8966u32) }),
0x6b22 => Some(unsafe { transmute(0x8964u32) }),
0x6b23 => Some(unsafe { transmute(0x896du32) }),
0x6b24 => Some(unsafe { transmute(0x896au32) }),
0x6b25 => Some(unsafe { transmute(0x896fu32) }),
0x6b26 => Some(unsafe { transmute(0x8974u32) }),
0x6b27 => Some(unsafe { transmute(0x8977u32) }),
0x6b28 => Some(unsafe { transmute(0x897eu32) }),
0x6b29 => Some(unsafe { transmute(0x8983u32) }),
0x6b2a => Some(unsafe { transmute(0x8988u32) }),
0x6b2b => Some(unsafe { transmute(0x898au32) }),
0x6b2c => Some(unsafe { transmute(0x8993u32) }),
0x6b2d => Some(unsafe { transmute(0x8998u32) }),
0x6b2e => Some(unsafe { transmute(0x89a1u32) }),
0x6b2f => Some(unsafe { transmute(0x89a9u32) }),
0x6b30 => Some(unsafe { transmute(0x89a6u32) }),
0x6b31 => Some(unsafe { transmute(0x89acu32) }),
0x6b32 => Some(unsafe { transmute(0x89afu32) }),
0x6b33 => Some(unsafe { transmute(0x89b2u32) }),
0x6b34 => Some(unsafe { transmute(0x89bau32) }),
0x6b35 => Some(unsafe { transmute(0x89bdu32) }),
0x6b36 => Some(unsafe { transmute(0x89bfu32) }),
0x6b37 => Some(unsafe { transmute(0x89c0u32) }),
0x6b38 => Some(unsafe { transmute(0x89dau32) }),
0x6b39 => Some(unsafe { transmute(0x89dcu32) }),
0x6b3a => Some(unsafe { transmute(0x89ddu32) }),
0x6b3b => Some(unsafe { transmute(0x89e7u32) }),
0x6b3c => Some(unsafe { transmute(0x89f4u32) }),
0x6b3d => Some(unsafe { transmute(0x89f8u32) }),
0x6b3e => Some(unsafe { transmute(0x8a03u32) }),
0x6b3f => Some(unsafe { transmute(0x8a16u32) }),
0x6b40 => Some(unsafe { transmute(0x8a10u32) }),
0x6b41 => Some(unsafe { transmute(0x8a0cu32) }),
0x6b42 => Some(unsafe { transmute(0x8a1bu32) }),
0x6b43 => Some(unsafe { transmute(0x8a1du32) }),
0x6b44 => Some(unsafe { transmute(0x8a25u32) }),
0x6b45 => Some(unsafe { transmute(0x8a36u32) }),
0x6b46 => Some(unsafe { transmute(0x8a41u32) }),
0x6b47 => Some(unsafe { transmute(0x8a5bu32) }),
0x6b48 => Some(unsafe { transmute(0x8a52u32) }),
0x6b49 => Some(unsafe { transmute(0x8a46u32) }),
0x6b4a => Some(unsafe { transmute(0x8a48u32) }),
0x6b4b => Some(unsafe { transmute(0x8a7cu32) }),
0x6b4c => Some(unsafe { transmute(0x8a6du32) }),
0x6b4d => Some(unsafe { transmute(0x8a6cu32) }),
0x6b4e => Some(unsafe { transmute(0x8a62u32) }),
0x6b4f => Some(unsafe { transmute(0x8a85u32) }),
0x6b50 => Some(unsafe { transmute(0x8a82u32) }),
0x6b51 => Some(unsafe { transmute(0x8a84u32) }),
0x6b52 => Some(unsafe { transmute(0x8aa8u32) }),
0x6b53 => Some(unsafe { transmute(0x8aa1u32) }),
0x6b54 => Some(unsafe { transmute(0x8a91u32) }),
0x6b55 => Some(unsafe { transmute(0x8aa5u32) }),
0x6b56 => Some(unsafe { transmute(0x8aa6u32) }),
0x6b57 => Some(unsafe { transmute(0x8a9au32) }),
0x6b58 => Some(unsafe { transmute(0x8aa3u32) }),
0x6b59 => Some(unsafe { transmute(0x8ac4u32) }),
0x6b5a => Some(unsafe { transmute(0x8acdu32) }),
0x6b5b => Some(unsafe { transmute(0x8ac2u32) }),
0x6b5c => Some(unsafe { transmute(0x8adau32) }),
0x6b5d => Some(unsafe { transmute(0x8aebu32) }),
0x6b5e => Some(unsafe { transmute(0x8af3u32) }),
0x6b5f => Some(unsafe { transmute(0x8ae7u32) }),
0x6b60 => Some(unsafe { transmute(0x8ae4u32) }),
0x6b61 => Some(unsafe { transmute(0x8af1u32) }),
0x6b62 => Some(unsafe { transmute(0x8b14u32) }),
0x6b63 => Some(unsafe { transmute(0x8ae0u32) }),
0x6b64 => Some(unsafe { transmute(0x8ae2u32) }),
0x6b65 => Some(unsafe { transmute(0x8af7u32) }),
0x6b66 => Some(unsafe { transmute(0x8adeu32) }),
0x6b67 => Some(unsafe { transmute(0x8adbu32) }),
0x6b68 => Some(unsafe { transmute(0x8b0cu32) }),
0x6b69 => Some(unsafe { transmute(0x8b07u32) }),
0x6b6a => Some(unsafe { transmute(0x8b1au32) }),
0x6b6b => Some(unsafe { transmute(0x8ae1u32) }),
0x6b6c => Some(unsafe { transmute(0x8b16u32) }),
0x6b6d => Some(unsafe { transmute(0x8b10u32) }),
0x6b6e => Some(unsafe { transmute(0x8b17u32) }),
0x6b6f => Some(unsafe { transmute(0x8b20u32) }),
0x6b70 => Some(unsafe { transmute(0x8b33u32) }),
0x6b71 => Some(unsafe { transmute(0x97abu32) }),
0x6b72 => Some(unsafe { transmute(0x8b26u32) }),
0x6b73 => Some(unsafe { transmute(0x8b2bu32) }),
0x6b74 => Some(unsafe { transmute(0x8b3eu32) }),
0x6b75 => Some(unsafe { transmute(0x8b28u32) }),
0x6b76 => Some(unsafe { transmute(0x8b41u32) }),
0x6b77 => Some(unsafe { transmute(0x8b4cu32) }),
0x6b78 => Some(unsafe { transmute(0x8b4fu32) }),
0x6b79 => Some(unsafe { transmute(0x8b4eu32) }),
0x6b7a => Some(unsafe { transmute(0x8b49u32) }),
0x6b7b => Some(unsafe { transmute(0x8b56u32) }),
0x6b7c => Some(unsafe { transmute(0x8b5bu32) }),
0x6b7d => Some(unsafe { transmute(0x8b5au32) }),
0x6b7e => Some(unsafe { transmute(0x8b6bu32) }),
0x6c21 => Some(unsafe { transmute(0x8b5fu32) }),
0x6c22 => Some(unsafe { transmute(0x8b6cu32) }),
0x6c23 => Some(unsafe { transmute(0x8b6fu32) }),
0x6c24 => Some(unsafe { transmute(0x8b74u32) }),
0x6c25 => Some(unsafe { transmute(0x8b7du32) }),
0x6c26 => Some(unsafe { transmute(0x8b80u32) }),
0x6c27 => Some(unsafe { transmute(0x8b8cu32) }),
0x6c28 => Some(unsafe { transmute(0x8b8eu32) }),
0x6c29 => Some(unsafe { transmute(0x8b92u32) }),
0x6c2a => Some(unsafe { transmute(0x8b93u32) }),
0x6c2b => Some(unsafe { transmute(0x8b96u32) }),
0x6c2c => Some(unsafe { transmute(0x8b99u32) }),
0x6c2d => Some(unsafe { transmute(0x8b9au32) }),
0x6c2e => Some(unsafe { transmute(0x8c3au32) }),
0x6c2f => Some(unsafe { transmute(0x8c41u32) }),
0x6c30 => Some(unsafe { transmute(0x8c3fu32) }),
0x6c31 => Some(unsafe { transmute(0x8c48u32) }),
0x6c32 => Some(unsafe { transmute(0x8c4cu32) }),
0x6c33 => Some(unsafe { transmute(0x8c4eu32) }),
0x6c34 => Some(unsafe { transmute(0x8c50u32) }),
0x6c35 => Some(unsafe { transmute(0x8c55u32) }),
0x6c36 => Some(unsafe { transmute(0x8c62u32) }),
0x6c37 => Some(unsafe { transmute(0x8c6cu32) }),
0x6c38 => Some(unsafe { transmute(0x8c78u32) }),
0x6c39 => Some(unsafe { transmute(0x8c7au32) }),
0x6c3a => Some(unsafe { transmute(0x8c82u32) }),
0x6c3b => Some(unsafe { transmute(0x8c89u32) }),
0x6c3c => Some(unsafe { transmute(0x8c85u32) }),
0x6c3d => Some(unsafe { transmute(0x8c8au32) }),
0x6c3e => Some(unsafe { transmute(0x8c8du32) }),
0x6c3f => Some(unsafe { transmute(0x8c8eu32) }),
0x6c40 => Some(unsafe { transmute(0x8c94u32) }),
0x6c41 => Some(unsafe { transmute(0x8c7cu32) }),
0x6c42 => Some(unsafe { transmute(0x8c98u32) }),
0x6c43 => Some(unsafe { transmute(0x621du32) }),
0x6c44 => Some(unsafe { transmute(0x8cadu32) }),
0x6c45 => Some(unsafe { transmute(0x8caau32) }),
0x6c46 => Some(unsafe { transmute(0x8cbdu32) }),
0x6c47 => Some(unsafe { transmute(0x8cb2u32) }),
0x6c48 => Some(unsafe { transmute(0x8cb3u32) }),
0x6c49 => Some(unsafe { transmute(0x8caeu32) }),
0x6c4a => Some(unsafe { transmute(0x8cb6u32) }),
0x6c4b => Some(unsafe { transmute(0x8cc8u32) }),
0x6c4c => Some(unsafe { transmute(0x8cc1u32) }),
0x6c4d => Some(unsafe { transmute(0x8ce4u32) }),
0x6c4e => Some(unsafe { transmute(0x8ce3u32) }),
0x6c4f => Some(unsafe { transmute(0x8cdau32) }),
0x6c50 => Some(unsafe { transmute(0x8cfdu32) }),
0x6c51 => Some(unsafe { transmute(0x8cfau32) }),
0x6c52 => Some(unsafe { transmute(0x8cfbu32) }),
0x6c53 => Some(unsafe { transmute(0x8d04u32) }),
0x6c54 => Some(unsafe { transmute(0x8d05u32) }),
0x6c55 => Some(unsafe { transmute(0x8d0au32) }),
0x6c56 => Some(unsafe { transmute(0x8d07u32) }),
0x6c57 => Some(unsafe { transmute(0x8d0fu32) }),
0x6c58 => Some(unsafe { transmute(0x8d0du32) }),
0x6c59 => Some(unsafe { transmute(0x8d10u32) }),
0x6c5a => Some(unsafe { transmute(0x9f4eu32) }),
0x6c5b => Some(unsafe { transmute(0x8d13u32) }),
0x6c5c => Some(unsafe { transmute(0x8ccdu32) }),
0x6c5d => Some(unsafe { transmute(0x8d14u32) }),
0x6c5e => Some(unsafe { transmute(0x8d16u32) }),
0x6c5f => Some(unsafe { transmute(0x8d67u32) }),
0x6c60 => Some(unsafe { transmute(0x8d6du32) }),
0x6c61 => Some(unsafe { transmute(0x8d71u32) }),
0x6c62 => Some(unsafe { transmute(0x8d73u32) }),
0x6c63 => Some(unsafe { transmute(0x8d81u32) }),
0x6c64 => Some(unsafe { transmute(0x8d99u32) }),
0x6c65 => Some(unsafe { transmute(0x8dc2u32) }),
0x6c66 => Some(unsafe { transmute(0x8dbeu32) }),
0x6c67 => Some(unsafe { transmute(0x8dbau32) }),
0x6c68 => Some(unsafe { transmute(0x8dcfu32) }),
0x6c69 => Some(unsafe { transmute(0x8ddau32) }),
0x6c6a => Some(unsafe { transmute(0x8dd6u32) }),
0x6c6b => Some(unsafe { transmute(0x8dccu32) }),
0x6c6c => Some(unsafe { transmute(0x8ddbu32) }),
0x6c6d => Some(unsafe { transmute(0x8dcbu32) }),
0x6c6e => Some(unsafe { transmute(0x8deau32) }),
0x6c6f => Some(unsafe { transmute(0x8debu32) }),
0x6c70 => Some(unsafe { transmute(0x8ddfu32) }),
0x6c71 => Some(unsafe { transmute(0x8de3u32) }),
0x6c72 => Some(unsafe { transmute(0x8dfcu32) }),
0x6c73 => Some(unsafe { transmute(0x8e08u32) }),
0x6c74 => Some(unsafe { transmute(0x8e09u32) }),
0x6c75 => Some(unsafe { transmute(0x8dffu32) }),
0x6c76 => Some(unsafe { transmute(0x8e1du32) }),
0x6c77 => Some(unsafe { transmute(0x8e1eu32) }),
0x6c78 => Some(unsafe { transmute(0x8e10u32) }),
0x6c79 => Some(unsafe { transmute(0x8e1fu32) }),
0x6c7a => Some(unsafe { transmute(0x8e42u32) }),
0x6c7b => Some(unsafe { transmute(0x8e35u32) }),
0x6c7c => Some(unsafe { transmute(0x8e30u32) }),
0x6c7d => Some(unsafe { transmute(0x8e34u32) }),
0x6c7e => Some(unsafe { transmute(0x8e4au32) }),
0x6d21 => Some(unsafe { transmute(0x8e47u32) }),
0x6d22 => Some(unsafe { transmute(0x8e49u32) }),
0x6d23 => Some(unsafe { transmute(0x8e4cu32) }),
0x6d24 => Some(unsafe { transmute(0x8e50u32) }),
0x6d25 => Some(unsafe { transmute(0x8e48u32) }),
0x6d26 => Some(unsafe { transmute(0x8e59u32) }),
0x6d27 => Some(unsafe { transmute(0x8e64u32) }),
0x6d28 => Some(unsafe { transmute(0x8e60u32) }),
0x6d29 => Some(unsafe { transmute(0x8e2au32) }),
0x6d2a => Some(unsafe { transmute(0x8e63u32) }),
0x6d2b => Some(unsafe { transmute(0x8e55u32) }),
0x6d2c => Some(unsafe { transmute(0x8e76u32) }),
0x6d2d => Some(unsafe { transmute(0x8e72u32) }),
0x6d2e => Some(unsafe { transmute(0x8e7cu32) }),
0x6d2f => Some(unsafe { transmute(0x8e81u32) }),
0x6d30 => Some(unsafe { transmute(0x8e87u32) }),
0x6d31 => Some(unsafe { transmute(0x8e85u32) }),
0x6d32 => Some(unsafe { transmute(0x8e84u32) }),
0x6d33 => Some(unsafe { transmute(0x8e8bu32) }),
0x6d34 => Some(unsafe { transmute(0x8e8au32) }),
0x6d35 => Some(unsafe { transmute(0x8e93u32) }),
0x6d36 => Some(unsafe { transmute(0x8e91u32) }),
0x6d37 => Some(unsafe { transmute(0x8e94u32) }),
0x6d38 => Some(unsafe { transmute(0x8e99u32) }),
0x6d39 => Some(unsafe { transmute(0x8eaau32) }),
0x6d3a => Some(unsafe { transmute(0x8ea1u32) }),
0x6d3b => Some(unsafe { transmute(0x8eacu32) }),
0x6d3c => Some(unsafe { transmute(0x8eb0u32) }),
0x6d3d => Some(unsafe { transmute(0x8ec6u32) }),
0x6d3e => Some(unsafe { transmute(0x8eb1u32) }),
0x6d3f => Some(unsafe { transmute(0x8ebeu32) }),
0x6d40 => Some(unsafe { transmute(0x8ec5u32) }),
0x6d41 => Some(unsafe { transmute(0x8ec8u32) }),
0x6d42 => Some(unsafe { transmute(0x8ecbu32) }),
0x6d43 => Some(unsafe { transmute(0x8edbu32) }),
0x6d44 => Some(unsafe { transmute(0x8ee3u32) }),
0x6d45 => Some(unsafe { transmute(0x8efcu32) }),
0x6d46 => Some(unsafe { transmute(0x8efbu32) }),
0x6d47 => Some(unsafe { transmute(0x8eebu32) }),
0x6d48 => Some(unsafe { transmute(0x8efeu32) }),
0x6d49 => Some(unsafe { transmute(0x8f0au32) }),
0x6d4a => Some(unsafe { transmute(0x8f05u32) }),
0x6d4b => Some(unsafe { transmute(0x8f15u32) }),
0x6d4c => Some(unsafe { transmute(0x8f12u32) }),
0x6d4d => Some(unsafe { transmute(0x8f19u32) }),
0x6d4e => Some(unsafe { transmute(0x8f13u32) }),
0x6d4f => Some(unsafe { transmute(0x8f1cu32) }),
0x6d50 => Some(unsafe { transmute(0x8f1fu32) }),
0x6d51 => Some(unsafe { transmute(0x8f1bu32) }),
0x6d52 => Some(unsafe { transmute(0x8f0cu32) }),
0x6d53 => Some(unsafe { transmute(0x8f26u32) }),
0x6d54 => Some(unsafe { transmute(0x8f33u32) }),
0x6d55 => Some(unsafe { transmute(0x8f3bu32) }),
0x6d56 => Some(unsafe { transmute(0x8f39u32) }),
0x6d57 => Some(unsafe { transmute(0x8f45u32) }),
0x6d58 => Some(unsafe { transmute(0x8f42u32) }),
0x6d59 => Some(unsafe { transmute(0x8f3eu32) }),
0x6d5a => Some(unsafe { transmute(0x8f4cu32) }),
0x6d5b => Some(unsafe { transmute(0x8f49u32) }),
0x6d5c => Some(unsafe { transmute(0x8f46u32) }),
0x6d5d => Some(unsafe { transmute(0x8f4eu32) }),
0x6d5e => Some(unsafe { transmute(0x8f57u32) }),
0x6d5f => Some(unsafe { transmute(0x8f5cu32) }),
0x6d60 => Some(unsafe { transmute(0x8f62u32) }),
0x6d61 => Some(unsafe { transmute(0x8f63u32) }),
0x6d62 => Some(unsafe { transmute(0x8f64u32) }),
0x6d63 => Some(unsafe { transmute(0x8f9cu32) }),
0x6d64 => Some(unsafe { transmute(0x8f9fu32) }),
0x6d65 => Some(unsafe { transmute(0x8fa3u32) }),
0x6d66 => Some(unsafe { transmute(0x8fadu32) }),
0x6d67 => Some(unsafe { transmute(0x8fafu32) }),
0x6d68 => Some(unsafe { transmute(0x8fb7u32) }),
0x6d69 => Some(unsafe { transmute(0x8fdau32) }),
0x6d6a => Some(unsafe { transmute(0x8fe5u32) }),
0x6d6b => Some(unsafe { transmute(0x8fe2u32) }),
0x6d6c => Some(unsafe { transmute(0x8feau32) }),
0x6d6d => Some(unsafe { transmute(0x8fefu32) }),
0x6d6e => Some(unsafe { transmute(0x9087u32) }),
0x6d6f => Some(unsafe { transmute(0x8ff4u32) }),
0x6d70 => Some(unsafe { transmute(0x9005u32) }),
0x6d71 => Some(unsafe { transmute(0x8ff9u32) }),
0x6d72 => Some(unsafe { transmute(0x8ffau32) }),
0x6d73 => Some(unsafe { transmute(0x9011u32) }),
0x6d74 => Some(unsafe { transmute(0x9015u32) }),
0x6d75 => Some(unsafe { transmute(0x9021u32) }),
0x6d76 => Some(unsafe { transmute(0x900du32) }),
0x6d77 => Some(unsafe { transmute(0x901eu32) }),
0x6d78 => Some(unsafe { transmute(0x9016u32) }),
0x6d79 => Some(unsafe { transmute(0x900bu32) }),
0x6d7a => Some(unsafe { transmute(0x9027u32) }),
0x6d7b => Some(unsafe { transmute(0x9036u32) }),
0x6d7c => Some(unsafe { transmute(0x9035u32) }),
0x6d7d => Some(unsafe { transmute(0x9039u32) }),
0x6d7e => Some(unsafe { transmute(0x8ff8u32) }),
0x6e21 => Some(unsafe { transmute(0x904fu32) }),
0x6e22 => Some(unsafe { transmute(0x9050u32) }),
0x6e23 => Some(unsafe { transmute(0x9051u32) }),
0x6e24 => Some(unsafe { transmute(0x9052u32) }),
0x6e25 => Some(unsafe { transmute(0x900eu32) }),
0x6e26 => Some(unsafe { transmute(0x9049u32) }),
0x6e27 => Some(unsafe { transmute(0x903eu32) }),
0x6e28 => Some(unsafe { transmute(0x9056u32) }),
0x6e29 => Some(unsafe { transmute(0x9058u32) }),
0x6e2a => Some(unsafe { transmute(0x905eu32) }),
0x6e2b => Some(unsafe { transmute(0x9068u32) }),
0x6e2c => Some(unsafe { transmute(0x906fu32) }),
0x6e2d => Some(unsafe { transmute(0x9076u32) }),
0x6e2e => Some(unsafe { transmute(0x96a8u32) }),
0x6e2f => Some(unsafe { transmute(0x9072u32) }),
0x6e30 => Some(unsafe { transmute(0x9082u32) }),
0x6e31 => Some(unsafe { transmute(0x907du32) }),
0x6e32 => Some(unsafe { transmute(0x9081u32) }),
0x6e33 => Some(unsafe { transmute(0x9080u32) }),
0x6e34 => Some(unsafe { transmute(0x908au32) }),
0x6e35 => Some(unsafe { transmute(0x9089u32) }),
0x6e36 => Some(unsafe { transmute(0x908fu32) }),
0x6e37 => Some(unsafe { transmute(0x90a8u32) }),
0x6e38 => Some(unsafe { transmute(0x90afu32) }),
0x6e39 => Some(unsafe { transmute(0x90b1u32) }),
0x6e3a => Some(unsafe { transmute(0x90b5u32) }),
0x6e3b => Some(unsafe { transmute(0x90e2u32) }),
0x6e3c => Some(unsafe { transmute(0x90e4u32) }),
0x6e3d => Some(unsafe { transmute(0x6248u32) }),
0x6e3e => Some(unsafe { transmute(0x90dbu32) }),
0x6e3f => Some(unsafe { transmute(0x9102u32) }),
0x6e40 => Some(unsafe { transmute(0x9112u32) }),
0x6e41 => Some(unsafe { transmute(0x9119u32) }),
0x6e42 => Some(unsafe { transmute(0x9132u32) }),
0x6e43 => Some(unsafe { transmute(0x9130u32) }),
0x6e44 => Some(unsafe { transmute(0x914au32) }),
0x6e45 => Some(unsafe { transmute(0x9156u32) }),
0x6e46 => Some(unsafe { transmute(0x9158u32) }),
0x6e47 => Some(unsafe { transmute(0x9163u32) }),
0x6e48 => Some(unsafe { transmute(0x9165u32) }),
0x6e49 => Some(unsafe { transmute(0x9169u32) }),
0x6e4a => Some(unsafe { transmute(0x9173u32) }),
0x6e4b => Some(unsafe { transmute(0x9172u32) }),
0x6e4c => Some(unsafe { transmute(0x918bu32) }),
0x6e4d => Some(unsafe { transmute(0x9189u32) }),
0x6e4e => Some(unsafe { transmute(0x9182u32) }),
0x6e4f => Some(unsafe { transmute(0x91a2u32) }),
0x6e50 => Some(unsafe { transmute(0x91abu32) }),
0x6e51 => Some(unsafe { transmute(0x91afu32) }),
0x6e52 => Some(unsafe { transmute(0x91aau32) }),
0x6e53 => Some(unsafe { transmute(0x91b5u32) }),
0x6e54 => Some(unsafe { transmute(0x91b4u32) }),
0x6e55 => Some(unsafe { transmute(0x91bau32) }),
0x6e56 => Some(unsafe { transmute(0x91c0u32) }),
0x6e57 => Some(unsafe { transmute(0x91c1u32) }),
0x6e58 => Some(unsafe { transmute(0x91c9u32) }),
0x6e59 => Some(unsafe { transmute(0x91cbu32) }),
0x6e5a => Some(unsafe { transmute(0x91d0u32) }),
0x6e5b => Some(unsafe { transmute(0x91d6u32) }),
0x6e5c => Some(unsafe { transmute(0x91dfu32) }),
0x6e5d => Some(unsafe { transmute(0x91e1u32) }),
0x6e5e => Some(unsafe { transmute(0x91dbu32) }),
0x6e5f => Some(unsafe { transmute(0x91fcu32) }),
0x6e60 => Some(unsafe { transmute(0x91f5u32) }),
0x6e61 => Some(unsafe { transmute(0x91f6u32) }),
0x6e62 => Some(unsafe { transmute(0x921eu32) }),
0x6e63 => Some(unsafe { transmute(0x91ffu32) }),
0x6e64 => Some(unsafe { transmute(0x9214u32) }),
0x6e65 => Some(unsafe { transmute(0x922cu32) }),
0x6e66 => Some(unsafe { transmute(0x9215u32) }),
0x6e67 => Some(unsafe { transmute(0x9211u32) }),
0x6e68 => Some(unsafe { transmute(0x925eu32) }),
0x6e69 => Some(unsafe { transmute(0x9257u32) }),
0x6e6a => Some(unsafe { transmute(0x9245u32) }),
0x6e6b => Some(unsafe { transmute(0x9249u32) }),
0x6e6c => Some(unsafe { transmute(0x9264u32) }),
0x6e6d => Some(unsafe { transmute(0x9248u32) }),
0x6e6e => Some(unsafe { transmute(0x9295u32) }),
0x6e6f => Some(unsafe { transmute(0x923fu32) }),
0x6e70 => Some(unsafe { transmute(0x924bu32) }),
0x6e71 => Some(unsafe { transmute(0x9250u32) }),
0x6e72 => Some(unsafe { transmute(0x929cu32) }),
0x6e73 => Some(unsafe { transmute(0x9296u32) }),
0x6e74 => Some(unsafe { transmute(0x9293u32) }),
0x6e75 => Some(unsafe { transmute(0x929bu32) }),
0x6e76 => Some(unsafe { transmute(0x925au32) }),
0x6e77 => Some(unsafe { transmute(0x92cfu32) }),
0x6e78 => Some(unsafe { transmute(0x92b9u32) }),
0x6e79 => Some(unsafe { transmute(0x92b7u32) }),
0x6e7a => Some(unsafe { transmute(0x92e9u32) }),
0x6e7b => Some(unsafe { transmute(0x930fu32) }),
0x6e7c => Some(unsafe { transmute(0x92fau32) }),
0x6e7d => Some(unsafe { transmute(0x9344u32) }),
0x6e7e => Some(unsafe { transmute(0x932eu32) }),
0x6f21 => Some(unsafe { transmute(0x9319u32) }),
0x6f22 => Some(unsafe { transmute(0x9322u32) }),
0x6f23 => Some(unsafe { transmute(0x931au32) }),
0x6f24 => Some(unsafe { transmute(0x9323u32) }),
0x6f25 => Some(unsafe { transmute(0x933au32) }),
0x6f26 => Some(unsafe { transmute(0x9335u32) }),
0x6f27 => Some(unsafe { transmute(0x933bu32) }),
0x6f28 => Some(unsafe { transmute(0x935cu32) }),
0x6f29 => Some(unsafe { transmute(0x9360u32) }),
0x6f2a => Some(unsafe { transmute(0x937cu32) }),
0x6f2b => Some(unsafe { transmute(0x936eu32) }),
0x6f2c => Some(unsafe { transmute(0x9356u32) }),
0x6f2d => Some(unsafe { transmute(0x93b0u32) }),
0x6f2e => Some(unsafe { transmute(0x93acu32) }),
0x6f2f => Some(unsafe { transmute(0x93adu32) }),
0x6f30 => Some(unsafe { transmute(0x9394u32) }),
0x6f31 => Some(unsafe { transmute(0x93b9u32) }),
0x6f32 => Some(unsafe { transmute(0x93d6u32) }),
0x6f33 => Some(unsafe { transmute(0x93d7u32) }),
0x6f34 => Some(unsafe { transmute(0x93e8u32) }),
0x6f35 => Some(unsafe { transmute(0x93e5u32) }),
0x6f36 => Some(unsafe { transmute(0x93d8u32) }),
0x6f37 => Some(unsafe { transmute(0x93c3u32) }),
0x6f38 => Some(unsafe { transmute(0x93ddu32) }),
0x6f39 => Some(unsafe { transmute(0x93d0u32) }),
0x6f3a => Some(unsafe { transmute(0x93c8u32) }),
0x6f3b => Some(unsafe { transmute(0x93e4u32) }),
0x6f3c => Some(unsafe { transmute(0x941au32) }),
0x6f3d => Some(unsafe { transmute(0x9414u32) }),
0x6f3e => Some(unsafe { transmute(0x9413u32) }),
0x6f3f => Some(unsafe { transmute(0x9403u32) }),
0x6f40 => Some(unsafe { transmute(0x9407u32) }),
0x6f41 => Some(unsafe { transmute(0x9410u32) }),
0x6f42 => Some(unsafe { transmute(0x9436u32) }),
0x6f43 => Some(unsafe { transmute(0x942bu32) }),
0x6f44 => Some(unsafe { transmute(0x9435u32) }),
0x6f45 => Some(unsafe { transmute(0x9421u32) }),
0x6f46 => Some(unsafe { transmute(0x943au32) }),
0x6f47 => Some(unsafe { transmute(0x9441u32) }),
0x6f48 => Some(unsafe { transmute(0x9452u32) }),
0x6f49 => Some(unsafe { transmute(0x9444u32) }),
0x6f4a => Some(unsafe { transmute(0x945bu32) }),
0x6f4b => Some(unsafe { transmute(0x9460u32) }),
0x6f4c => Some(unsafe { transmute(0x9462u32) }),
0x6f4d => Some(unsafe { transmute(0x945eu32) }),
0x6f4e => Some(unsafe { transmute(0x946au32) }),
0x6f4f => Some(unsafe { transmute(0x9229u32) }),
0x6f50 => Some(unsafe { transmute(0x9470u32) }),
0x6f51 => Some(unsafe { transmute(0x9475u32) }),
0x6f52 => Some(unsafe { transmute(0x9477u32) }),
0x6f53 => Some(unsafe { transmute(0x947du32) }),
0x6f54 => Some(unsafe { transmute(0x945au32) }),
0x6f55 => Some(unsafe { transmute(0x947cu32) }),
0x6f56 => Some(unsafe { transmute(0x947eu32) }),
0x6f57 => Some(unsafe { transmute(0x9481u32) }),
0x6f58 => Some(unsafe { transmute(0x947fu32) }),
0x6f59 => Some(unsafe { transmute(0x9582u32) }),
0x6f5a => Some(unsafe { transmute(0x9587u32) }),
0x6f5b => Some(unsafe { transmute(0x958au32) }),
0x6f5c => Some(unsafe { transmute(0x9594u32) }),
0x6f5d => Some(unsafe { transmute(0x9596u32) }),
0x6f5e => Some(unsafe { transmute(0x9598u32) }),
0x6f5f => Some(unsafe { transmute(0x9599u32) }),
0x6f60 => Some(unsafe { transmute(0x95a0u32) }),
0x6f61 => Some(unsafe { transmute(0x95a8u32) }),
0x6f62 => Some(unsafe { transmute(0x95a7u32) }),
0x6f63 => Some(unsafe { transmute(0x95adu32) }),
0x6f64 => Some(unsafe { transmute(0x95bcu32) }),
0x6f65 => Some(unsafe { transmute(0x95bbu32) }),
0x6f66 => Some(unsafe { transmute(0x95b9u32) }),
0x6f67 => Some(unsafe { transmute(0x95beu32) }),
0x6f68 => Some(unsafe { transmute(0x95cau32) }),
0x6f69 => Some(unsafe { transmute(0x6ff6u32) }),
0x6f6a => Some(unsafe { transmute(0x95c3u32) }),
0x6f6b => Some(unsafe { transmute(0x95cdu32) }),
0x6f6c => Some(unsafe { transmute(0x95ccu32) }),
0x6f6d => Some(unsafe { transmute(0x95d5u32) }),
0x6f6e => Some(unsafe { transmute(0x95d4u32) }),
0x6f6f => Some(unsafe { transmute(0x95d6u32) }),
0x6f70 => Some(unsafe { transmute(0x95dcu32) }),
0x6f71 => Some(unsafe { transmute(0x95e1u32) }),
0x6f72 => Some(unsafe { transmute(0x95e5u32) }),
0x6f73 => Some(unsafe { transmute(0x95e2u32) }),
0x6f74 => Some(unsafe { transmute(0x9621u32) }),
0x6f75 => Some(unsafe { transmute(0x9628u32) }),
0x6f76 => Some(unsafe { transmute(0x962eu32) }),
0x6f77 => Some(unsafe { transmute(0x962fu32) }),
0x6f78 => Some(unsafe { transmute(0x9642u32) }),
0x6f79 => Some(unsafe { transmute(0x964cu32) }),
0x6f7a => Some(unsafe { transmute(0x964fu32) }),
0x6f7b => Some(unsafe { transmute(0x964bu32) }),
0x6f7c => Some(unsafe { transmute(0x9677u32) }),
0x6f7d => Some(unsafe { transmute(0x965cu32) }),
0x6f7e => Some(unsafe { transmute(0x965eu32) }),
0x7021 => Some(unsafe { transmute(0x965du32) }),
0x7022 => Some(unsafe { transmute(0x965fu32) }),
0x7023 => Some(unsafe { transmute(0x9666u32) }),
0x7024 => Some(unsafe { transmute(0x9672u32) }),
0x7025 => Some(unsafe { transmute(0x966cu32) }),
0x7026 => Some(unsafe { transmute(0x968du32) }),
0x7027 => Some(unsafe { transmute(0x9698u32) }),
0x7028 => Some(unsafe { transmute(0x9695u32) }),
0x7029 => Some(unsafe { transmute(0x9697u32) }),
0x702a => Some(unsafe { transmute(0x96aau32) }),
0x702b => Some(unsafe { transmute(0x96a7u32) }),
0x702c => Some(unsafe { transmute(0x96b1u32) }),
0x702d => Some(unsafe { transmute(0x96b2u32) }),
0x702e => Some(unsafe { transmute(0x96b0u32) }),
0x702f => Some(unsafe { transmute(0x96b4u32) }),
0x7030 => Some(unsafe { transmute(0x96b6u32) }),
0x7031 => Some(unsafe { transmute(0x96b8u32) }),
0x7032 => Some(unsafe { transmute(0x96b9u32) }),
0x7033 => Some(unsafe { transmute(0x96ceu32) }),
0x7034 => Some(unsafe { transmute(0x96cbu32) }),
0x7035 => Some(unsafe { transmute(0x96c9u32) }),
0x7036 => Some(unsafe { transmute(0x96cdu32) }),
0x7037 => Some(unsafe { transmute(0x894du32) }),
0x7038 => Some(unsafe { transmute(0x96dcu32) }),
0x7039 => Some(unsafe { transmute(0x970du32) }),
0x703a => Some(unsafe { transmute(0x96d5u32) }),
0x703b => Some(unsafe { transmute(0x96f9u32) }),
0x703c => Some(unsafe { transmute(0x9704u32) }),
0x703d => Some(unsafe { transmute(0x9706u32) }),
0x703e => Some(unsafe { transmute(0x9708u32) }),
0x703f => Some(unsafe { transmute(0x9713u32) }),
0x7040 => Some(unsafe { transmute(0x970eu32) }),
0x7041 => Some(unsafe { transmute(0x9711u32) }),
0x7042 => Some(unsafe { transmute(0x970fu32) }),
0x7043 => Some(unsafe { transmute(0x9716u32) }),
0x7044 => Some(unsafe { transmute(0x9719u32) }),
0x7045 => Some(unsafe { transmute(0x9724u32) }),
0x7046 => Some(unsafe { transmute(0x972au32) }),
0x7047 => Some(unsafe { transmute(0x9730u32) }),
0x7048 => Some(unsafe { transmute(0x9739u32) }),
0x7049 => Some(unsafe { transmute(0x973du32) }),
0x704a => Some(unsafe { transmute(0x973eu32) }),
0x704b => Some(unsafe { transmute(0x9744u32) }),
0x704c => Some(unsafe { transmute(0x9746u32) }),
0x704d => Some(unsafe { transmute(0x9748u32) }),
0x704e => Some(unsafe { transmute(0x9742u32) }),
0x704f => Some(unsafe { transmute(0x9749u32) }),
0x7050 => Some(unsafe { transmute(0x975cu32) }),
0x7051 => Some(unsafe { transmute(0x9760u32) }),
0x7052 => Some(unsafe { transmute(0x9764u32) }),
0x7053 => Some(unsafe { transmute(0x9766u32) }),
0x7054 => Some(unsafe { transmute(0x9768u32) }),
0x7055 => Some(unsafe { transmute(0x52d2u32) }),
0x7056 => Some(unsafe { transmute(0x976bu32) }),
0x7057 => Some(unsafe { transmute(0x9771u32) }),
0x7058 => Some(unsafe { transmute(0x9779u32) }),
0x7059 => Some(unsafe { transmute(0x9785u32) }),
0x705a => Some(unsafe { transmute(0x977cu32) }),
0x705b => Some(unsafe { transmute(0x9781u32) }),
0x705c => Some(unsafe { transmute(0x977au32) }),
0x705d => Some(unsafe { transmute(0x9786u32) }),
0x705e => Some(unsafe { transmute(0x978bu32) }),
0x705f => Some(unsafe { transmute(0x978fu32) }),
0x7060 => Some(unsafe { transmute(0x9790u32) }),
0x7061 => Some(unsafe { transmute(0x979cu32) }),
0x7062 => Some(unsafe { transmute(0x97a8u32) }),
0x7063 => Some(unsafe { transmute(0x97a6u32) }),
0x7064 => Some(unsafe { transmute(0x97a3u32) }),
0x7065 => Some(unsafe { transmute(0x97b3u32) }),
0x7066 => Some(unsafe { transmute(0x97b4u32) }),
0x7067 => Some(unsafe { transmute(0x97c3u32) }),
0x7068 => Some(unsafe { transmute(0x97c6u32) }),
0x7069 => Some(unsafe { transmute(0x97c8u32) }),
0x706a => Some(unsafe { transmute(0x97cbu32) }),
0x706b => Some(unsafe { transmute(0x97dcu32) }),
0x706c => Some(unsafe { transmute(0x97edu32) }),
0x706d => Some(unsafe { transmute(0x9f4fu32) }),
0x706e => Some(unsafe { transmute(0x97f2u32) }),
0x706f => Some(unsafe { transmute(0x7adfu32) }),
0x7070 => Some(unsafe { transmute(0x97f6u32) }),
0x7071 => Some(unsafe { transmute(0x97f5u32) }),
0x7072 => Some(unsafe { transmute(0x980fu32) }),
0x7073 => Some(unsafe { transmute(0x980cu32) }),
0x7074 => Some(unsafe { transmute(0x9838u32) }),
0x7075 => Some(unsafe { transmute(0x9824u32) }),
0x7076 => Some(unsafe { transmute(0x9821u32) }),
0x7077 => Some(unsafe { transmute(0x9837u32) }),
0x7078 => Some(unsafe { transmute(0x983du32) }),
0x7079 => Some(unsafe { transmute(0x9846u32) }),
0x707a => Some(unsafe { transmute(0x984fu32) }),
0x707b => Some(unsafe { transmute(0x984bu32) }),
0x707c => Some(unsafe { transmute(0x986bu32) }),
0x707d => Some(unsafe { transmute(0x986fu32) }),
0x707e => Some(unsafe { transmute(0x9870u32) }),
0x7121 => Some(unsafe { transmute(0x9871u32) }),
0x7122 => Some(unsafe { transmute(0x9874u32) }),
0x7123 => Some(unsafe { transmute(0x9873u32) }),
0x7124 => Some(unsafe { transmute(0x98aau32) }),
0x7125 => Some(unsafe { transmute(0x98afu32) }),
0x7126 => Some(unsafe { transmute(0x98b1u32) }),
0x7127 => Some(unsafe { transmute(0x98b6u32) }),
0x7128 => Some(unsafe { transmute(0x98c4u32) }),
0x7129 => Some(unsafe { transmute(0x98c3u32) }),
0x712a => Some(unsafe { transmute(0x98c6u32) }),
0x712b => Some(unsafe { transmute(0x98e9u32) }),
0x712c => Some(unsafe { transmute(0x98ebu32) }),
0x712d => Some(unsafe { transmute(0x9903u32) }),
0x712e => Some(unsafe { transmute(0x9909u32) }),
0x712f => Some(unsafe { transmute(0x9912u32) }),
0x7130 => Some(unsafe { transmute(0x9914u32) }),
0x7131 => Some(unsafe { transmute(0x9918u32) }),
0x7132 => Some(unsafe { transmute(0x9921u32) }),
0x7133 => Some(unsafe { transmute(0x991du32) }),
0x7134 => Some(unsafe { transmute(0x991eu32) }),
0x7135 => Some(unsafe { transmute(0x9924u32) }),
0x7136 => Some(unsafe { transmute(0x9920u32) }),
0x7137 => Some(unsafe { transmute(0x992cu32) }),
0x7138 => Some(unsafe { transmute(0x992eu32) }),
0x7139 => Some(unsafe { transmute(0x993du32) }),
0x713a => Some(unsafe { transmute(0x993eu32) }),
0x713b => Some(unsafe { transmute(0x9942u32) }),
0x713c => Some(unsafe { transmute(0x9949u32) }),
0x713d => Some(unsafe { transmute(0x9945u32) }),
0x713e => Some(unsafe { transmute(0x9950u32) }),
0x713f => Some(unsafe { transmute(0x994bu32) }),
0x7140 => Some(unsafe { transmute(0x9951u32) }),
0x7141 => Some(unsafe { transmute(0x9952u32) }),
0x7142 => Some(unsafe { transmute(0x994cu32) }),
0x7143 => Some(unsafe { transmute(0x9955u32) }),
0x7144 => Some(unsafe { transmute(0x9997u32) }),
0x7145 => Some(unsafe { transmute(0x9998u32) }),
0x7146 => Some(unsafe { transmute(0x99a5u32) }),
0x7147 => Some(unsafe { transmute(0x99adu32) }),
0x7148 => Some(unsafe { transmute(0x99aeu32) }),
0x7149 => Some(unsafe { transmute(0x99bcu32) }),
0x714a => Some(unsafe { transmute(0x99dfu32) }),
0x714b => Some(unsafe { transmute(0x99dbu32) }),
0x714c => Some(unsafe { transmute(0x99ddu32) }),
0x714d => Some(unsafe { transmute(0x99d8u32) }),
0x714e => Some(unsafe { transmute(0x99d1u32) }),
0x714f => Some(unsafe { transmute(0x99edu32) }),
0x7150 => Some(unsafe { transmute(0x99eeu32) }),
0x7151 => Some(unsafe { transmute(0x99f1u32) }),
0x7152 => Some(unsafe { transmute(0x99f2u32) }),
0x7153 => Some(unsafe { transmute(0x99fbu32) }),
0x7154 => Some(unsafe { transmute(0x99f8u32) }),
0x7155 => Some(unsafe { transmute(0x9a01u32) }),
0x7156 => Some(unsafe { transmute(0x9a0fu32) }),
0x7157 => Some(unsafe { transmute(0x9a05u32) }),
0x7158 => Some(unsafe { transmute(0x99e2u32) }),
0x7159 => Some(unsafe { transmute(0x9a19u32) }),
0x715a => Some(unsafe { transmute(0x9a2bu32) }),
0x715b => Some(unsafe { transmute(0x9a37u32) }),
0x715c => Some(unsafe { transmute(0x9a45u32) }),
0x715d => Some(unsafe { transmute(0x9a42u32) }),
0x715e => Some(unsafe { transmute(0x9a40u32) }),
0x715f => Some(unsafe { transmute(0x9a43u32) }),
0x7160 => Some(unsafe { transmute(0x9a3eu32) }),
0x7161 => Some(unsafe { transmute(0x9a55u32) }),
0x7162 => Some(unsafe { transmute(0x9a4du32) }),
0x7163 => Some(unsafe { transmute(0x9a5bu32) }),
0x7164 => Some(unsafe { transmute(0x9a57u32) }),
0x7165 => Some(unsafe { transmute(0x9a5fu32) }),
0x7166 => Some(unsafe { transmute(0x9a62u32) }),
0x7167 => Some(unsafe { transmute(0x9a65u32) }),
0x7168 => Some(unsafe { transmute(0x9a64u32) }),
0x7169 => Some(unsafe { transmute(0x9a69u32) }),
0x716a => Some(unsafe { transmute(0x9a6bu32) }),
0x716b => Some(unsafe { transmute(0x9a6au32) }),
0x716c => Some(unsafe { transmute(0x9aadu32) }),
0x716d => Some(unsafe { transmute(0x9ab0u32) }),
0x716e => Some(unsafe { transmute(0x9abcu32) }),
0x716f => Some(unsafe { transmute(0x9ac0u32) }),
0x7170 => Some(unsafe { transmute(0x9acfu32) }),
0x7171 => Some(unsafe { transmute(0x9ad1u32) }),
0x7172 => Some(unsafe { transmute(0x9ad3u32) }),
0x7173 => Some(unsafe { transmute(0x9ad4u32) }),
0x7174 => Some(unsafe { transmute(0x9adeu32) }),
0x7175 => Some(unsafe { transmute(0x9adfu32) }),
0x7176 => Some(unsafe { transmute(0x9ae2u32) }),
0x7177 => Some(unsafe { transmute(0x9ae3u32) }),
0x7178 => Some(unsafe { transmute(0x9ae6u32) }),
0x7179 => Some(unsafe { transmute(0x9aefu32) }),
0x717a => Some(unsafe { transmute(0x9aebu32) }),
0x717b => Some(unsafe { transmute(0x9aeeu32) }),
0x717c => Some(unsafe { transmute(0x9af4u32) }),
0x717d => Some(unsafe { transmute(0x9af1u32) }),
0x717e => Some(unsafe { transmute(0x9af7u32) }),
0x7221 => Some(unsafe { transmute(0x9afbu32) }),
0x7222 => Some(unsafe { transmute(0x9b06u32) }),
0x7223 => Some(unsafe { transmute(0x9b18u32) }),
0x7224 => Some(unsafe { transmute(0x9b1au32) }),
0x7225 => Some(unsafe { transmute(0x9b1fu32) }),
0x7226 => Some(unsafe { transmute(0x9b22u32) }),
0x7227 => Some(unsafe { transmute(0x9b23u32) }),
0x7228 => Some(unsafe { transmute(0x9b25u32) }),
0x7229 => Some(unsafe { transmute(0x9b27u32) }),
0x722a => Some(unsafe { transmute(0x9b28u32) }),
0x722b => Some(unsafe { transmute(0x9b29u32) }),
0x722c => Some(unsafe { transmute(0x9b2au32) }),
0x722d => Some(unsafe { transmute(0x9b2eu32) }),
0x722e => Some(unsafe { transmute(0x9b2fu32) }),
0x722f => Some(unsafe { transmute(0x9b32u32) }),
0x7230 => Some(unsafe { transmute(0x9b44u32) }),
0x7231 => Some(unsafe { transmute(0x9b43u32) }),
0x7232 => Some(unsafe { transmute(0x9b4fu32) }),
0x7233 => Some(unsafe { transmute(0x9b4du32) }),
0x7234 => Some(unsafe { transmute(0x9b4eu32) }),
0x7235 => Some(unsafe { transmute(0x9b51u32) }),
0x7236 => Some(unsafe { transmute(0x9b58u32) }),
0x7237 => Some(unsafe { transmute(0x9b74u32) }),
0x7238 => Some(unsafe { transmute(0x9b93u32) }),
0x7239 => Some(unsafe { transmute(0x9b83u32) }),
0x723a => Some(unsafe { transmute(0x9b91u32) }),
0x723b => Some(unsafe { transmute(0x9b96u32) }),
0x723c => Some(unsafe { transmute(0x9b97u32) }),
0x723d => Some(unsafe { transmute(0x9b9fu32) }),
0x723e => Some(unsafe { transmute(0x9ba0u32) }),
0x723f => Some(unsafe { transmute(0x9ba8u32) }),
0x7240 => Some(unsafe { transmute(0x9bb4u32) }),
0x7241 => Some(unsafe { transmute(0x9bc0u32) }),
0x7242 => Some(unsafe { transmute(0x9bcau32) }),
0x7243 => Some(unsafe { transmute(0x9bb9u32) }),
0x7244 => Some(unsafe { transmute(0x9bc6u32) }),
0x7245 => Some(unsafe { transmute(0x9bcfu32) }),
0x7246 => Some(unsafe { transmute(0x9bd1u32) }),
0x7247 => Some(unsafe { transmute(0x9bd2u32) }),
0x7248 => Some(unsafe { transmute(0x9be3u32) }),
0x7249 => Some(unsafe { transmute(0x9be2u32) }),
0x724a => Some(unsafe { transmute(0x9be4u32) }),
0x724b => Some(unsafe { transmute(0x9bd4u32) }),
0x724c => Some(unsafe { transmute(0x9be1u32) }),
0x724d => Some(unsafe { transmute(0x9c3au32) }),
0x724e => Some(unsafe { transmute(0x9bf2u32) }),
0x724f => Some(unsafe { transmute(0x9bf1u32) }),
0x7250 => Some(unsafe { transmute(0x9bf0u32) }),
0x7251 => Some(unsafe { transmute(0x9c15u32) }),
0x7252 => Some(unsafe { transmute(0x9c14u32) }),
0x7253 => Some(unsafe { transmute(0x9c09u32) }),
0x7254 => Some(unsafe { transmute(0x9c13u32) }),
0x7255 => Some(unsafe { transmute(0x9c0cu32) }),
0x7256 => Some(unsafe { transmute(0x9c06u32) }),
0x7257 => Some(unsafe { transmute(0x9c08u32) }),
0x7258 => Some(unsafe { transmute(0x9c12u32) }),
0x7259 => Some(unsafe { transmute(0x9c0au32) }),
0x725a => Some(unsafe { transmute(0x9c04u32) }),
0x725b => Some(unsafe { transmute(0x9c2eu32) }),
0x725c => Some(unsafe { transmute(0x9c1bu32) }),
0x725d => Some(unsafe { transmute(0x9c25u32) }),
0x725e => Some(unsafe { transmute(0x9c24u32) }),
0x725f => Some(unsafe { transmute(0x9c21u32) }),
0x7260 => Some(unsafe { transmute(0x9c30u32) }),
0x7261 => Some(unsafe { transmute(0x9c47u32) }),
0x7262 => Some(unsafe { transmute(0x9c32u32) }),
0x7263 => Some(unsafe { transmute(0x9c46u32) }),
0x7264 => Some(unsafe { transmute(0x9c3eu32) }),
0x7265 => Some(unsafe { transmute(0x9c5au32) }),
0x7266 => Some(unsafe { transmute(0x9c60u32) }),
0x7267 => Some(unsafe { transmute(0x9c67u32) }),
0x7268 => Some(unsafe { transmute(0x9c76u32) }),
0x7269 => Some(unsafe { transmute(0x9c78u32) }),
0x726a => Some(unsafe { transmute(0x9ce7u32) }),
0x726b => Some(unsafe { transmute(0x9cecu32) }),
0x726c => Some(unsafe { transmute(0x9cf0u32) }),
0x726d => Some(unsafe { transmute(0x9d09u32) }),
0x726e => Some(unsafe { transmute(0x9d08u32) }),
0x726f => Some(unsafe { transmute(0x9cebu32) }),
0x7270 => Some(unsafe { transmute(0x9d03u32) }),
0x7271 => Some(unsafe { transmute(0x9d06u32) }),
0x7272 => Some(unsafe { transmute(0x9d2au32) }),
0x7273 => Some(unsafe { transmute(0x9d26u32) }),
0x7274 => Some(unsafe { transmute(0x9dafu32) }),
0x7275 => Some(unsafe { transmute(0x9d23u32) }),
0x7276 => Some(unsafe { transmute(0x9d1fu32) }),
0x7277 => Some(unsafe { transmute(0x9d44u32) }),
0x7278 => Some(unsafe { transmute(0x9d15u32) }),
0x7279 => Some(unsafe { transmute(0x9d12u32) }),
0x727a => Some(unsafe { transmute(0x9d41u32) }),
0x727b => Some(unsafe { transmute(0x9d3fu32) }),
0x727c => Some(unsafe { transmute(0x9d3eu32) }),
0x727d => Some(unsafe { transmute(0x9d46u32) }),
0x727e => Some(unsafe { transmute(0x9d48u32) }),
0x7321 => Some(unsafe { transmute(0x9d5du32) }),
0x7322 => Some(unsafe { transmute(0x9d5eu32) }),
0x7323 => Some(unsafe { transmute(0x9d64u32) }),
0x7324 => Some(unsafe { transmute(0x9d51u32) }),
0x7325 => Some(unsafe { transmute(0x9d50u32) }),
0x7326 => Some(unsafe { transmute(0x9d59u32) }),
0x7327 => Some(unsafe { transmute(0x9d72u32) }),
0x7328 => Some(unsafe { transmute(0x9d89u32) }),
0x7329 => Some(unsafe { transmute(0x9d87u32) }),
0x732a => Some(unsafe { transmute(0x9dabu32) }),
0x732b => Some(unsafe { transmute(0x9d6fu32) }),
0x732c => Some(unsafe { transmute(0x9d7au32) }),
0x732d => Some(unsafe { transmute(0x9d9au32) }),
0x732e => Some(unsafe { transmute(0x9da4u32) }),
0x732f => Some(unsafe { transmute(0x9da9u32) }),
0x7330 => Some(unsafe { transmute(0x9db2u32) }),
0x7331 => Some(unsafe { transmute(0x9dc4u32) }),
0x7332 => Some(unsafe { transmute(0x9dc1u32) }),
0x7333 => Some(unsafe { transmute(0x9dbbu32) }),
0x7334 => Some(unsafe { transmute(0x9db8u32) }),
0x7335 => Some(unsafe { transmute(0x9dbau32) }),
0x7336 => Some(unsafe { transmute(0x9dc6u32) }),
0x7337 => Some(unsafe { transmute(0x9dcfu32) }),
0x7338 => Some(unsafe { transmute(0x9dc2u32) }),
0x7339 => Some(unsafe { transmute(0x9dd9u32) }),
0x733a => Some(unsafe { transmute(0x9dd3u32) }),
0x733b => Some(unsafe { transmute(0x9df8u32) }),
0x733c => Some(unsafe { transmute(0x9de6u32) }),
0x733d => Some(unsafe { transmute(0x9dedu32) }),
0x733e => Some(unsafe { transmute(0x9defu32) }),
0x733f => Some(unsafe { transmute(0x9dfdu32) }),
0x7340 => Some(unsafe { transmute(0x9e1au32) }),
0x7341 => Some(unsafe { transmute(0x9e1bu32) }),
0x7342 => Some(unsafe { transmute(0x9e1eu32) }),
0x7343 => Some(unsafe { transmute(0x9e75u32) }),
0x7344 => Some(unsafe { transmute(0x9e79u32) }),
0x7345 => Some(unsafe { transmute(0x9e7du32) }),
0x7346 => Some(unsafe { transmute(0x9e81u32) }),
0x7347 => Some(unsafe { transmute(0x9e88u32) }),
0x7348 => Some(unsafe { transmute(0x9e8bu32) }),
0x7349 => Some(unsafe { transmute(0x9e8cu32) }),
0x734a => Some(unsafe { transmute(0x9e92u32) }),
0x734b => Some(unsafe { transmute(0x9e95u32) }),
0x734c => Some(unsafe { transmute(0x9e91u32) }),
0x734d => Some(unsafe { transmute(0x9e9du32) }),
0x734e => Some(unsafe { transmute(0x9ea5u32) }),
0x734f => Some(unsafe { transmute(0x9ea9u32) }),
0x7350 => Some(unsafe { transmute(0x9eb8u32) }),
0x7351 => Some(unsafe { transmute(0x9eaau32) }),
0x7352 => Some(unsafe { transmute(0x9eadu32) }),
0x7353 => Some(unsafe { transmute(0x9761u32) }),
0x7354 => Some(unsafe { transmute(0x9eccu32) }),
0x7355 => Some(unsafe { transmute(0x9eceu32) }),
0x7356 => Some(unsafe { transmute(0x9ecfu32) }),
0x7357 => Some(unsafe { transmute(0x9ed0u32) }),
0x7358 => Some(unsafe { transmute(0x9ed4u32) }),
0x7359 => Some(unsafe { transmute(0x9edcu32) }),
0x735a => Some(unsafe { transmute(0x9edeu32) }),
0x735b => Some(unsafe { transmute(0x9eddu32) }),
0x735c => Some(unsafe { transmute(0x9ee0u32) }),
0x735d => Some(unsafe { transmute(0x9ee5u32) }),
0x735e => Some(unsafe { transmute(0x9ee8u32) }),
0x735f => Some(unsafe { transmute(0x9eefu32) }),
0x7360 => Some(unsafe { transmute(0x9ef4u32) }),
0x7361 => Some(unsafe { transmute(0x9ef6u32) }),
0x7362 => Some(unsafe { transmute(0x9ef7u32) }),
0x7363 => Some(unsafe { transmute(0x9ef9u32) }),
0x7364 => Some(unsafe { transmute(0x9efbu32) }),
0x7365 => Some(unsafe { transmute(0x9efcu32) }),
0x7366 => Some(unsafe { transmute(0x9efdu32) }),
0x7367 => Some(unsafe { transmute(0x9f07u32) }),
0x7368 => Some(unsafe { transmute(0x9f08u32) }),
0x7369 => Some(unsafe { transmute(0x76b7u32) }),
0x736a => Some(unsafe { transmute(0x9f15u32) }),
0x736b => Some(unsafe { transmute(0x9f21u32) }),
0x736c => Some(unsafe { transmute(0x9f2cu32) }),
0x736d => Some(unsafe { transmute(0x9f3eu32) }),
0x736e => Some(unsafe { transmute(0x9f4au32) }),
0x736f => Some(unsafe { transmute(0x9f52u32) }),
0x7370 => Some(unsafe { transmute(0x9f54u32) }),
0x7371 => Some(unsafe { transmute(0x9f63u32) }),
0x7372 => Some(unsafe { transmute(0x9f5fu32) }),
0x7373 => Some(unsafe { transmute(0x9f60u32) }),
0x7374 => Some(unsafe { transmute(0x9f61u32) }),
0x7375 => Some(unsafe { transmute(0x9f66u32) }),
0x7376 => Some(unsafe { transmute(0x9f67u32) }),
0x7377 => Some(unsafe { transmute(0x9f6cu32) }),
0x7378 => Some(unsafe { transmute(0x9f6au32) }),
0x7379 => Some(unsafe { transmute(0x9f77u32) }),
0x737a => Some(unsafe { transmute(0x9f72u32) }),
0x737b => Some(unsafe { transmute(0x9f76u32) }),
0x737c => Some(unsafe { transmute(0x9f95u32) }),
0x737d => Some(unsafe { transmute(0x9f9cu32) }),
0x737e => Some(unsafe { transmute(0x9fa0u32) }),
0x7421 => Some(unsafe { transmute(0x582fu32) }),
0x7422 => Some(unsafe { transmute(0x69c7u32) }),
0x7423 => Some(unsafe { transmute(0x9059u32) }),
0x7424 => Some(unsafe { transmute(0x7464u32) }),
0x7425 => Some(unsafe { transmute(0x51dcu32) }),
0x7426 => Some(unsafe { transmute(0x7199u32) }),
_ => None
}
}
| 189
|
pub fn get_cpu_utilization() -> f64 {
use std::env;
env::var("BELLMAN_CPU_UTILIZATION")
.and_then(|v| match v.parse() {
Ok(val) => Ok(val),
Err(_) => {
error!("Invalid BELLMAN_CPU_UTILIZATION! Defaulting to 0...");
Ok(0f64)
}
})
.unwrap_or(0f64)
.max(0f64)
.min(1f64)
}
| 190
|
fn parse_peers_str(peers_str: &str) -> AppResult<Vec<Peer>> {
let peers_str: Vec<&str> = peers_str.split(",").collect();
let peers: Vec<Peer> = peers_str
.into_iter()
.map(|it| {
let peer = it.parse();
peer.unwrap()
})
.collect();
Ok(peers)
}
| 191
|
pub fn semaphore() -> &'static Semaphore {
SEMAPHORE.get_or_init(|| Semaphore::new(*pool_connection_number()))
}
| 192
|
extern fn QScroller_scrollerPropertiesChanged_signal_connect_cb_0(rsfptr:fn(QScrollerProperties), arg0: *mut c_void) {
println!("{}:{}", file!(), line!());
let rsarg0 = QScrollerProperties::inheritFrom(arg0 as u64);
rsfptr(rsarg0);
}
| 193
|
fn main() -> ! {
let p = stm32::Peripherals::take().unwrap();
let gpio_a = p.GPIOA.split();
let btn_a = gpio_a.pa4.into_pull_up_input();
let btn_b = gpio_a.pa10.into_pull_up_input();
let gpio_b = p.GPIOB.split();
let gpio_c = p.GPIOC.split();
let mut r = gpio_b.pb4.into_push_pull_output();
let mut g = gpio_b.pb3.into_push_pull_output();
let mut b = gpio_c.pc7.into_push_pull_output();
let rcc = p.RCC.constrain();
let clocks = rcc.cfgr.freeze();
let i2c = stm32f4xx_hal::i2c::I2c::i2c1(
p.I2C1,
(
gpio_b.pb8.into_alternate_af4_open_drain(),
gpio_b.pb9.into_alternate_af4_open_drain(),
),
stm32f4xx_hal::time::KiloHertz(400).into(),
clocks,
);
let interface = I2CDIBuilder::new().init(i2c);
let mut disp: Screen = ssd1306::Builder::new().connect(interface).into();
disp.init().unwrap();
disp.flush().unwrap();
let mut i = 0u8;
set_led(i, &mut r, &mut g, &mut b);
set_screen(i, &mut disp);
loop {
asm::delay(2_000_000);
let a_pressed = btn_a.is_high().unwrap();
let b_pressed = btn_b.is_high().unwrap();
if a_pressed == b_pressed {
continue;
}
if btn_a.is_high().unwrap() {
i += 1;
}
if btn_b.is_high().unwrap() {
if i == 0 {
i = 6;
} else {
i -= 1;
}
}
if i > 6 {
i = 0;
}
set_led(i, &mut r, &mut g, &mut b);
set_screen(i, &mut disp);
}
}
| 194
|
fn enhance(old: &Matrix<bool>, rules: &HashMap<Matrix<bool>, Matrix<bool>>) -> Matrix<bool> {
if old.rows % 2 == 0 {
let old_chunks = old.rows / 2;
let new_grid_size = old_chunks * 3;
let mut new_grid = Matrix::new_square(new_grid_size, false);
for chunk_y in 0..old_chunks {
for chunk_x in 0..old_chunks {
let old_chunk = old.slice(chunk_x*2..chunk_x*2 + 2, chunk_y*2..chunk_y*2 + 2);
let res = &rules[&old_chunk];
new_grid.set_slice(&(chunk_x*3, chunk_y*3), &res);
}
}
new_grid
} else {
assert_eq!(0, old.rows % 3);
let old_chunks = old.rows / 3;
let new_grid_size = old_chunks * 4;
let mut new_grid = Matrix::new_square(new_grid_size, false);
for chunk_y in 0..old_chunks {
for chunk_x in 0..old_chunks {
let old_chunk = old.slice(chunk_x*3..chunk_x*3 + 3, chunk_y*3..chunk_y*3 + 3);
let res = &rules[&old_chunk];
new_grid.set_slice(&(chunk_x*4, chunk_y*4), &res);
}
}
new_grid
}
}
| 195
|
pub fn write_varint7(buf: &mut Vec<u8>, i: i8) -> usize {
write_uint8(buf, (i as u8) ^ 0x80)
}
| 196
|
unsafe fn near_heap_ultimate_root_ptr<T, F: Fn(&T, &T) -> bool>(mut root: *mut T, order: usize, f: F) -> *mut T {
if order > 1 { for &child_root in &[root.offset(-(leo.get_unchecked(order - 2) + 1)), root.offset(-1)] {
if f(&*root, &*child_root) { root = child_root; }
} }
root
}
| 197
|
fn draw_body<Message, B>(
renderer: &mut Renderer<B>,
body: &Element<'_, Message, Renderer<B>>,
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
style: &Style,
) -> (Primitive, mouse::Interaction)
where
B: Backend + backend::Text,
{
let mut body_children = layout.children();
let body_background = Primitive::Quad {
bounds: layout.bounds(),
background: style.body_background,
border_radius: 0.0,
border_width: 0.0,
border_color: Color::TRANSPARENT,
};
let (body, mouse_interaction) = body.draw(
renderer,
&Defaults {
text: defaults::Text {
color: style.body_text_color,
},
},
body_children
.next()
.expect("Graphics: Layout should have a body content layout"),
cursor_position,
viewport,
);
(
Primitive::Group {
primitives: vec![body_background, body],
},
mouse_interaction,
)
}
| 198
|
fn main() {
module4::blah::doit();
foo_();
let _ = Bar;
}
| 199
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.