From: Kostya Shishkov Date: Tue, 7 May 2024 16:13:19 +0000 (+0200) Subject: aac: clear M/S flags X-Git-Url: https://git.nihav.org/?p=nihav.git;a=commitdiff_plain;h=refs%2Fheads%2Fmaster;hp=e12dabcd04fc59677660fce8fc9437931d141e93 aac: clear M/S flags --- diff --git a/nihav-acorn/Cargo.toml b/nihav-acorn/Cargo.toml new file mode 100644 index 0000000..0372971 --- /dev/null +++ b/nihav-acorn/Cargo.toml @@ -0,0 +1,38 @@ +[package] +name = "nihav_acorn" +version = "0.1.0" +authors = ["Kostya Shishkov "] +edition = "2018" + +[dependencies.nihav_core] +path = "../nihav-core" + +[dependencies.nihav_codec_support] +path = "../nihav-codec-support" + +[features] +default = ["all_decoders", "all_demuxers", "all_packetisers"] + +all_decoders = ["all_video_decoders", "all_audio_decoders"] +all_video_decoders = ["decoder_movinglines", "decoder_movingblocks", "decoder_movingblockshq", "decoder_linepack", "decoder_rawvideo"] +all_audio_decoders = ["decoder_rawaudio"] +decoders = [] + +decoder_movinglines = ["decoders"] +decoder_movingblocks = ["decoders"] +decoder_movingblockshq = ["decoders"] +decoder_linepack = ["decoders"] +decoder_rawvideo = ["decoders"] + +decoder_rawaudio = ["decoders"] + +all_demuxers = ["demuxer_armovie"] +demuxers = [] + +demuxer_armovie = ["demuxers"] + +all_packetisers = ["packetiser_cinepak", "packetiser_msvideo1"] +packetisers = [] + +packetiser_cinepak = ["packetisers"] +packetiser_msvideo1 = ["packetisers"] \ No newline at end of file diff --git a/nihav-acorn/src/codecs/linepack.rs b/nihav-acorn/src/codecs/linepack.rs new file mode 100644 index 0000000..0311e8b --- /dev/null +++ b/nihav-acorn/src/codecs/linepack.rs @@ -0,0 +1,314 @@ +use nihav_core::codecs::*; +use nihav_core::io::byteio::*; + +use super::RGB555_FORMAT; +use super::yuvtab::YUV2RGB; + +#[derive(Default)] +struct LinePackDecoder { + info: NACodecInfoRef, + cur_frm: Vec, + prev_frm: Vec, + width: usize, + is_yuv: bool, +} + +impl LinePackDecoder { + fn new() -> Self { Self::default() } +} + +impl NADecoder for LinePackDecoder { + fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { + let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB555_FORMAT)); + self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); + self.cur_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.prev_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.width = vinfo.get_width(); + if let Some(edata) = info.get_extradata() { + for triplet in edata.windows(3) { + if triplet == b"YUV" { + self.is_yuv = true; + break; + } + } + } + Ok(()) + } else { + Err(DecoderError::InvalidData) + } + } + fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { + let src = pkt.get_buffer(); + validate!(src.len() > 2 && (src.len() & 1) == 0); + let mut mr = MemoryReader::new_read(&src); + let mut br = ByteReader::new(&mut mr); + + let mut is_intra = true; + let mut dpos = 0; + while dpos < self.cur_frm.len() { + let val = br.read_u16le()?; + if (val & 0x8000) == 0 { // raw pixel + self.cur_frm[dpos] = val; + dpos += 1; + } else { + let op = (val >> 12) & 7; + match op { + 0 => { // skip + let len = (val & 0xFFF) as usize; + validate!(dpos + len <= self.cur_frm.len()); + self.cur_frm[dpos..][..len].copy_from_slice(&self.prev_frm[dpos..][..len]); + dpos += len; + is_intra = false; + }, + 1 => { // motion + let dx = (( val & 7) as isize) - 4; + let dy = (((val >> 3) & 7) as isize) - 4; + let len = ((val >> 6) & 0x3F) as usize; + validate!(dpos + len <= self.cur_frm.len()); + if dx == 0 && dy == 0 { // previous line + validate!(dpos >= self.width); + for _ in 0..len { + self.cur_frm[dpos] = self.cur_frm[dpos - self.width]; + dpos += 1; + } + } else { + let offset = (dpos as isize) + dx + dy * (self.width as isize); + validate!(offset >= 0); + let offset = offset as usize; + validate!(offset + len <= self.prev_frm.len()); + self.cur_frm[dpos..][..len].copy_from_slice(&self.prev_frm[offset..][..len]); + dpos += len; + is_intra = false; + } + }, + 2 => { // run + let len = (val & 0xFFF) as usize; + validate!(dpos + len <= self.cur_frm.len()); + let pix = br.read_u16le()?; + for _ in 0..len { + self.cur_frm[dpos] = pix; + dpos += 1; + } + }, + 3 => { // raw + let len = (val & 0xFFF) as usize; + validate!(dpos + len <= self.cur_frm.len()); + for _ in 0..len { + self.cur_frm[dpos] = br.read_u16le()?; + dpos += 1; + } + }, + 4 => { // four-colour pattern + let len = (val & 0xFF) as usize; + validate!(dpos + len <= self.cur_frm.len()); + let clrs = [ + br.read_u16le()?, + br.read_u16le()?, + br.read_u16le()?, + br.read_u16le()? + ]; + let mut mask = 0; + let mut pos = 8; + + for _i in 0..len { + if pos == 8 { + mask = br.read_u16le()? as usize; + pos = 0; + } + self.cur_frm[dpos] = clrs[mask & 3]; + dpos += 1; + mask >>= 2; + pos += 1; + } + }, + 5 => { // interleaved + let len = (val & 0xFFF) as usize; + validate!(dpos + len * 2 <= self.cur_frm.len()); + let clrs = [ + br.read_u16le()?, + br.read_u16le()? + ]; + for _ in 0..len { + self.cur_frm[dpos] = clrs[0]; + dpos += 1; + self.cur_frm[dpos] = clrs[1]; + dpos += 1; + } + }, + _ => return Err(DecoderError::NotImplemented), + } + } + } + + let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; + let mut buf = bufinfo.get_vbuf16().unwrap(); + let stride = buf.get_stride(0); + let data = buf.get_data_mut().unwrap(); + + for (dline, sline) in data.chunks_exact_mut(stride) + .zip(self.cur_frm.chunks_exact(self.width)) { + dline[..self.width].copy_from_slice(sline); + } + if self.is_yuv { + for el in data.iter_mut() { + *el = YUV2RGB[(*el as usize) & 0x7FFF]; + } + } + + std::mem::swap(&mut self.cur_frm, &mut self.prev_frm); + + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo); + frm.set_keyframe(is_intra); + frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P }); + Ok(frm.into_ref()) + } + fn flush(&mut self) { + for el in self.cur_frm.iter_mut() { + *el = 0; + } + for el in self.prev_frm.iter_mut() { + *el = 0; + } + } +} + +impl NAOptionHandler for LinePackDecoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub fn get_decoder() -> Box { + Box::new(LinePackDecoder::new()) +} + +#[derive(Default)] +struct LinePackPacketiser { + stream: Option, + buf: Vec, + end: usize, + frameno: u32, + intra: bool, + pos: usize, + img_size: usize, +} + +impl LinePackPacketiser { + fn new() -> Self { Self::default() } +} + +impl NAPacketiser for LinePackPacketiser { + fn attach_stream(&mut self, stream: NAStreamRef) { + let vinfo = stream.get_info().get_properties().get_video_info().unwrap(); + self.img_size = vinfo.width * vinfo.height; + self.stream = Some(stream); + } + fn add_data(&mut self, src: &[u8]) -> bool { + self.buf.extend_from_slice(src); + self.buf.len() < (1 << 10) + } + fn parse_stream(&mut self, id: u32) -> DecoderResult { + if let Some(ref stream) = self.stream { + let mut stream = NAStream::clone(stream); + stream.id = id; + Ok(stream.into_ref()) + } else { + Err(DecoderError::MissingReference) + } + } + fn skip_junk(&mut self) -> DecoderResult { + Err(DecoderError::NotImplemented) + } + fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult> { + if self.buf.len() < self.end { + return Ok(None); + } + + if self.end == 0 { + self.intra = true; + self.pos = 0; + } + + while self.end + 2 <= self.buf.len() && self.pos < self.img_size { + let val = u16::from(self.buf[self.end + 1]) * 256 + u16::from(self.buf[self.end]); + self.end += 2; + + if (val & 0x8000) == 0 { + self.pos += 1; + } else { + let op = (val >> 12) & 7; + let common_len = (val & 0xFFF) as usize; + self.pos += match op { + 0 => common_len, // skip size + 1 => ((val >> 6) & 0x3F) as usize, // motion size + 2 => common_len, // run + 3 => common_len, // raw + 4 => common_len & 0xFF, // four-colour pattern + 5 => common_len * 2, // interleaved + _ => 0, // ??? + }; + self.end += match op { + 2 => 2, // run value + 3 => common_len * 2, // raw values + 4 => 8 + ((common_len & 0xFF) + 7) / 8 * 2, // 4 colours + masks + 5 => 4, // two values + _ => 0, + }; + if (op == 0) || (op == 1 && (val & 0x3F) != 0x24) || (op == 2) { + self.intra = false; + } + } + } + + if self.pos >= self.img_size && self.end <= self.buf.len() { + let mut data = Vec::with_capacity(self.end); + data.extend_from_slice(&self.buf[..self.end]); + self.buf.drain(..self.end); + let ts = NATimeInfo::new(Some(u64::from(self.frameno)), None, None, stream.tb_num, stream.tb_den); + self.end = 0; + self.frameno += 1; + + return Ok(Some(NAPacket::new(stream, ts, self.intra, data))); + } + + Ok(None) + } + fn reset(&mut self) { + self.buf.clear(); + self.end = 0; + } + fn bytes_left(&self) -> usize { self.buf.len() } +} + +pub fn get_packetiser() -> Box { + Box::new(LinePackPacketiser::new()) +} + +#[cfg(test)] +mod test { + use nihav_core::codecs::{RegisteredDecoders, RegisteredPacketisers}; + use nihav_core::demuxers::RegisteredRawDemuxers; + use nihav_codec_support::test::dec_video::*; + use crate::*; + #[test] + fn test_linepack() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Cine Clips by Oregan Software Developments + test_decoding_raw("armovie", "linepack", "assets/Acorn/COLOURPLUS", Some(5), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0x373eb9d6, 0xc52d7abd, 0xe1f3631b, 0xf509cb16], + [0x373eb9d6, 0xc52d7abd, 0xe1f3631b, 0xf509cb16], + [0x373eb9d6, 0xc52d7abd, 0xe1f3631b, 0xf509cb16], + [0x373eb9d6, 0xc52d7abd, 0xe1f3631b, 0xf509cb16], + [0x373eb9d6, 0xc52d7abd, 0xe1f3631b, 0xf509cb16], + [0x32033527, 0x3073331b, 0x83942239, 0x57f975ee]])); + } +} diff --git a/nihav-acorn/src/codecs/mod.rs b/nihav-acorn/src/codecs/mod.rs new file mode 100644 index 0000000..232e162 --- /dev/null +++ b/nihav-acorn/src/codecs/mod.rs @@ -0,0 +1,93 @@ +use nihav_core::codecs::*; + +#[cfg(debug_assertions)] +macro_rules! validate { + ($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DecoderError::InvalidData); } }; +} +#[cfg(not(debug_assertions))] +macro_rules! validate { + ($a:expr) => { if !$a { return Err(DecoderError::InvalidData); } }; +} + +#[allow(dead_code)] +const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, + comp_info: [ + Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 0, comp_offs: 0, next_elem: 2 }), + Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 5, comp_offs: 0, next_elem: 2 }), + Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }), + None, None], + elem_size: 2, be: false, alpha: false, palette: false }; + +#[allow(dead_code)] +mod yuvtab; + +#[cfg(feature="decoder_movinglines")] +mod movinglines; +#[cfg(feature="decoder_movingblocks")] +mod movingblocks; +#[cfg(feature="decoder_movingblockshq")] +mod movingblockshq; +#[cfg(feature="decoder_rawvideo")] +mod rawvideo; + +#[cfg(feature="decoder_linepack")] +mod linepack; + +#[cfg(feature="decoder_rawaudio")] +mod rawaudio; + +const ACORN_CODECS: &[DecoderInfo] = &[ +#[cfg(feature="decoder_rawvideo")] + DecoderInfo { name: "arm_rawvideo", get_decoder: rawvideo::get_decoder }, +#[cfg(feature="decoder_movinglines")] + DecoderInfo { name: "movinglines", get_decoder: movinglines::get_decoder }, +#[cfg(feature="decoder_movingblocks")] + DecoderInfo { name: "movingblocks", get_decoder: movingblocks::get_decoder }, +#[cfg(feature="decoder_movingblockshq")] + DecoderInfo { name: "movingblockshq", get_decoder: movingblockshq::get_decoder }, + +#[cfg(feature="decoder_linepack")] + DecoderInfo { name: "linepack", get_decoder: linepack::get_decoder }, + +#[cfg(feature="decoder_rawaudio")] + DecoderInfo { name: "arm_rawaudio", get_decoder: rawaudio::get_decoder }, +]; + +/// Registers all available codecs provided by this crate. +pub fn acorn_register_all_decoders(rd: &mut RegisteredDecoders) { + for decoder in ACORN_CODECS.iter() { + rd.add_decoder(*decoder); + } +} + +#[cfg(any(feature="packetiser_cinepak", feature="packetiser_msvideo1"))] +mod wss_packetisers; + +const ACORN_PACKETISERS: &[PacketiserInfo] = &[ +#[cfg(feature="decoder_rawvideo")] + PacketiserInfo { name: "arm_rawvideo", get_packetiser: rawvideo::get_packetiser }, +#[cfg(feature="decoder_movinglines")] + PacketiserInfo { name: "movinglines", get_packetiser: movinglines::get_packetiser }, +#[cfg(feature="decoder_movingblocks")] + PacketiserInfo { name: "movingblocks", get_packetiser: movingblocks::get_packetiser }, +#[cfg(feature="decoder_movingblockshq")] + PacketiserInfo { name: "movingblockshq", get_packetiser: movingblockshq::get_packetiser }, + +#[cfg(feature="decoder_linepack")] + PacketiserInfo { name: "linepack", get_packetiser: linepack::get_packetiser }, + +#[cfg(feature="decoder_rawaudio")] + PacketiserInfo { name: "arm_rawaudio", get_packetiser: rawaudio::get_packetiser }, + +#[cfg(feature="packetiser_cinepak")] + PacketiserInfo { name: "cinepak", get_packetiser: wss_packetisers::get_packetiser_cinepak }, +#[cfg(feature="packetiser_msvideo1")] + PacketiserInfo { name: "msvideo1", get_packetiser: wss_packetisers::get_packetiser_msvideo1 }, +]; + +/// Registers all available packetisers provided by this crate. +pub fn acorn_register_all_packetisers(rp: &mut RegisteredPacketisers) { + for pkt in ACORN_PACKETISERS.iter() { + rp.add_packetiser(*pkt); + } +} diff --git a/nihav-acorn/src/codecs/movingblocks.rs b/nihav-acorn/src/codecs/movingblocks.rs new file mode 100644 index 0000000..197d646 --- /dev/null +++ b/nihav-acorn/src/codecs/movingblocks.rs @@ -0,0 +1,464 @@ +use nihav_core::codecs::*; +use nihav_core::io::bitreader::*; + +use super::RGB555_FORMAT; +use super::yuvtab::YUV2RGB; + +fn get_mv(br: &mut BitReader, is_4x4: bool) -> DecoderResult<((i8, i8), bool)> { + match br.read(2)? { + 0b00 => Ok(((0, 0), false)), + 0b10 => Ok((MV_TAB1[br.read(3)? as usize], false)), + 0b01 => Ok((MV_TAB2[br.read(4)? as usize], false)), + _ => { + let idx = br.read(6)? as usize; + if idx < MV_TAB3.len() { + Ok((MV_TAB3[idx], false)) + } else { + let idx = idx - MV_TAB3.len(); + if is_4x4 { + Ok((MV_TAB_SELF_4X4[idx], true)) + } else { + Ok((MV_TAB_SELF_2X2[idx], true)) + } + } + }, + } +} + +#[derive(Default)] +struct MBDecoder { + info: NACodecInfoRef, + cur_frm: Vec, + prev_frm: Vec, + width: usize, + height: usize, + is_yuv: bool, +} + +impl MBDecoder { + fn new() -> Self { Self::default() } +} + +impl NADecoder for MBDecoder { + fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { + let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB555_FORMAT)); + self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); + self.cur_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.prev_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.width = vinfo.get_width(); + self.height = vinfo.get_height(); + validate!((self.width & 3) == 0); + validate!((self.height & 3) == 0); + if let Some(edata) = info.get_extradata() { + for triplet in edata.windows(3) { + if triplet == b"YUV" { + self.is_yuv = true; + break; + } + } + } + Ok(()) + } else { + Err(DecoderError::InvalidData) + } + } + fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { + let src = pkt.get_buffer(); + validate!(src.len() > 2); + let mut br = BitReader::new(&src, BitReaderMode::LE); + + let mut is_intra = true; + let mut dpos = 0; + for _y in (0..self.height).step_by(4) { + for x in (0..self.width).step_by(4) { + if br.read_bool()? { // raw block + let mut luma = [0; 16]; + for el in luma.iter_mut() { + *el = br.read(5)? as u16; + } + let uv = (br.read(10)? as u16) << 5; + for (drow, yrow) in self.cur_frm[dpos + x..].chunks_mut(self.width) + .zip(luma.chunks_exact(4)) { + for (dst, &src_y) in drow.iter_mut().zip(yrow.iter()) { + *dst = src_y | uv; + } + } + } else if br.read_bool()? { // split block + let offsets = [dpos + x, dpos + x + 2, dpos + x + self.width * 2, dpos + x + 2 + self.width * 2]; + for &offset in offsets.iter() { + if br.read_bool()? { // raw subblock + let mut luma = [0; 4]; + for el in luma.iter_mut() { + *el = br.read(5)? as u16; + } + let uv = (br.read(10)? as u16) << 5; + for (drow, yrow) in self.cur_frm[offset..].chunks_mut(self.width) + .zip(luma.chunks_exact(2)) { + for (dst, &src_y) in drow.iter_mut().zip(yrow.iter()) { + *dst = src_y | uv; + } + } + } else { // MV subblock + let ((dx, dy), copy_cur) = get_mv(&mut br, false)?; + let src_pos = (offset as isize) + (dx as isize) + (dy as isize) * (self.width as isize); + validate!(src_pos >= 0); + let src_pos = src_pos as usize; + validate!(src_pos + 2 + self.width <= self.cur_frm.len()); + if !copy_cur { + let src = &self.prev_frm[src_pos..]; + for (drow, srow) in self.cur_frm[offset..].chunks_mut(self.width) + .zip(src.chunks(self.width)).take(2) { + drow[..2].copy_from_slice(&srow[..2]); + } + is_intra = false; + } else { + let mut ooff = offset; + let mut soff = src_pos; + for _ in 0..2 { + for i in 0..2 { + self.cur_frm[ooff + i] = self.cur_frm[soff + i]; + } + ooff += self.width; + soff += self.width; + } + } + } + } + } else { // MV block + let ((dx, dy), copy_cur) = get_mv(&mut br, true)?; + let src_pos = ((dpos + x) as isize) + (dx as isize) + (dy as isize) * (self.width as isize); + validate!(src_pos >= 0); + let src_pos = src_pos as usize; + validate!(src_pos + 4 + self.width * 3 <= self.cur_frm.len()); + if !copy_cur { + let src = &self.prev_frm[src_pos..]; + for (drow, srow) in self.cur_frm[dpos + x..].chunks_mut(self.width) + .zip(src.chunks(self.width)).take(4) { + drow[..4].copy_from_slice(&srow[..4]); + } + is_intra = false; + } else { + let mut ooff = dpos + x; + let mut soff = src_pos; + for _ in 0..4 { + for i in 0..4 { + self.cur_frm[ooff + i] = self.cur_frm[soff + i]; + } + ooff += self.width; + soff += self.width; + } + } + } + } + dpos += self.width * 4; + } + + let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; + let mut buf = bufinfo.get_vbuf16().unwrap(); + let stride = buf.get_stride(0); + let data = buf.get_data_mut().unwrap(); + + for (dline, sline) in data.chunks_exact_mut(stride) + .zip(self.cur_frm.chunks_exact(self.width)) { + dline[..self.width].copy_from_slice(sline); + } + if self.is_yuv { + for el in data.iter_mut() { + *el = YUV2RGB[(*el as usize) & 0x7FFF]; + } + } + + std::mem::swap(&mut self.cur_frm, &mut self.prev_frm); + + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo); + frm.set_keyframe(is_intra); + frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P }); + Ok(frm.into_ref()) + } + fn flush(&mut self) { + for el in self.cur_frm.iter_mut() { + *el = 0; + } + for el in self.prev_frm.iter_mut() { + *el = 0; + } + } +} + +impl NAOptionHandler for MBDecoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub fn get_decoder() -> Box { + Box::new(MBDecoder::new()) +} + +#[derive(Default,Debug,PartialEq)] +enum ParseState { + #[default] + Start, + BlockMode, + Subblock(u8), +} + +#[derive(Default)] +struct MBPacketiser { + stream: Option, + buf: Vec, + frameno: u32, + intra: bool, + bitpos: usize, + x: usize, + y: usize, + state: ParseState, + width: usize, + height: usize, + csizes: Vec, +} + +impl MBPacketiser { + fn new() -> Self { Self::default() } + fn peek_bits(&mut self, nbits: u8) -> Option { + if self.bitpos + usize::from(nbits) <= self.buf.len() * 8 { + let tail = (self.bitpos as u8) & 7; + let mask = 0xFF >> (8 - nbits); + let cw = if tail + nbits <= 8 { + u16::from(self.buf[self.bitpos >> 3]) + } else { + let b0 = self.buf[self.bitpos >> 3]; + let b1 = self.buf[(self.bitpos >> 3) + 1]; + u16::from(b0) + u16::from(b1) * 256 + }; + Some(((cw >> tail) as u8) & mask) + } else { + None + } + } + fn skip_bits(&mut self, nbits: u8) { + self.bitpos += usize::from(nbits); + } + fn advance_block(&mut self) { + self.x += 4; + if self.x == self.width { + self.x = 0; + self.y += 4; + } + } +} + +impl NAPacketiser for MBPacketiser { + fn attach_stream(&mut self, stream: NAStreamRef) { + let vinfo = stream.get_info().get_properties().get_video_info().unwrap(); + self.width = vinfo.width; + self.height = vinfo.height; + self.stream = Some(stream); + } + fn add_data(&mut self, src: &[u8]) -> bool { + self.csizes.push(src.len()); + self.buf.extend_from_slice(src); + self.buf.len() < (1 << 10) + } + fn parse_stream(&mut self, id: u32) -> DecoderResult { + if let Some(ref stream) = self.stream { + let mut stream = NAStream::clone(stream); + stream.id = id; + Ok(stream.into_ref()) + } else { + Err(DecoderError::MissingReference) + } + } + fn skip_junk(&mut self) -> DecoderResult { + Err(DecoderError::NotImplemented) + } + fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult> { + if self.buf.len() * 8 < self.bitpos { + return Ok(None); + } + + if self.state == ParseState::Start { + self.intra = true; + self.x = 0; + self.y = 0; + self.state = ParseState::BlockMode; + self.bitpos = 0; + } + + while self.y < self.height { + match self.state { + ParseState::Start => unreachable!(), + ParseState::BlockMode => { + if let Some(mode) = self.peek_bits(2) { + match mode { + 0b10 => { // subblocks + self.skip_bits(2); + self.state = ParseState::Subblock(0); + }, + 0b00 => { // MV block + if let Some(ret) = self.peek_bits(4) { + let mv_mode = ret >> 2; + match mv_mode { + 0b10 => self.skip_bits(3), + 0b01 => self.skip_bits(4), + 0b11 => self.skip_bits(6), + _ => {}, + } + } else { + return Ok(None); + } + self.skip_bits(4); // block mode + MV mode + self.advance_block(); + }, + _ => { // raw block + self.skip_bits(1); + self.skip_bits(90); // 16 Y + UV 5-bit samples + self.advance_block(); + }, + } + } else { + return Ok(None); + } + }, + ParseState::Subblock(sblk) => { + if let Some(mode) = self.peek_bits(1) { + if mode == 1 { // raw subblock + self.skip_bits(1); + self.skip_bits(30); // 4 Y + UV 5-bit samples + } else { // MV subblock + if let Some(ret) = self.peek_bits(3) { + let mv_mode = ret >> 1; + match mv_mode { + 0b10 => self.skip_bits(3), + 0b01 => self.skip_bits(4), + 0b11 => self.skip_bits(6), + _ => {}, + } + } else { + return Ok(None); + } + self.skip_bits(3); // block mode + MV mode + } + self.state = if sblk < 3 { + ParseState::Subblock(sblk + 1) + } else { + self.advance_block(); + ParseState::BlockMode + }; + } else { + return Ok(None); + } + }, + } + } + + let size = (self.bitpos + 7) >> 3; + + let mut data = Vec::with_capacity(size); + data.extend_from_slice(&self.buf[..size]); + self.buf.drain(..size); + + if !self.csizes.is_empty() { + if self.csizes[0] >= size { + self.csizes[0] -= size; + // skip possible padding at the end of chunk + if self.csizes[0] == 1 { + self.buf.remove(0); + self.csizes[0] -= 1; + } + if self.csizes[0] == 0 { + self.csizes.remove(0); + } + } else { + println!("ran past input chunk end!"); + self.csizes.clear(); + } + } + + let ts = NATimeInfo::new(Some(u64::from(self.frameno)), None, None, stream.tb_num, stream.tb_den); + self.frameno += 1; + + self.state = ParseState::Start; + + Ok(Some(NAPacket::new(stream, ts, self.intra, data))) + } + fn reset(&mut self) { + self.buf.clear(); + self.bitpos = 0; + self.state = ParseState::Start; + } + fn bytes_left(&self) -> usize { self.buf.len() } +} + +pub fn get_packetiser() -> Box { + Box::new(MBPacketiser::new()) +} + +#[cfg(test)] +mod test { + use nihav_core::codecs::{RegisteredDecoders, RegisteredPacketisers}; + use nihav_core::demuxers::RegisteredRawDemuxers; + use nihav_codec_support::test::dec_video::*; + use crate::*; + #[test] + fn test_movingblocks() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Cine Clips by Oregan Software Developments + test_decoding_raw("armovie", "movingblocks", "assets/Acorn/CANWHARF", Some(3), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0x3d499be9, 0x8f57aa2d, 0x7f539425, 0x18fe3f8e], + [0xb937773a, 0xe629b2f3, 0x78b42f33, 0x62f1640f], + [0x20c08d46, 0x2d64123d, 0xae74f85c, 0x8bead127], + [0xa54e3362, 0xb224cf10, 0x6ebd5d97, 0xc8a46c39]])); + } +} + +const MV_TAB1: [(i8, i8); 8] = [ + (-1, -1), (0, -1), (1, -1), + (-1, 0), (1, 0), + (-1, 1), (0, 1), (1, 1) +]; + +const MV_TAB2: [(i8, i8); 16] = [ + (-2, -2), (-1, -2), (0, -2), (1, -2), (2, -2), + (-2, -1), ( 2, -1), + (-2, 0), ( 2, 0), + (-2, 1), ( 2, 1), + (-2, 2), (-1, 2), (0, 2), (1, 2), (2, 2) +]; + +const MV_TAB3: [(i8, i8); 56] = [ + (-4, -4), (-3, -4), (-2, -4), (-1, -4), (0, -4), (1, -4), (2, -4), (3, -4), (4, -4), + (-4, -3), ( 4, -3), + (-4, -2), ( 4, -2), + (-4, -1), ( 4, -1), + (-4, 0), ( 4, 0), + (-4, 1), ( 4, 1), + (-4, 2), ( 4, 2), + (-4, 3), ( 4, 3), + (-4, 4), (-3, 4), (-2, 4), (-1, 4), (0, 4), (1, 4), (2, 4), (3, 4), (4, 4), + (-3, -3), (-2, -3), (-1, -3), ( 0, -3), (1, -3), (2, -3), (3, -3), + (-3, -2), ( 3, -2), + (-3, -1), ( 3, -1), + (-3, 0), ( 3, 0), + (-3, 1), ( 3, 1), + (-3, 2), ( 3, 2), + (-3, 3), (-2, 3), (-1, 3), ( 0, 3), (1, 3), (2, 3), (3, 3) +]; + +const MV_TAB_SELF_2X2: [(i8, i8); 8] = [ + (-2, -2), (-1, -2), ( 0, -2), (1, -2), (2, -2), + (-2, -1), (-2, 0), (-3, 0), +]; +const MV_TAB_SELF_4X4: [(i8, i8); 8] = [ + (-2, -4), (-1, -4), ( 0, -4), (1, -4), (2, -4), + (-4, 0), (-4, -1), (-4, -2) +]; diff --git a/nihav-acorn/src/codecs/movingblockshq.rs b/nihav-acorn/src/codecs/movingblockshq.rs new file mode 100644 index 0000000..d271ec5 --- /dev/null +++ b/nihav-acorn/src/codecs/movingblockshq.rs @@ -0,0 +1,606 @@ +use nihav_core::codecs::*; +use nihav_core::io::bitreader::*; +use nihav_core::io::codebook::*; + +use super::RGB555_FORMAT; +use super::yuvtab::YUV2RGB; + +struct DeltaCodebook { + cb: Codebook, +} + +fn map_idx(idx: usize) -> u16 { + idx as u16 +} + +impl Default for DeltaCodebook { + fn default() -> Self { + let mut cr = TableCodebookDescReader::new(&LUMA_CODES, &LUMA_BITS, map_idx); + let cb = Codebook::new(&mut cr, CodebookMode::LSB).unwrap(); + Self { cb } + } +} + +fn get_mv(br: &mut BitReader, is_4x4: bool) -> DecoderResult<((i8, i8), bool)> { + match br.read(2)? { + 0b00 => Ok((MV_TAB1[br.read(3)? as usize], false)), + 0b10 => Ok((MV_TAB2[br.read(4)? as usize], false)), + 0b01 => { + let idx = br.read(5)? as usize; + let self_tab = if is_4x4 { &MV_TAB_SELF_4X4 } else { &MV_TAB_SELF_2X2 }; + if idx < self_tab.len() { + Ok((self_tab[idx], true)) + } else { + Ok((MV_TAB3[idx - self_tab.len()], false)) + } + }, + 0b11 => { + let idx = br.read(8)? as usize; + validate!(idx < MV_TAB8.len()); + Ok((MV_TAB8[idx], false)) + }, + _ => unreachable!(), + } +} + +#[derive(Default)] +struct MBDecoder { + info: NACodecInfoRef, + cur_frm: Vec, + prev_frm: Vec, + width: usize, + height: usize, + is_yuv: bool, + cb: DeltaCodebook, +} + +impl MBDecoder { + fn new() -> Self { Self::default() } +} + +impl NADecoder for MBDecoder { + fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { + let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB555_FORMAT)); + self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); + self.cur_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.prev_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.width = vinfo.get_width(); + self.height = vinfo.get_height(); + validate!((self.width & 3) == 0); + validate!((self.height & 3) == 0); + self.is_yuv = true; + Ok(()) + } else { + Err(DecoderError::InvalidData) + } + } + fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { + let src = pkt.get_buffer(); + validate!(src.len() > 2); + let mut br = BitReader::new(&src, BitReaderMode::LE); + + let mut is_intra = true; + let mut dpos = 0; + let mut avg_y = 0; + for _y in (0..self.height).step_by(4) { + for x in (0..self.width).step_by(4) { + match br.read(2)? { + 0b00 => { // skip + for (dline, sline) in self.cur_frm[dpos + x..].chunks_mut(self.width) + .zip(self.prev_frm[dpos + x..].chunks(self.width)).take(4) { + dline[..4].copy_from_slice(&sline[..4]); + } + }, + 0b10 => { // MV + let ((dx, dy), copy_cur) = get_mv(&mut br, true)?; + let src_pos = ((dpos + x) as isize) + (dx as isize) + (dy as isize) * (self.width as isize); + validate!(src_pos >= 0); + let src_pos = src_pos as usize; + validate!(src_pos + 4 + self.width * 3 <= self.cur_frm.len()); + if !copy_cur { + let src = &self.prev_frm[src_pos..]; + for (drow, srow) in self.cur_frm[dpos + x..].chunks_mut(self.width) + .zip(src.chunks(self.width)).take(4) { + drow[..4].copy_from_slice(&srow[..4]); + } + is_intra = false; + } else { + let mut ooff = dpos + x; + let mut soff = src_pos; + for _ in 0..4 { + for i in 0..4 { + self.cur_frm[ooff + i] = self.cur_frm[soff + i]; + } + ooff += self.width; + soff += self.width; + } + } + }, + 0b01 => { // raw + let uv = (br.read(10)? as u16) << 5; + + let mut luma = [0; 16]; + for el in luma.iter_mut() { + *el = br.read_cb(&self.cb.cb)?; + } + let mut luma_sum = 0; + for row in (0..16).step_by(4) { + for col in 0..4 { + let pred_val = match (col, row) { + (0, 0) => avg_y, + (0, _) => luma[col + row - 4], + (_, 0) => luma[col - 1], + _ => (luma[col + row - 1] + luma[col + row - 4]) >> 1, + }; + luma[col + row] = (luma[col + row] + pred_val) & 0x1F; + luma_sum += luma[col + row]; + } + } + avg_y = luma_sum >> 4; + + for (drow, yrow) in self.cur_frm[dpos + x..].chunks_mut(self.width) + .zip(luma.chunks_exact(4)) { + for (dst, &src_y) in drow.iter_mut().zip(yrow.iter()) { + *dst = src_y | uv; + } + } + }, + _ => { // subdivision + let offsets = [dpos + x, dpos + x + 2, dpos + x + self.width * 2, dpos + x + 2 + self.width * 2]; + for &offset in offsets.iter() { + if br.read_bool()? { // MV + let ((dx, dy), copy_cur) = get_mv(&mut br, false)?; + let src_pos = (offset as isize) + (dx as isize) + (dy as isize) * (self.width as isize); + validate!(src_pos >= 0); + let src_pos = src_pos as usize; + validate!(src_pos + 2 + self.width <= self.cur_frm.len()); + if !copy_cur { + let src = &self.prev_frm[src_pos..]; + for (drow, srow) in self.cur_frm[offset..].chunks_mut(self.width) + .zip(src.chunks(self.width)).take(2) { + drow[..2].copy_from_slice(&srow[..2]); + } + is_intra = false; + } else { + let mut ooff = offset; + let mut soff = src_pos; + for _ in 0..2 { + for i in 0..2 { + self.cur_frm[ooff + i] = self.cur_frm[soff + i]; + } + ooff += self.width; + soff += self.width; + } + } + } else if br.read_bool()? { // raw + let uv = (br.read(10)? as u16) << 5; + + let mut luma = [0; 4]; + for el in luma.iter_mut() { + *el = br.read_cb(&self.cb.cb)?; + } + luma[0] = (luma[0] + avg_y) & 0x1F; + luma[1] = (luma[1] + luma[0]) & 0x1F; + luma[2] = (luma[2] + luma[0]) & 0x1F; + luma[3] = (luma[3] + ((luma[1] + luma[2]) >> 1)) & 0x1F; + avg_y = luma.iter().sum::() >> 2; + + self.cur_frm[offset] = luma[0] | uv; + self.cur_frm[offset + 1] = luma[1] | uv; + self.cur_frm[offset + self.width] = luma[2] | uv; + self.cur_frm[offset + self.width + 1] = luma[3] | uv; + } else { // skip + for (dline, sline) in self.cur_frm[offset..].chunks_mut(self.width) + .zip(self.prev_frm[offset..].chunks(self.width)).take(2) { + dline[..2].copy_from_slice(&sline[..2]); + } + } + } + }, + }; + } + dpos += self.width * 4; + } + + let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; + let mut buf = bufinfo.get_vbuf16().unwrap(); + let stride = buf.get_stride(0); + let data = buf.get_data_mut().unwrap(); + + for (dline, sline) in data.chunks_exact_mut(stride) + .zip(self.cur_frm.chunks_exact(self.width)) { + dline[..self.width].copy_from_slice(sline); + } + if self.is_yuv { + for el in data.iter_mut() { + *el = YUV2RGB[(*el as usize) & 0x7FFF]; + } + } + + std::mem::swap(&mut self.cur_frm, &mut self.prev_frm); + + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo); + frm.set_keyframe(is_intra); + frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P }); + Ok(frm.into_ref()) + } + fn flush(&mut self) { + for el in self.cur_frm.iter_mut() { + *el = 0; + } + for el in self.prev_frm.iter_mut() { + *el = 0; + } + } +} + +impl NAOptionHandler for MBDecoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub fn get_decoder() -> Box { + Box::new(MBDecoder::new()) +} + +#[derive(Default,Debug,PartialEq)] +enum ParseState { + #[default] + Start, + BlockMode, + Raw(u8), + Subblock(u8), + SubblockRaw(u8, u8), +} + +#[derive(Default)] +struct MBPacketiser { + stream: Option, + buf: Vec, + frameno: u32, + intra: bool, + bitpos: usize, + x: usize, + y: usize, + state: ParseState, + width: usize, + height: usize, + csizes: Vec, +} + +impl MBPacketiser { + fn new() -> Self { Self::default() } + fn peek_bits(&mut self, nbits: u8) -> Option { + if self.bitpos + usize::from(nbits) <= self.buf.len() * 8 { + let tail = (self.bitpos as u8) & 7; + let mask = 0xFF >> (8 - nbits); + let cw = if tail + nbits <= 8 { + u16::from(self.buf[self.bitpos >> 3]) + } else { + let b0 = self.buf[self.bitpos >> 3]; + let b1 = self.buf[(self.bitpos >> 3) + 1]; + u16::from(b0) + u16::from(b1) * 256 + }; + Some(((cw >> tail) as u8) & mask) + } else { + None + } + } + fn peek_code(&mut self) -> Option { + let mut cur_code = 0; + let mut avail_bits = 0; + let tail = self.bitpos & 7; + while (avail_bits < (9 + tail)) && (self.bitpos + avail_bits + 8 <= self.buf.len() * 8) { + cur_code |= u32::from(self.buf[(self.bitpos + avail_bits) >> 3]) << avail_bits; + avail_bits += 8; + } + if avail_bits <= tail { + return None; + } + let cur_code = (cur_code >> tail) as u16; + let avail_bits = (avail_bits - tail) as u8; + for (&code, &len) in LUMA_CODES.iter().zip(LUMA_BITS.iter()) { + if len <= avail_bits && (cur_code & ((1 << len) - 1)) == code { + return Some(len); + } + } + None + } + fn skip_bits(&mut self, nbits: u8) { + self.bitpos += usize::from(nbits); + } + fn advance_block(&mut self) { + self.x += 4; + if self.x == self.width { + self.x = 0; + self.y += 4; + } + } +} + +impl NAPacketiser for MBPacketiser { + fn attach_stream(&mut self, stream: NAStreamRef) { + let vinfo = stream.get_info().get_properties().get_video_info().unwrap(); + self.width = vinfo.width; + self.height = vinfo.height; + self.stream = Some(stream); + } + fn add_data(&mut self, src: &[u8]) -> bool { + self.csizes.push(src.len()); + self.buf.extend_from_slice(src); + self.buf.len() < (1 << 10) + } + fn parse_stream(&mut self, id: u32) -> DecoderResult { + if let Some(ref stream) = self.stream { + let mut stream = NAStream::clone(stream); + stream.id = id; + Ok(stream.into_ref()) + } else { + Err(DecoderError::MissingReference) + } + } + fn skip_junk(&mut self) -> DecoderResult { + Err(DecoderError::NotImplemented) + } + fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult> { + if self.buf.len() * 8 < self.bitpos { + return Ok(None); + } + + if self.state == ParseState::Start { + self.intra = true; + self.x = 0; + self.y = 0; + self.state = ParseState::BlockMode; + self.bitpos = 0; + } + + while self.y < self.height { + match self.state { + ParseState::Start => unreachable!(), + ParseState::BlockMode => { + if let Some(mode) = self.peek_bits(2) { + match mode { + 0b00 => { // skip + self.skip_bits(2); + self.intra = false; + self.advance_block(); + }, + 0b10 => { // MV block + if let Some(ret) = self.peek_bits(4) { + let mv_mode = ret >> 2; + match mv_mode { + 0b00 => self.skip_bits(3), + 0b10 => self.skip_bits(4), + 0b01 => self.skip_bits(5), + _ => self.skip_bits(8), + } + if mv_mode != 0b01 { + self.intra = false; + } + } else { + return Ok(None); + } + self.skip_bits(4); // block mode + MV mode + self.advance_block(); + }, + 0b11 => { // subblocks + self.skip_bits(2); + self.state = ParseState::Subblock(0); + }, + _ => { // raw block + self.skip_bits(2); + self.skip_bits(10); // UV + self.state = ParseState::Raw(0); + }, + } + } else { + return Ok(None); + } + }, + ParseState::Raw(coef) => { + if let Some(bits) = self.peek_code() { + self.skip_bits(bits); + } else { + return Ok(None); + } + self.state = if coef < 15 { + ParseState::Raw(coef + 1) + } else { + self.advance_block(); + ParseState::BlockMode + }; + }, + ParseState::Subblock(sblk) => { + if let Some(mode) = self.peek_bits(2) { + match mode { + 0b00 => { // skip + self.intra = false; + self.skip_bits(2); // subblock mode + }, + 0b10 => { // raw + self.skip_bits(2); // subblock mode + self.skip_bits(10); // UV + self.state = ParseState::SubblockRaw(sblk, 0); + continue; + }, + _ => { // MV + if let Some(ret) = self.peek_bits(3) { + let mv_mode = ret >> 1; + match mv_mode { + 0b00 => self.skip_bits(3), + 0b10 => self.skip_bits(4), + 0b01 => self.skip_bits(5), + _ => self.skip_bits(8), + } + if mv_mode != 0b01 { + self.intra = false; + } + self.skip_bits(3); // subblock mode + MV mode + } else { + return Ok(None); + } + }, + }; + self.state = if sblk < 3 { + ParseState::Subblock(sblk + 1) + } else { + self.advance_block(); + ParseState::BlockMode + }; + } else { + return Ok(None); + } + }, + ParseState::SubblockRaw(sblk, coef) => { + if let Some(bits) = self.peek_code() { + self.skip_bits(bits); + } else { + return Ok(None); + } + self.state = if coef < 3 { + ParseState::SubblockRaw(sblk, coef + 1) + } else if sblk < 3 { + ParseState::Subblock(sblk + 1) + } else { + self.advance_block(); + ParseState::BlockMode + }; + }, + } + } + + let size = (self.bitpos + 7) >> 3; + + let mut data = Vec::with_capacity(size); + data.extend_from_slice(&self.buf[..size]); + self.buf.drain(..size); + + if !self.csizes.is_empty() { + if self.csizes[0] >= size { + self.csizes[0] -= size; + // skip possible padding at the end of chunk + if self.csizes[0] == 1 { + self.buf.remove(0); + self.csizes[0] -= 1; + } + if self.csizes[0] == 0 { + self.csizes.remove(0); + } + } else { + println!("ran past input chunk end!"); + self.csizes.clear(); + self.buf.clear(); + } + } + + let ts = NATimeInfo::new(Some(u64::from(self.frameno)), None, None, stream.tb_num, stream.tb_den); + self.frameno += 1; + + self.state = ParseState::Start; + + Ok(Some(NAPacket::new(stream, ts, self.intra, data))) + } + fn reset(&mut self) { + self.buf.clear(); + self.bitpos = 0; + self.state = ParseState::Start; + } + fn bytes_left(&self) -> usize { self.buf.len() } +} + +pub fn get_packetiser() -> Box { + Box::new(MBPacketiser::new()) +} + +#[cfg(test)] +mod test { + use nihav_core::codecs::{RegisteredDecoders, RegisteredPacketisers}; + use nihav_core::demuxers::RegisteredRawDemuxers; + use nihav_codec_support::test::dec_video::*; + use crate::*; + #[test] + fn test_movingblockshq() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from RISC DISC 3 + test_decoding_raw("armovie", "movingblockshq", "assets/Acorn/EXPLODE", Some(3), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0x84a7bd46, 0xeb85d848, 0x2c1a6810, 0x27d0430f], + [0x43667e79, 0x64280602, 0xbc4bbbd5, 0x4cac3b7d], + [0x5318b37e, 0xa0df48e9, 0x6cd52319, 0xbebcb6ac], + [0x2208e86c, 0xc8c29366, 0x6840bc14, 0xb991720f]])); + } +} + +const LUMA_CODES: [u16; 32] = [ + 0x002, 0x007, 0x004, 0x008, 0x01D, 0x03B, 0x035, 0x05B, + 0x065, 0x070, 0x050, 0x0ED, 0x0A5, 0x0C5, 0x090, 0x19B, + 0x16D, 0x06D, 0x09B, 0x010, 0x045, 0x025, 0x01B, 0x030, + 0x005, 0x02D, 0x015, 0x00D, 0x000, 0x00B, 0x003, 0x001 +]; +const LUMA_BITS: [u8; 32] = [ + 2, 3, 3, 4, 5, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, + 9, 9, 9, 8, 8, 8, 8, 7, 7, 7, 6, 6, 5, 5, 4, 3 +]; + +const MV_TAB1: [(i8, i8); 8] = [ + (-1, -1), (0, -1), (1, -1), + (-1, 0), (1, 0), + (-1, 1), (0, 1), (1, 1) +]; + +const MV_TAB2: [(i8, i8); 16] = [ + (-2, -2), (-1, -2), (0, -2), (1, -2), (2, -2), + (-2, -1), (2, -1), + (-2, 0), (2, 0), + (-2, 1), (2, 1), + (-2, 2), (-1, 2), (0, 2), (1, 2), (2, 2) +]; + +const MV_TAB3: [(i8, i8); 24] = [ + (-3, -3), (-2, -3), (-1, -3), ( 0, -3), (1, -3), (2, -3), (3, -3), + (-3, -2), (3, -2), + (-3, -1), (3, -1), + (-3, 0), (3, 0), + (-3, 1), (3, 1), + (-3, 2), (3, 2), + (-3, 3), (-2, 3), (-1, 3), ( 0, 3), (1, 3), (2, 3), (3, 3) +]; + +const MV_TAB8: [(i8, i8); 240] = [ + (-8,-8), (-7,-8), (-6,-8), (-5,-8), (-4,-8), (-3,-8), (-2,-8), (-1,-8), (0,-8), (1,-8), (2,-8), (3,-8), (4,-8), (5,-8), (6,-8), (7,-8), (8,-8), + (-8,-7), (-7,-7), (-6,-7), (-5,-7), (-4,-7), (-3,-7), (-2,-7), (-1,-7), (0,-7), (1,-7), (2,-7), (3,-7), (4,-7), (5,-7), (6,-7), (7,-7), (8,-7), + (-8,-6), (-7,-6), (-6,-6), (-5,-6), (-4,-6), (-3,-6), (-2,-6), (-1,-6), (0,-6), (1,-6), (2,-6), (3,-6), (4,-6), (5,-6), (6,-6), (7,-6), (8,-6), + (-8,-5), (-7,-5), (-6,-5), (-5,-5), (-4,-5), (-3,-5), (-2,-5), (-1,-5), (0,-5), (1,-5), (2,-5), (3,-5), (4,-5), (5,-5), (6,-5), (7,-5), (8,-5), + (-8,-4), (-7,-4), (-6,-4), (-5,-4), (-4,-4), (-3,-4), (-2,-4), (-1,-4), (0,-4), (1,-4), (2,-4), (3,-4), (4,-4), (5,-4), (6,-4), (7,-4), (8,-4), + (-8,-3), (-7,-3), (-6,-3), (-5,-3), (-4,-3), (4,-3), (5,-3), (6,-3), (7,-3), (8,-3), + (-8,-2), (-7,-2), (-6,-2), (-5,-2), (-4,-2), (4,-2), (5,-2), (6,-2), (7,-2), (8,-2), + (-8,-1), (-7,-1), (-6,-1), (-5,-1), (-4,-1), (4,-1), (5,-1), (6,-1), (7,-1), (8,-1), + (-8, 0), (-7, 0), (-6, 0), (-5, 0), (-4, 0), (4, 0), (5, 0), (6, 0), (7, 0), (8, 0), + (-8, 1), (-7, 1), (-6, 1), (-5, 1), (-4, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), + (-8, 2), (-7, 2), (-6, 2), (-5, 2), (-4, 2), (4, 2), (5, 2), (6, 2), (7, 2), (8, 2), + (-8, 3), (-7, 3), (-6, 3), (-5, 3), (-4, 3), (4, 3), (5, 3), (6, 3), (7, 3), (8, 3), + (-8, 4), (-7, 4), (-6, 4), (-5, 4), (-4, 4), (-3, 4), (-2, 4), (-1, 4), (0, 4), (1, 4), (2, 4), (3, 4), (4, 4), (5, 4), (6, 4), (7, 4), (8, 4), + (-8, 5), (-7, 5), (-6, 5), (-5, 5), (-4, 5), (-3, 5), (-2, 5), (-1, 5), (0, 5), (1, 5), (2, 5), (3, 5), (4, 5), (5, 5), (6, 5), (7, 5), (8, 5), + (-8, 6), (-7, 6), (-6, 6), (-5, 6), (-4, 6), (-3, 6), (-2, 6), (-1, 6), (0, 6), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6), (7, 6), (8, 6), + (-8, 7), (-7, 7), (-6, 7), (-5, 7), (-4, 7), (-3, 7), (-2, 7), (-1, 7), (0, 7), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7), (7, 7), (8, 7), + (-8, 8), (-7, 8), (-6, 8), (-5, 8), (-4, 8), (-3, 8), (-2, 8), (-1, 8), (0, 8), (1, 8), (2, 8), (3, 8), (4, 8), (5, 8), (6, 8), (7, 8), (8, 8) +]; + +const MV_TAB_SELF_4X4: [(i8, i8); 8] = [ + (-2, -4), (-1, -4), ( 0, -4), (1, -4), (2, -4), + (-4, 0), (-4, -1), (-4, -2), +]; +const MV_TAB_SELF_2X2: [(i8, i8); 8] = [ + (-2, -2), (-1, -2), ( 0, -2), (1, -2), (2, -2), + (-2, -1), (-2, 0), (-3, 0), +]; diff --git a/nihav-acorn/src/codecs/movinglines.rs b/nihav-acorn/src/codecs/movinglines.rs new file mode 100644 index 0000000..ad159af --- /dev/null +++ b/nihav-acorn/src/codecs/movinglines.rs @@ -0,0 +1,295 @@ +use nihav_core::codecs::*; +use nihav_core::io::byteio::*; + +use super::RGB555_FORMAT; +use super::yuvtab::YUV2RGB; + +const END_CODE: u16 = 0x7300; + +#[derive(Default)] +struct MLDecoder { + info: NACodecInfoRef, + cur_frm: Vec, + prev_frm: Vec, + width: usize, + is_yuv: bool, +} + +impl MLDecoder { + fn new() -> Self { Self::default() } +} + +impl NADecoder for MLDecoder { + fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { + let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB555_FORMAT)); + self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); + self.cur_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.prev_frm = vec![0; vinfo.get_width() * vinfo.get_height()]; + self.width = vinfo.get_width(); + if let Some(edata) = info.get_extradata() { + for triplet in edata.windows(3) { + if triplet == b"YUV" { + self.is_yuv = true; + break; + } + } + } + Ok(()) + } else { + Err(DecoderError::InvalidData) + } + } + fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { + let src = pkt.get_buffer(); + validate!(src.len() > 2 && (src.len() & 1) == 0); + let mut mr = MemoryReader::new_read(&src); + let mut br = ByteReader::new(&mut mr); + + let mut is_intra = true; + let mut dpos = 0; + while dpos < self.cur_frm.len() { + let op = br.read_u16le()?; + let raw_flag = (op & 1) == 0; + let val = op >> 1; + if raw_flag { + self.cur_frm[dpos] = val; + dpos += 1; + } else { + match val { + 0..=0x47FF => { // copy prev + let len = ((val & 0x3F) + 2) as usize; + validate!(dpos + len <= self.cur_frm.len()); + + let mut idx = (val >> 6) as isize; + if idx >= 144 { // skip (0,0) + idx += 1; + } + let dy = idx / 17 - 8; + let dx = idx % 17 - 8; + let spos = dpos as isize + dx + dy * (self.width as isize); + validate!(spos >= 0); + let mut spos = spos as usize; + validate!(spos + len <= self.prev_frm.len()); + + for _ in 0..len { + self.cur_frm[dpos] = self.prev_frm[spos]; + dpos += 1; + spos += 1; + } + + is_intra = false; + }, + 0x4800..=0x72FF => { // copy cur + let len = ((val & 0x3F) + 2) as usize; + validate!(dpos + len <= self.cur_frm.len()); + + let idx = ((val >> 6) as usize) - 0x120; + let dx = idx % 19; + let dy = 9 - (idx / 19); + validate!(dpos + dx >= dy * self.width + 9); + let mut spos = dpos + dx - 9 - dy * self.width; + + for _ in 0..len { + self.cur_frm[dpos] = self.cur_frm[spos]; + dpos += 1; + spos += 1; + } + }, + END_CODE => break, // end of frame + 0x7301..=0x77FF => { // run + let len = ((val & 0x3F) + 2) as usize; + let pix = br.read_u16le()?; + validate!(dpos + len <= self.cur_frm.len()); + for _ in 0..len { + self.cur_frm[dpos] = pix; + dpos += 1; + } + }, + 0x7800..=0x7BFF => { // skip + let len = ((val & 0x3FF) + 1) as usize; + validate!(dpos + len <= self.cur_frm.len()); + for _ in 0..len { + self.cur_frm[dpos] = self.prev_frm[dpos]; + dpos += 1; + } + is_intra = false; + }, + 0x7C00.. => { // raw + let len = ((val & 0x3FF) + 1) as usize; + validate!(dpos + len <= self.cur_frm.len()); + let mut bitbuf = u32::from(br.read_u16le()?); + let mut bits = 16; + for _ in 0..len { + if bits < 15 { + bitbuf |= u32::from(br.read_u16le()?) << bits; + bits += 16; + } + self.cur_frm[dpos] = (bitbuf & 0x7FFF) as u16; + bitbuf >>= 15; + bits -= 15; + dpos += 1; + } + }, + } + } + } + validate!(br.left() == 2 && br.read_u16le()? == (END_CODE * 2 + 1)); + + let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; + let mut buf = bufinfo.get_vbuf16().unwrap(); + let stride = buf.get_stride(0); + let data = buf.get_data_mut().unwrap(); + + for (dline, sline) in data.chunks_exact_mut(stride) + .zip(self.cur_frm.chunks_exact(self.width)) { + dline[..self.width].copy_from_slice(sline); + } + if self.is_yuv { + for el in data.iter_mut() { + *el = YUV2RGB[(*el as usize) & 0x7FFF]; + } + } + + std::mem::swap(&mut self.cur_frm, &mut self.prev_frm); + + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo); + frm.set_keyframe(is_intra); + frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P }); + Ok(frm.into_ref()) + } + fn flush(&mut self) { + for el in self.cur_frm.iter_mut() { + *el = 0; + } + for el in self.prev_frm.iter_mut() { + *el = 0; + } + } +} + +impl NAOptionHandler for MLDecoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub fn get_decoder() -> Box { + Box::new(MLDecoder::new()) +} + +#[derive(Default)] +struct MLPacketiser { + stream: Option, + buf: Vec, + end: usize, + frameno: u32, + intra: bool, +} + +impl MLPacketiser { + fn new() -> Self { Self::default() } +} + +impl NAPacketiser for MLPacketiser { + fn attach_stream(&mut self, stream: NAStreamRef) { + self.stream = Some(stream); + } + fn add_data(&mut self, src: &[u8]) -> bool { + self.buf.extend_from_slice(src); + self.buf.len() < (1 << 10) + } + fn parse_stream(&mut self, id: u32) -> DecoderResult { + if let Some(ref stream) = self.stream { + let mut stream = NAStream::clone(stream); + stream.id = id; + Ok(stream.into_ref()) + } else { + Err(DecoderError::MissingReference) + } + } + fn skip_junk(&mut self) -> DecoderResult { + Err(DecoderError::NotImplemented) + } + fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult> { + if self.buf.len() < self.end { + return Ok(None); + } + + if self.end == 0 { + self.intra = true; + } + + let mut found = false; + while self.end + 2 <= self.buf.len() { + let op = u16::from(self.buf[self.end + 1]) * 256 + u16::from(self.buf[self.end]); + self.end += 2; + + if op == (END_CODE * 2 + 1) { + found = true; + break; + } + // run + if ((op & 1) == 1) && (0xE603..=0xEFFF).contains(&op) { + self.end += 2; + } + // raw data + if ((op & 1) == 1) && (op > 0xF800) { + let raw_size = (((op >> 1) & 0x3FF) + 1) as usize; + self.end += ((raw_size * 15 + 15) & !15) >> 3; + } + // copy from previous frame + if ((op & 1) == 1) && ((op < 0x9000) || (0xF001..=0xF7FF).contains(&op)) { + self.intra = false; + } + } + + if found { + let mut data = Vec::with_capacity(self.end); + data.extend_from_slice(&self.buf[..self.end]); + self.buf.drain(..self.end); + let ts = NATimeInfo::new(Some(u64::from(self.frameno)), None, None, stream.tb_num, stream.tb_den); + self.end = 0; + self.frameno += 1; + + return Ok(Some(NAPacket::new(stream, ts, self.intra, data))); + } + + Ok(None) + } + fn reset(&mut self) { + self.buf.clear(); + self.end = 0; + } + fn bytes_left(&self) -> usize { self.buf.len() } +} + +pub fn get_packetiser() -> Box { + Box::new(MLPacketiser::new()) +} + +#[cfg(test)] +mod test { + use nihav_core::codecs::{RegisteredDecoders, RegisteredPacketisers}; + use nihav_core::demuxers::RegisteredRawDemuxers; + use nihav_codec_support::test::dec_video::*; + use crate::*; + #[test] + fn test_movinglines() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Acorn Replay Demonstration Disc 2 + test_decoding_raw("armovie", "movinglines", "assets/Acorn/CHEMSET2", Some(3), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0x2ba85570, 0x339ddc8f, 0x2e9ea4ba, 0xec6fa25c], + [0x17a5dd38, 0xab99b869, 0x63936887, 0x0cb05673], + [0x81d920cf, 0x57155044, 0xe13d1b8b, 0xb029e645], + [0x7dc1a826, 0xea3c8e29, 0x13398b07, 0xa9a647de]])); + } +} diff --git a/nihav-acorn/src/codecs/rawaudio.rs b/nihav-acorn/src/codecs/rawaudio.rs new file mode 100644 index 0000000..5952013 --- /dev/null +++ b/nihav-acorn/src/codecs/rawaudio.rs @@ -0,0 +1,287 @@ +use nihav_core::codecs::*; +use nihav_core::io::byteio::*; + +const fn chord_val(val: u8) -> u32 { + (val as u32) * 0x7FFF / 247 +} + +fn vidc_mu_law(val: u8) -> i16 { + const CHORDS: [u32; 9] = [chord_val(0), chord_val(1), chord_val(3), chord_val(7), + chord_val(15), chord_val(31), chord_val(63), chord_val(127), chord_val(247) ]; + + let chord = ((val >> 4) & 7) as usize; + let point = u32::from(val & 0xF); + + (CHORDS[chord] + point * (CHORDS[chord + 1] - CHORDS[chord]) / 8) as i16 +} + +#[derive(Default,Debug,Clone,Copy,PartialEq)] +enum CodecType { + S8, + #[default] + U8, + S16, + Logarithmic, +} + +#[derive(Default)] +struct RawDecoder { + info: NACodecInfoRef, + chmap: NAChannelMap, + blk_size: usize, + codec_type: CodecType, +} + +impl RawDecoder { + fn new() -> Self { Self::default() } +} + +impl NADecoder for RawDecoder { + fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() { + let channels = ainfo.channels; + let srate = ainfo.sample_rate; + let bits = ainfo.format.bits; + validate!(info.get_extradata().is_some()); + + if let Some(edata) = info.get_extradata() { + let mut is_vidc = false; + let mut is_unsigned = false; + + for i in 0..edata.len() { + let head = &edata[i..]; + if (head.len() >= 4 && &head[..4] == b"VIDC") || (head.len() >= 11 && &head[..11] == b"exponential") { + is_vidc = true; + break; + } + if head.len() >= 8 && (&head[..8] == b"unsigned" || &head[..8] == b"UNSIGNED") { + is_unsigned = true; + } + } + self.codec_type = if is_vidc { + CodecType::Logarithmic + } else if bits == 8 { + if is_unsigned { + CodecType::U8 + } else { + CodecType::S8 + } + } else { + CodecType::S16 + }; + } else { + return Err(DecoderError::InvalidData); + } + + match channels { + 1 => self.chmap.add_channel(NAChannelType::C), + 2 => self.chmap.add_channels(&[NAChannelType::L, NAChannelType::R]), + _ => return Err(DecoderError::InvalidData), + } + + self.blk_size = match self.codec_type { + CodecType::U8 | CodecType::S8 | CodecType::Logarithmic => channels as usize, + CodecType::S16 => channels as usize * 2, + }; + + let fmt = match self.codec_type { + CodecType::U8 | CodecType::S8 => SND_U8_FORMAT, + CodecType::S16 | CodecType::Logarithmic => SND_S16_FORMAT, + }; + + let myinfo = NACodecTypeInfo::Audio(NAAudioInfo::new(srate, channels, fmt, 0)); + self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); + + Ok(()) + } else { + Err(DecoderError::InvalidData) + } + } + fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { + let src = pkt.get_buffer(); + validate!(!src.is_empty() && (src.len() % self.blk_size) == 0); + + let bufinfo = alloc_audio_buffer(self.info.get_properties().get_audio_info().unwrap(), src.len() / self.blk_size, self.chmap.clone())?; + match self.codec_type { + CodecType::S8 => { + let mut buf = bufinfo.get_abuf_u8().unwrap(); + let dst = buf.get_data_mut().unwrap(); + for (dst, &src) in dst.iter_mut().zip(src.iter()) { + *dst = src ^ 0x80; + } + }, + CodecType::U8 => { + let mut buf = bufinfo.get_abuf_u8().unwrap(); + let dst = buf.get_data_mut().unwrap(); + dst[..src.len()].copy_from_slice(&src); + }, + CodecType::S16 => { + let mut buf = bufinfo.get_abuf_i16().unwrap(); + let dst = buf.get_data_mut().unwrap(); + + for (dst, src) in dst.iter_mut().zip(src.chunks_exact(2)) { + *dst = read_u16le(src)? as i16; + } + }, + CodecType::Logarithmic => { + let mut buf = bufinfo.get_abuf_i16().unwrap(); + let dst = buf.get_data_mut().unwrap(); + + for (dst, &val) in dst.iter_mut().zip(src.iter()) { + let sign = (val & 0x01) != 0; + *dst = vidc_mu_law(val >> 1); + if sign { + *dst = -*dst; + } + } + }, + } + + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo); + frm.set_keyframe(true); + frm.set_frame_type(FrameType::I); + Ok(frm.into_ref()) + } + fn flush(&mut self) {} +} + +impl NAOptionHandler for RawDecoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub fn get_decoder() -> Box { + Box::new(RawDecoder::new()) +} + +#[derive(Default)] +struct RawPacketiser { + stream: Option, + blk_size: usize, + asize: u64, + buf: Vec, +} + +impl RawPacketiser { + fn new() -> Self { Self::default() } +} + +impl NAPacketiser for RawPacketiser { + fn attach_stream(&mut self, stream: NAStreamRef) { + if let NACodecTypeInfo::Audio(ainfo) = stream.get_info().get_properties() { + self.blk_size = (ainfo.channels as usize) * (ainfo.format.bits as usize) / 8; + } + self.stream = Some(stream); + } + fn add_data(&mut self, src: &[u8]) -> bool { + self.buf.extend_from_slice(src); + self.buf.len() < (1 << 10) + } + fn parse_stream(&mut self, id: u32) -> DecoderResult { + if let Some(ref stream) = self.stream { + let mut stream = NAStream::clone(stream); + stream.id = id; + Ok(stream.into_ref()) + } else { + Err(DecoderError::MissingReference) + } + } + fn skip_junk(&mut self) -> DecoderResult { + Err(DecoderError::NotImplemented) + } + fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult> { + if self.blk_size == 0 { + return Err(DecoderError::MissingReference); + } + + if self.buf.len() < 2 { + return Ok(None); + } + + let data_len = self.buf.len(); + let mut data = Vec::new(); + std::mem::swap(&mut self.buf, &mut data); + + let ts = NATimeInfo::new(Some(self.asize), None, None, stream.tb_num, stream.tb_den); + self.asize += (data_len / self.blk_size) as u64; + + Ok(Some(NAPacket::new(stream, ts, true, data))) + } + fn reset(&mut self) { + self.buf.clear(); + } + fn bytes_left(&self) -> usize { self.buf.len() } +} + +pub fn get_packetiser() -> Box { + Box::new(RawPacketiser::new()) +} + +#[cfg(test)] +mod test { + use nihav_core::codecs::{RegisteredDecoders, RegisteredPacketisers}; + use nihav_core::demuxers::RegisteredRawDemuxers; + use nihav_codec_support::test::dec_video::*; + use crate::*; + + #[test] + fn test_format_s8() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Acorn Replay Demonstration Disc 2 + test_decoding_raw("armovie", "arm_rawaudio", "assets/Acorn/CHEMSET2", Some(1), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5([0x167985bf, 0xd82c3fb0, 0x125ff24e, 0xa7408c57])); + } + + #[test] + fn test_format_u8() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Cine Clips by Oregan Software Developments + test_decoding_raw("armovie", "arm_rawaudio", "assets/Acorn/COLOURPLUS", Some(1), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5([0x2f0dc76b, 0x208372ad, 0xa986fb0b, 0x1024dcc8])); + } + + #[test] + fn test_format_vidc() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Cine Clips by Oregan Software Developments + test_decoding_raw("armovie", "arm_rawaudio", "assets/Acorn/CFC2", Some(1), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5([0x3c2a6e48, 0x6e511c72, 0xd30b5813, 0x42d98a71])); + } + + #[test] + fn test_format_s16() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Cine Clips by Oregan Software Developments + test_decoding_raw("armovie", "arm_rawaudio", "assets/Acorn/SKYHIGH", Some(1), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5([0xd2003a1c, 0xfe38974f, 0xa1850a5b, 0xb4313217])); + } +} diff --git a/nihav-acorn/src/codecs/rawvideo.rs b/nihav-acorn/src/codecs/rawvideo.rs new file mode 100644 index 0000000..2e63695 --- /dev/null +++ b/nihav-acorn/src/codecs/rawvideo.rs @@ -0,0 +1,320 @@ +use nihav_core::codecs::*; +use nihav_core::io::byteio::*; +use nihav_core::io::bitreader::*; + +use super::RGB555_FORMAT; +use super::yuvtab::YUV2RGB; + +const YUV422_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel:: +YUV(YUVSubmodel::YUVJ), components: 3, + comp_info: [ + Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 1}), + Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 1, next_elem: 1}), + Some(NAPixelChromaton{ h_ss: 1, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 2, next_elem: 1}), + None, None], + elem_size: 0, be: false, alpha: false, palette: false }; + + +trait ReadYUV5 { + fn read_y(&mut self) -> DecoderResult; + fn read_uv(&mut self) -> DecoderResult; +} + +impl<'a> ReadYUV5 for BitReader<'a> { + fn read_y(&mut self) -> DecoderResult { + let v = self.read(5)? as u8; + Ok((v << 3) | (v >> 2)) + } + fn read_uv(&mut self) -> DecoderResult { + const EXPAND: [u8; 16] = [ + 0x00, 0x08, 0x11, 0x19, 0x22, 0x2A, 0x33, 0x3B, 0x44, 0x4C, 0x55, 0x5D, 0x66, 0x6E, 0x77, 0x7F]; + let v = self.read(5)? as u8; + if v < 16 { + Ok(EXPAND[v as usize] | 0x80) + } else { + Ok(EXPAND[(v & 0xF) as usize]) + } + } +} + +#[derive(Default)] +struct RawDecoder { + info: NACodecInfoRef, + width: usize, + height: usize, + is_yuv: bool, + codec_id: u16, +} + +impl RawDecoder { + fn new() -> Self { Self::default() } +} + +impl NADecoder for RawDecoder { + fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { + self.width = vinfo.get_width(); + self.height = vinfo.get_height(); + validate!(info.get_extradata().is_some()); + + if let Some(edata) = info.get_extradata() { + validate!(edata.len() > 1); + self.codec_id = u16::from(edata[0]) + 256 * u16::from(edata[1]); + + for triplet in edata.windows(3) { + if triplet == b"YUV" { + self.is_yuv = true; + break; + } + } + } else { + return Err(DecoderError::InvalidData); + } + + let fmt = match self.codec_id { + 2 => RGB555_FORMAT, + 3 if self.is_yuv => { + validate!((self.width & 1) == 0); + YUV422_FORMAT + }, + 5 if self.is_yuv => { + validate!((self.width & 1) == 0); + validate!((self.height & 1) == 0); + YUV420_FORMAT + }, + _ => return Err(DecoderError::NotImplemented), + }; + + let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, fmt)); + self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); + + Ok(()) + } else { + Err(DecoderError::InvalidData) + } + } + fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { + let src = pkt.get_buffer(); + validate!(src.len() > 1); + + let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; + match self.codec_id { + 2 => { + let mut mr = MemoryReader::new_read(&src); + let mut br = ByteReader::new(&mut mr); + + let mut buf = bufinfo.get_vbuf16().unwrap(); + let stride = buf.get_stride(0); + let data = buf.get_data_mut().unwrap(); + + for dline in data.chunks_exact_mut(stride).take(self.height) { + for el in dline[..self.width].iter_mut().take(self.width) { + *el = br.read_u16le()?; + if self.is_yuv { + *el = YUV2RGB[(*el as usize) & 0x7FFF]; + } + } + } + }, + 3 => { + let mut br = BitReader::new(&src, BitReaderMode::LE); + let mut buf = bufinfo.get_vbuf().unwrap(); + let dst = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); + + let mut yoff = dst.offset[0]; + let mut uoff = dst.offset[1]; + let mut voff = dst.offset[2]; + for _y in 0..self.height { + for x in (0..self.width).step_by(2) { + dst.data[yoff + x] = br.read_y()?; + dst.data[yoff + x + 1] = br.read_y()?; + dst.data[uoff + x / 2] = br.read_uv()?; + dst.data[voff + x / 2] = br.read_uv()?; + } + yoff += dst.stride[0]; + uoff += dst.stride[1]; + voff += dst.stride[2]; + } + }, + 5 => { + let mut br = BitReader::new(&src, BitReaderMode::LE); + let mut buf = bufinfo.get_vbuf().unwrap(); + let dst = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); + + let mut yoff = dst.offset[0]; + let mut uoff = dst.offset[1]; + let mut voff = dst.offset[2]; + for _y in (0..self.height).step_by(2) { + for x in (0..self.width).step_by(2) { + dst.data[yoff + x] = br.read_y()?; + dst.data[yoff + x + 1] = br.read_y()?; + dst.data[yoff + x + dst.stride[0]] = br.read_y()?; + dst.data[yoff + x + dst.stride[0] + 1] = br.read_y()?; + dst.data[uoff + x / 2] = br.read_uv()?; + dst.data[voff + x / 2] = br.read_uv()?; + br.skip(2)?; + } + yoff += dst.stride[0] * 2; + uoff += dst.stride[1]; + voff += dst.stride[2]; + } + }, + _ => unreachable!(), + } + + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo); + frm.set_keyframe(true); + frm.set_frame_type(FrameType::I); + Ok(frm.into_ref()) + } + fn flush(&mut self) {} +} + +impl NAOptionHandler for RawDecoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub fn get_decoder() -> Box { + Box::new(RawDecoder::new()) +} + +#[derive(Default)] +struct RawPacketiser { + stream: Option, + buf: Vec, + frameno: u32, + size: usize, +} + +impl RawPacketiser { + fn new() -> Self { Self::default() } +} + +impl NAPacketiser for RawPacketiser { + fn attach_stream(&mut self, stream: NAStreamRef) { + let vinfo = stream.get_info().get_properties().get_video_info().unwrap(); + let width = vinfo.width; + let height = vinfo.height; + if let Some(edata) = stream.get_info().get_extradata() { + if edata.len() > 1 { + let codec_id = u16::from(edata[0]) + 256 * u16::from(edata[1]); + /*let mut is_yuv = false; + for triplet in edata.windows(3) { + if triplet == b"YUV" { + is_yuv = true; + break; + } + }*/ + self.size = match codec_id { + 2 => width * height * 2, + 3 => width * height * 10 / 8, + 5 => width * height, + _ => unimplemented!(), + }; + } + } + self.stream = Some(stream); + } + fn add_data(&mut self, src: &[u8]) -> bool { + self.buf.extend_from_slice(src); + self.buf.len() < (1 << 10) + } + fn parse_stream(&mut self, id: u32) -> DecoderResult { + if let Some(ref stream) = self.stream { + let mut stream = NAStream::clone(stream); + stream.id = id; + Ok(stream.into_ref()) + } else { + Err(DecoderError::MissingReference) + } + } + fn skip_junk(&mut self) -> DecoderResult { + Err(DecoderError::NotImplemented) + } + fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult> { + if self.size == 0 { + return Err(DecoderError::MissingReference); + } + if self.buf.len() < self.size { + return Ok(None); + } + + let mut data = Vec::with_capacity(self.size); + data.extend_from_slice(&self.buf[..self.size]); + self.buf.drain(..self.size); + + let ts = NATimeInfo::new(Some(u64::from(self.frameno)), None, None, stream.tb_num, stream.tb_den); + self.frameno += 1; + + Ok(Some(NAPacket::new(stream, ts, true, data))) + } + fn reset(&mut self) { + self.buf.clear(); + } + fn bytes_left(&self) -> usize { self.buf.len() } +} + +pub fn get_packetiser() -> Box { + Box::new(RawPacketiser::new()) +} + +#[cfg(test)] +mod test { + use nihav_core::codecs::{RegisteredDecoders, RegisteredPacketisers}; + use nihav_core::demuxers::RegisteredRawDemuxers; + use nihav_codec_support::test::dec_video::*; + use crate::*; + + #[test] + fn test_format2() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Acorn Replay Demonstration Disc 2 + test_decoding_raw("armovie", "arm_rawvideo", "assets/Acorn/ROBIN2", Some(1), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0x9a452976, 0x5fa64428, 0x71172412, 0x6db21372], + [0xabc70d88, 0x2431a96b, 0xfc8d58a6, 0xef1bb1c9]])); + } + + #[test] + fn test_format3() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Cine Clips by Oregan Software Developments + test_decoding_raw("armovie", "arm_rawvideo", "assets/Acorn/TROPICLSUN", Some(1), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0xcd5fe3d0, 0x60454448, 0x9f91180a, 0x8e73370d], + [0x148b07bb, 0xbf647ddd, 0x2bf8c9e5, 0x4b37122a]])); + } + + #[test] + fn test_format5() { + let mut dmx_reg = RegisteredRawDemuxers::new(); + acorn_register_all_raw_demuxers(&mut dmx_reg); + let mut pkt_reg = RegisteredPacketisers::new(); + acorn_register_all_packetisers(&mut pkt_reg); + let mut dec_reg = RegisteredDecoders::new(); + acorn_register_all_decoders(&mut dec_reg); + + // a sample from Empire video editor demo + test_decoding_raw("armovie", "arm_rawvideo", "assets/Acorn/CLIP3", Some(1), + &dmx_reg, &pkt_reg, &dec_reg, + ExpectedTestResult::MD5Frames(vec![ + [0x816ccb08, 0x5e86539c, 0x1bb51e98, 0x849936c4], + [0xa42cf122, 0x296f3825, 0xedb7f0fc, 0x25a7825e]])); + } +} diff --git a/nihav-acorn/src/codecs/wss_packetisers.rs b/nihav-acorn/src/codecs/wss_packetisers.rs new file mode 100644 index 0000000..6bdd1a9 --- /dev/null +++ b/nihav-acorn/src/codecs/wss_packetisers.rs @@ -0,0 +1,159 @@ +use nihav_core::codecs::*; +use nihav_core::io::byteio::*; + +struct Palette { + data: [u8; 1024], +} + +impl Default for Palette { + fn default() -> Self { + Self { data: [0; 1024] } + } +} + +impl Palette { + fn read_data(&mut self, src: &[u8]) { + for (dst, src) in self.data.chunks_exact_mut(4).zip(src.chunks_exact(4)) { + let clr = read_u32le(src).unwrap(); + let r = (clr & 0x1F) as u8; + dst[0] = (r << 3) | (r >> 2); + let g = ((clr >> 5) & 0x1F) as u8; + dst[1] = (g << 3) | (g >> 2); + let b = ((clr >> 10) & 0x1F) as u8; + dst[2] = (b << 3) | (b >> 2); + dst[3] = 0; + } + } + fn get_side_data(&self) -> NASideData { + NASideData::Palette(true, Arc::new(self.data)) + } +} + +#[derive(Default)] +struct WssPacketiser { + stream: Option, + buf: Vec, + csizes: Vec, + frameno: u32, + frame_size: usize, + palette: Palette, + pal_mode: bool, + has_pal: bool, +} + +impl WssPacketiser { + fn new() -> Self { Self::default() } + fn remove_payload(&mut self, size: usize) { + self.buf.drain(..size); + if !self.csizes.is_empty() { + if self.csizes[0] >= size { + self.csizes[0] -= size; + // skip possible padding at the end of chunk + if self.csizes[0] == 1 { + self.buf.remove(0); + self.csizes[0] -= 1; + } + if self.csizes[0] == 0 { + self.csizes.remove(0); + } + } else { + println!("ran past input chunk end!"); + self.csizes.clear(); + } + } + } +} + +impl NAPacketiser for WssPacketiser { + fn attach_stream(&mut self, stream: NAStreamRef) { + self.stream = Some(stream); + } + fn add_data(&mut self, src: &[u8]) -> bool { + self.csizes.push(src.len()); + self.buf.extend_from_slice(src); + self.buf.len() < (1 << 10) + } + fn parse_stream(&mut self, id: u32) -> DecoderResult { + if let Some(ref stream) = self.stream { + let mut stream = NAStream::clone(stream); + stream.id = id; + Ok(stream.into_ref()) + } else { + Err(DecoderError::MissingReference) + } + } + fn skip_junk(&mut self) -> DecoderResult { + Err(DecoderError::NotImplemented) + } + fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult> { + loop { + if self.buf.len() < 4 || self.buf.len() < self.frame_size { + return Ok(None); + } + + if self.frame_size == 0 { + self.frame_size = read_u32le(&self.buf)? as usize; + if self.frame_size == 0 { + self.remove_payload(4); + self.frameno += 1; + continue; + } + if self.frame_size == 0xFFFFFFFF { + self.pal_mode = true; + self.frame_size = 1024; + } + self.frame_size += 4; + validate!(self.frame_size > 16); + if self.buf.len() >= self.frame_size { + if self.pal_mode { + self.palette.read_data(&self.buf[4..][..1024]); + self.remove_payload(self.frame_size); + self.pal_mode = false; + self.has_pal = true; + self.frame_size = 0; + continue; + } + break; + } + } + } + + let mut data = Vec::with_capacity(self.frame_size); + data.extend_from_slice(&self.buf[16..self.frame_size]); + self.remove_payload(self.frame_size); + + let mut is_intra = false; + if let Some(ref stream) = self.stream { + #[allow(clippy::single_match)] + match stream.get_info().get_name() { + "cinepak" => is_intra = (data[0] & 1) == 0, + _ => {}, + }; + } + + let ts = NATimeInfo::new(Some(u64::from(self.frameno)), None, None, stream.tb_num, stream.tb_den); + self.frameno += 1; + self.frame_size = 0; + + let mut pkt = NAPacket::new(stream, ts, is_intra, data); + if self.has_pal { + pkt.add_side_data(self.palette.get_side_data()); + } + + Ok(Some(pkt)) + } + fn reset(&mut self) { + self.buf.clear(); + } + fn bytes_left(&self) -> usize { self.buf.len() } +} + +#[cfg(feature="packetiser_cinepak")] +pub fn get_packetiser_cinepak() -> Box { + Box::new(WssPacketiser::new()) +} + +#[cfg(feature="packetiser_msvideo1")] +pub fn get_packetiser_msvideo1() -> Box { + Box::new(WssPacketiser::new()) +} diff --git a/nihav-acorn/src/codecs/yuvtab.rs b/nihav-acorn/src/codecs/yuvtab.rs new file mode 100644 index 0000000..fd4cfc6 --- /dev/null +++ b/nihav-acorn/src/codecs/yuvtab.rs @@ -0,0 +1,4115 @@ +// A table for converting 5-bit YUV to 5-bit RGB +/* Generated using the following code: + for (i, el) in tab.iter_mut().enumerate() { + let y = ( i & 0x1F) as f32; + let u = ((i >> 5) & 0x1F) as i16; + let v = ((i >> 10) & 0x1F) as i16; + + let v = (if v > 15 { v - 31 } else { v }) as f32; + let u = (if u > 15 { u - 31 } else { u }) as f32; + + let r = (y + 1.13983 * v).max(0.0).min(15.0) as u16; + let g = (y - 0.39465 * u - 0.58060 * v).max(0.0).min(15.0) as u16; + let b = (y + 2.03211 * u) .max(0.0).min(15.0) as u16; + + *el = r | (g << 5) | (b << 10); + } +*/ +pub const YUV2RGB: [u16; 32768] = [ + 0x0000, 0x0421, 0x0842, 0x0C63, 0x1084, 0x14A5, 0x18C6, 0x1CE7, + 0x2108, 0x2529, 0x294A, 0x2D6B, 0x318C, 0x35AD, 0x39CE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0800, 0x0C01, 0x1022, 0x1443, 0x1864, 0x1C85, 0x20A6, 0x24C7, + 0x28E8, 0x2D09, 0x312A, 0x354B, 0x396C, 0x3D8D, 0x3DAE, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1000, 0x1401, 0x1822, 0x1C43, 0x2064, 0x2485, 0x28A6, 0x2CC7, + 0x30E8, 0x3509, 0x392A, 0x3D4B, 0x3D6C, 0x3D8D, 0x3DAE, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1800, 0x1C01, 0x2002, 0x2423, 0x2844, 0x2C65, 0x3086, 0x34A7, + 0x38C8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, 0x3D8E, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2000, 0x2401, 0x2802, 0x2C23, 0x3044, 0x3465, 0x3886, 0x3CA7, + 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, 0x3D8E, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2800, 0x2C01, 0x3002, 0x3423, 0x3844, 0x3C65, 0x3C86, 0x3CA7, + 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, 0x3D8E, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3000, 0x3401, 0x3802, 0x3C03, 0x3C24, 0x3C45, 0x3C66, 0x3C87, + 0x3CA8, 0x3CC9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, 0x3D6E, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C01, 0x3C02, 0x3C03, 0x3C24, 0x3C45, 0x3C66, 0x3C87, + 0x3CA8, 0x3CC9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, 0x3D6E, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C25, 0x3C46, 0x3C67, + 0x3C88, 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C25, 0x3C46, 0x3C67, + 0x3C88, 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C25, 0x3C46, 0x3C67, + 0x3C88, 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C26, 0x3C47, + 0x3C68, 0x3C89, 0x3CAA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C26, 0x3C47, + 0x3C68, 0x3C89, 0x3CAA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, + 0x3C48, 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, + 0x3C48, 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, + 0x3C48, 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, 0x0166, 0x0187, + 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, 0x0166, 0x0187, + 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, 0x0166, 0x0187, + 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0080, 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, 0x0146, 0x0167, + 0x0188, 0x01A9, 0x01CA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0080, 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, 0x0146, 0x0167, + 0x0188, 0x01A9, 0x01CA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0060, 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, + 0x0168, 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0060, 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, + 0x0168, 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0060, 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, + 0x0168, 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0040, 0x0061, 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, + 0x0148, 0x0169, 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x01EE, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0040, 0x0061, 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, + 0x0148, 0x0169, 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x05EE, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, + 0x0128, 0x0149, 0x016A, 0x018B, 0x05AC, 0x09CD, 0x0DEE, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, + 0x0128, 0x0149, 0x056A, 0x098B, 0x0DAC, 0x11CD, 0x15EE, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, + 0x0528, 0x0949, 0x0D6A, 0x118B, 0x15AC, 0x19CD, 0x1DEE, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0021, 0x0042, 0x0063, 0x0084, 0x00A5, 0x04C6, 0x08E7, + 0x0D08, 0x1129, 0x154A, 0x196B, 0x1D8C, 0x21AD, 0x25CE, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0021, 0x0042, 0x0063, 0x0484, 0x08A5, 0x0CC6, 0x10E7, + 0x1508, 0x1929, 0x1D4A, 0x216B, 0x258C, 0x29AD, 0x2DCE, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0421, 0x0842, 0x0C63, 0x1084, 0x14A5, 0x18C6, 0x1CE7, + 0x2108, 0x2529, 0x294A, 0x2D6B, 0x318C, 0x35AD, 0x39CE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0001, 0x0402, 0x0823, 0x0C44, 0x1065, 0x1486, 0x18A7, 0x1CC8, + 0x20E9, 0x250A, 0x292B, 0x2D4C, 0x316D, 0x358E, 0x39AF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0801, 0x0C02, 0x1023, 0x1444, 0x1865, 0x1C86, 0x20A7, 0x24C8, + 0x28E9, 0x2D0A, 0x312B, 0x354C, 0x396D, 0x3D8E, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1001, 0x1402, 0x1803, 0x1C24, 0x2045, 0x2466, 0x2887, 0x2CA8, + 0x30C9, 0x34EA, 0x390B, 0x3D2C, 0x3D4D, 0x3D6E, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1801, 0x1C02, 0x2003, 0x2424, 0x2845, 0x2C66, 0x3087, 0x34A8, + 0x38C9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, 0x3D6E, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2001, 0x2402, 0x2803, 0x2C04, 0x3025, 0x3446, 0x3867, 0x3C88, + 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2801, 0x2C02, 0x3003, 0x3404, 0x3825, 0x3C46, 0x3C67, 0x3C88, + 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3001, 0x3402, 0x3803, 0x3C04, 0x3C25, 0x3C46, 0x3C67, 0x3C88, + 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3801, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C26, 0x3C47, 0x3C68, + 0x3C89, 0x3CAA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C26, 0x3C47, 0x3C68, + 0x3C89, 0x3CAA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, 0x3C48, + 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, 0x3C48, + 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, 0x3C48, + 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C28, + 0x3C49, 0x3C6A, 0x3C8B, 0x3CAC, 0x3CCD, 0x3CEE, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C28, + 0x3C49, 0x3C6A, 0x3C8B, 0x3CAC, 0x3CCD, 0x3CEE, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, + 0x3C29, 0x3C4A, 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, + 0x3C29, 0x3C4A, 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, 0x0146, 0x0167, 0x0188, + 0x01A9, 0x01CA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, 0x0168, + 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, 0x0168, + 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, 0x0168, + 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0061, 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, 0x0148, + 0x0169, 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0061, 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, 0x0148, + 0x0169, 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, 0x0128, + 0x0149, 0x016A, 0x018B, 0x01AC, 0x01CD, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, 0x0128, + 0x0149, 0x016A, 0x018B, 0x01AC, 0x01CD, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, 0x0128, + 0x0149, 0x016A, 0x018B, 0x01AC, 0x01CD, 0x01EE, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0021, 0x0042, 0x0063, 0x0084, 0x00A5, 0x00C6, 0x00E7, 0x0108, + 0x0129, 0x014A, 0x016B, 0x018C, 0x01AD, 0x01CE, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0021, 0x0042, 0x0063, 0x0084, 0x00A5, 0x00C6, 0x00E7, 0x0108, + 0x0129, 0x014A, 0x016B, 0x018C, 0x05AD, 0x09CE, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0001, 0x0022, 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, + 0x0109, 0x012A, 0x054B, 0x096C, 0x0D8D, 0x11AE, 0x15CF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0001, 0x0022, 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, + 0x0509, 0x092A, 0x0D4B, 0x116C, 0x158D, 0x19AE, 0x1DCF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0001, 0x0022, 0x0043, 0x0064, 0x0085, 0x00A6, 0x04C7, 0x08E8, + 0x0D09, 0x112A, 0x154B, 0x196C, 0x1D8D, 0x21AE, 0x25CF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0001, 0x0002, 0x0023, 0x0044, 0x0465, 0x0886, 0x0CA7, 0x10C8, + 0x14E9, 0x190A, 0x1D2B, 0x214C, 0x256D, 0x298E, 0x2DAF, 0x31CF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0001, 0x0402, 0x0823, 0x0C44, 0x1065, 0x1486, 0x18A7, 0x1CC8, + 0x20E9, 0x250A, 0x292B, 0x2D4C, 0x316D, 0x358E, 0x39AF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0002, 0x0403, 0x0804, 0x0C25, 0x1046, 0x1467, 0x1888, 0x1CA9, + 0x20CA, 0x24EB, 0x290C, 0x2D2D, 0x314E, 0x356F, 0x398F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0802, 0x0C03, 0x1004, 0x1425, 0x1846, 0x1C67, 0x2088, 0x24A9, + 0x28CA, 0x2CEB, 0x310C, 0x352D, 0x394E, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1002, 0x1403, 0x1804, 0x1C25, 0x2046, 0x2467, 0x2888, 0x2CA9, + 0x30CA, 0x34EB, 0x390C, 0x3D2D, 0x3D4E, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1802, 0x1C03, 0x2004, 0x2405, 0x2826, 0x2C47, 0x3068, 0x3489, + 0x38AA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2002, 0x2403, 0x2804, 0x2C05, 0x3026, 0x3447, 0x3868, 0x3C89, + 0x3CAA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2802, 0x2C03, 0x3004, 0x3405, 0x3806, 0x3C27, 0x3C48, 0x3C69, + 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3002, 0x3403, 0x3804, 0x3C05, 0x3C06, 0x3C27, 0x3C48, 0x3C69, + 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3802, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, 0x3C48, 0x3C69, + 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C28, 0x3C49, + 0x3C6A, 0x3C8B, 0x3CAC, 0x3CCD, 0x3CEE, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C28, 0x3C49, + 0x3C6A, 0x3C8B, 0x3CAC, 0x3CCD, 0x3CEE, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C29, + 0x3C4A, 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C29, + 0x3C4A, 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C29, + 0x3C4A, 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, + 0x3C2A, 0x3C4B, 0x3C6C, 0x3C8D, 0x3CAE, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, + 0x3C2A, 0x3C4B, 0x3C6C, 0x3C8D, 0x3CAE, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, + 0x3C0A, 0x3C2B, 0x3C4C, 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, 0x0148, 0x0169, + 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, 0x0148, 0x0169, + 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, 0x0128, 0x0149, + 0x016A, 0x018B, 0x01AC, 0x01CD, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, 0x0128, 0x0149, + 0x016A, 0x018B, 0x01AC, 0x01CD, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, 0x0128, 0x0149, + 0x016A, 0x018B, 0x01AC, 0x01CD, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0042, 0x0063, 0x0084, 0x00A5, 0x00C6, 0x00E7, 0x0108, 0x0129, + 0x014A, 0x016B, 0x018C, 0x01AD, 0x01CE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0042, 0x0063, 0x0084, 0x00A5, 0x00C6, 0x00E7, 0x0108, 0x0129, + 0x014A, 0x016B, 0x018C, 0x01AD, 0x01CE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0022, 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, + 0x012A, 0x014B, 0x016C, 0x018D, 0x01AE, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0022, 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, + 0x012A, 0x014B, 0x016C, 0x018D, 0x01AE, 0x01CF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0022, 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, + 0x012A, 0x014B, 0x016C, 0x018D, 0x01AE, 0x01CF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0002, 0x0023, 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, + 0x010A, 0x012B, 0x014C, 0x016D, 0x058E, 0x09AF, 0x0DCF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0002, 0x0023, 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, + 0x010A, 0x012B, 0x054C, 0x096D, 0x0D8E, 0x11AF, 0x15CF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0002, 0x0023, 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, + 0x050A, 0x092B, 0x0D4C, 0x116D, 0x158E, 0x19AF, 0x1DCF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0002, 0x0003, 0x0024, 0x0045, 0x0066, 0x0087, 0x04A8, 0x08C9, + 0x0CEA, 0x110B, 0x152C, 0x194D, 0x1D6E, 0x218F, 0x25AF, 0x29CF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0002, 0x0003, 0x0024, 0x0045, 0x0466, 0x0887, 0x0CA8, 0x10C9, + 0x14EA, 0x190B, 0x1D2C, 0x214D, 0x256E, 0x298F, 0x2DAF, 0x31CF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0002, 0x0403, 0x0804, 0x0C25, 0x1046, 0x1467, 0x1888, 0x1CA9, + 0x20CA, 0x24EB, 0x290C, 0x2D2D, 0x314E, 0x356F, 0x398F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0003, 0x0404, 0x0805, 0x0C26, 0x1047, 0x1468, 0x1889, 0x1CAA, + 0x20CB, 0x24EC, 0x290D, 0x2D2E, 0x314F, 0x356F, 0x398F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0803, 0x0C04, 0x1005, 0x1406, 0x1827, 0x1C48, 0x2069, 0x248A, + 0x28AB, 0x2CCC, 0x30ED, 0x350E, 0x392F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1003, 0x1404, 0x1805, 0x1C06, 0x2027, 0x2448, 0x2869, 0x2C8A, + 0x30AB, 0x34CC, 0x38ED, 0x3D0E, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1803, 0x1C04, 0x2005, 0x2406, 0x2827, 0x2C48, 0x3069, 0x348A, + 0x38AB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2003, 0x2404, 0x2805, 0x2C06, 0x3007, 0x3428, 0x3849, 0x3C6A, + 0x3C8B, 0x3CAC, 0x3CCD, 0x3CEE, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2803, 0x2C04, 0x3005, 0x3406, 0x3807, 0x3C28, 0x3C49, 0x3C6A, + 0x3C8B, 0x3CAC, 0x3CCD, 0x3CEE, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3003, 0x3404, 0x3805, 0x3C06, 0x3C07, 0x3C08, 0x3C29, 0x3C4A, + 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3803, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C29, 0x3C4A, + 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C29, 0x3C4A, + 0x3C6B, 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C2A, + 0x3C4B, 0x3C6C, 0x3C8D, 0x3CAE, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C2A, + 0x3C4B, 0x3C6C, 0x3C8D, 0x3CAE, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, + 0x3C2B, 0x3C4C, 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, + 0x3C2B, 0x3C4C, 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, + 0x3C2B, 0x3C4C, 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, + 0x3C0B, 0x3C2C, 0x3C4D, 0x3C6E, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, + 0x3C0B, 0x3C2C, 0x3C4D, 0x3C6E, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, 0x0128, 0x0149, 0x016A, + 0x018B, 0x01AC, 0x01CD, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0063, 0x0084, 0x00A5, 0x00C6, 0x00E7, 0x0108, 0x0129, 0x014A, + 0x016B, 0x018C, 0x01AD, 0x01CE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0063, 0x0084, 0x00A5, 0x00C6, 0x00E7, 0x0108, 0x0129, 0x014A, + 0x016B, 0x018C, 0x01AD, 0x01CE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, 0x012A, + 0x014B, 0x016C, 0x018D, 0x01AE, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, 0x012A, + 0x014B, 0x016C, 0x018D, 0x01AE, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0043, 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, 0x012A, + 0x014B, 0x016C, 0x018D, 0x01AE, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0023, 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, 0x010A, + 0x012B, 0x014C, 0x016D, 0x018E, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0023, 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, 0x010A, + 0x012B, 0x014C, 0x016D, 0x018E, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0023, 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, 0x010A, + 0x012B, 0x014C, 0x016D, 0x018E, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0003, 0x0024, 0x0045, 0x0066, 0x0087, 0x00A8, 0x00C9, 0x00EA, + 0x010B, 0x012C, 0x014D, 0x016E, 0x018F, 0x01AF, 0x05CF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0003, 0x0024, 0x0045, 0x0066, 0x0087, 0x00A8, 0x00C9, 0x00EA, + 0x010B, 0x012C, 0x014D, 0x016E, 0x058F, 0x09AF, 0x0DCF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0003, 0x0004, 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, + 0x00EB, 0x010C, 0x052D, 0x094E, 0x0D6F, 0x118F, 0x15AF, 0x19CF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0003, 0x0004, 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, + 0x04EB, 0x090C, 0x0D2D, 0x114E, 0x156F, 0x198F, 0x1DAF, 0x21CF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0003, 0x0004, 0x0025, 0x0046, 0x0067, 0x0088, 0x04A9, 0x08CA, + 0x0CEB, 0x110C, 0x152D, 0x194E, 0x1D6F, 0x218F, 0x25AF, 0x29CF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0003, 0x0004, 0x0005, 0x0026, 0x0447, 0x0868, 0x0C89, 0x10AA, + 0x14CB, 0x18EC, 0x1D0D, 0x212E, 0x254F, 0x296F, 0x2D8F, 0x31AF, + 0x35CF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0003, 0x0404, 0x0805, 0x0C26, 0x1047, 0x1468, 0x1889, 0x1CAA, + 0x20CB, 0x24EC, 0x290D, 0x2D2E, 0x314F, 0x356F, 0x398F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0004, 0x0405, 0x0806, 0x0C07, 0x1028, 0x1449, 0x186A, 0x1C8B, + 0x20AC, 0x24CD, 0x28EE, 0x2D0F, 0x312F, 0x354F, 0x396F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0804, 0x0C05, 0x1006, 0x1407, 0x1828, 0x1C49, 0x206A, 0x248B, + 0x28AC, 0x2CCD, 0x30EE, 0x350F, 0x392F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1004, 0x1405, 0x1806, 0x1C07, 0x2008, 0x2429, 0x284A, 0x2C6B, + 0x308C, 0x34AD, 0x38CE, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1804, 0x1C05, 0x2006, 0x2407, 0x2808, 0x2C29, 0x304A, 0x346B, + 0x388C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2004, 0x2405, 0x2806, 0x2C07, 0x3008, 0x3429, 0x384A, 0x3C6B, + 0x3C8C, 0x3CAD, 0x3CCE, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2804, 0x2C05, 0x3006, 0x3407, 0x3808, 0x3C09, 0x3C2A, 0x3C4B, + 0x3C6C, 0x3C8D, 0x3CAE, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3004, 0x3405, 0x3806, 0x3C07, 0x3C08, 0x3C09, 0x3C2A, 0x3C4B, + 0x3C6C, 0x3C8D, 0x3CAE, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3804, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C2B, + 0x3C4C, 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C2B, + 0x3C4C, 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C2B, + 0x3C4C, 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, + 0x3C2C, 0x3C4D, 0x3C6E, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, + 0x3C2C, 0x3C4D, 0x3C6E, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, + 0x3C0C, 0x3C2D, 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, + 0x3C0C, 0x3C2D, 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, + 0x3C0C, 0x3C2D, 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C04, 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, + 0x3C0C, 0x3C0D, 0x3C2E, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, 0x012A, 0x014B, + 0x016C, 0x018D, 0x01AE, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0064, 0x0085, 0x00A6, 0x00C7, 0x00E8, 0x0109, 0x012A, 0x014B, + 0x016C, 0x018D, 0x01AE, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, 0x010A, 0x012B, + 0x014C, 0x016D, 0x018E, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, 0x010A, 0x012B, + 0x014C, 0x016D, 0x018E, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0044, 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, 0x010A, 0x012B, + 0x014C, 0x016D, 0x018E, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0024, 0x0045, 0x0066, 0x0087, 0x00A8, 0x00C9, 0x00EA, 0x010B, + 0x012C, 0x014D, 0x016E, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0024, 0x0045, 0x0066, 0x0087, 0x00A8, 0x00C9, 0x00EA, 0x010B, + 0x012C, 0x014D, 0x016E, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0004, 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, + 0x010C, 0x012D, 0x014E, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0004, 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, + 0x010C, 0x012D, 0x014E, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0004, 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, + 0x010C, 0x012D, 0x014E, 0x016F, 0x018F, 0x01AF, 0x05CF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0004, 0x0005, 0x0026, 0x0047, 0x0068, 0x0089, 0x00AA, 0x00CB, + 0x00EC, 0x010D, 0x012E, 0x014F, 0x056F, 0x098F, 0x0DAF, 0x11CF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0004, 0x0005, 0x0026, 0x0047, 0x0068, 0x0089, 0x00AA, 0x00CB, + 0x00EC, 0x010D, 0x052E, 0x094F, 0x0D6F, 0x118F, 0x15AF, 0x19CF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0004, 0x0005, 0x0006, 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, + 0x04CC, 0x08ED, 0x0D0E, 0x112F, 0x154F, 0x196F, 0x1D8F, 0x21AF, + 0x25CF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0004, 0x0005, 0x0006, 0x0027, 0x0048, 0x0069, 0x048A, 0x08AB, + 0x0CCC, 0x10ED, 0x150E, 0x192F, 0x1D4F, 0x216F, 0x258F, 0x29AF, + 0x2DCF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0004, 0x0005, 0x0006, 0x0027, 0x0448, 0x0869, 0x0C8A, 0x10AB, + 0x14CC, 0x18ED, 0x1D0E, 0x212F, 0x254F, 0x296F, 0x2D8F, 0x31AF, + 0x35CF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0004, 0x0405, 0x0806, 0x0C07, 0x1028, 0x1449, 0x186A, 0x1C8B, + 0x20AC, 0x24CD, 0x28EE, 0x2D0F, 0x312F, 0x354F, 0x396F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0005, 0x0406, 0x0807, 0x0C08, 0x1029, 0x144A, 0x186B, 0x1C8C, + 0x20AD, 0x24CE, 0x28EF, 0x2D0F, 0x312F, 0x354F, 0x396F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0805, 0x0C06, 0x1007, 0x1408, 0x1809, 0x1C2A, 0x204B, 0x246C, + 0x288D, 0x2CAE, 0x30CF, 0x34EF, 0x390F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1005, 0x1406, 0x1807, 0x1C08, 0x2009, 0x242A, 0x284B, 0x2C6C, + 0x308D, 0x34AE, 0x38CF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1805, 0x1C06, 0x2007, 0x2408, 0x2809, 0x2C0A, 0x302B, 0x344C, + 0x386D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2005, 0x2406, 0x2807, 0x2C08, 0x3009, 0x340A, 0x382B, 0x3C4C, + 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2805, 0x2C06, 0x3007, 0x3408, 0x3809, 0x3C0A, 0x3C2B, 0x3C4C, + 0x3C6D, 0x3C8E, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3005, 0x3406, 0x3807, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C2C, + 0x3C4D, 0x3C6E, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3805, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C2C, + 0x3C4D, 0x3C6E, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C2D, 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C2D, 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C2D, 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C0D, 0x3C2E, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C0D, 0x3C2E, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C0D, 0x3C0E, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C0D, 0x3C0E, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C05, 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, + 0x3C0D, 0x3C0E, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0065, 0x0086, 0x00A7, 0x00C8, 0x00E9, 0x010A, 0x012B, 0x014C, + 0x016D, 0x018E, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0045, 0x0066, 0x0087, 0x00A8, 0x00C9, 0x00EA, 0x010B, 0x012C, + 0x014D, 0x016E, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0045, 0x0066, 0x0087, 0x00A8, 0x00C9, 0x00EA, 0x010B, 0x012C, + 0x014D, 0x016E, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, 0x010C, + 0x012D, 0x014E, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, 0x010C, + 0x012D, 0x014E, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0025, 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, 0x010C, + 0x012D, 0x014E, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0005, 0x0026, 0x0047, 0x0068, 0x0089, 0x00AA, 0x00CB, 0x00EC, + 0x010D, 0x012E, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0005, 0x0026, 0x0047, 0x0068, 0x0089, 0x00AA, 0x00CB, 0x00EC, + 0x010D, 0x012E, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0005, 0x0006, 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, + 0x00ED, 0x010E, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0005, 0x0006, 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, + 0x00ED, 0x010E, 0x012F, 0x014F, 0x016F, 0x018F, 0x05AF, 0x09CF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0005, 0x0006, 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, + 0x00ED, 0x010E, 0x012F, 0x014F, 0x056F, 0x098F, 0x0DAF, 0x11CF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0005, 0x0006, 0x0007, 0x0028, 0x0049, 0x006A, 0x008B, 0x00AC, + 0x00CD, 0x00EE, 0x050F, 0x092F, 0x0D4F, 0x116F, 0x158F, 0x19AF, + 0x1DCF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0005, 0x0006, 0x0007, 0x0028, 0x0049, 0x006A, 0x008B, 0x00AC, + 0x04CD, 0x08EE, 0x0D0F, 0x112F, 0x154F, 0x196F, 0x1D8F, 0x21AF, + 0x25CF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0005, 0x0006, 0x0007, 0x0008, 0x0029, 0x004A, 0x046B, 0x088C, + 0x0CAD, 0x10CE, 0x14EF, 0x190F, 0x1D2F, 0x214F, 0x256F, 0x298F, + 0x2DAF, 0x31CF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0005, 0x0006, 0x0007, 0x0008, 0x0429, 0x084A, 0x0C6B, 0x108C, + 0x14AD, 0x18CE, 0x1CEF, 0x210F, 0x252F, 0x294F, 0x2D6F, 0x318F, + 0x35AF, 0x39CF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0005, 0x0406, 0x0807, 0x0C08, 0x1029, 0x144A, 0x186B, 0x1C8C, + 0x20AD, 0x24CE, 0x28EF, 0x2D0F, 0x312F, 0x354F, 0x396F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0006, 0x0407, 0x0808, 0x0C09, 0x100A, 0x142B, 0x184C, 0x1C6D, + 0x208E, 0x24AF, 0x28CF, 0x2CEF, 0x310F, 0x352F, 0x394F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0806, 0x0C07, 0x1008, 0x1409, 0x180A, 0x1C2B, 0x204C, 0x246D, + 0x288E, 0x2CAF, 0x30CF, 0x34EF, 0x390F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1006, 0x1407, 0x1808, 0x1C09, 0x200A, 0x240B, 0x282C, 0x2C4D, + 0x306E, 0x348F, 0x38AF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1806, 0x1C07, 0x2008, 0x2409, 0x280A, 0x2C0B, 0x302C, 0x344D, + 0x386E, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2006, 0x2407, 0x2808, 0x2C09, 0x300A, 0x340B, 0x380C, 0x3C2D, + 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2806, 0x2C07, 0x3008, 0x3409, 0x380A, 0x3C0B, 0x3C0C, 0x3C2D, + 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3006, 0x3407, 0x3808, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C2D, + 0x3C4E, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3806, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C2E, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C2E, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C0E, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C0E, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C0E, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C0E, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C0E, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C06, 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, 0x010C, 0x012D, + 0x014E, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0046, 0x0067, 0x0088, 0x00A9, 0x00CA, 0x00EB, 0x010C, 0x012D, + 0x014E, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0026, 0x0047, 0x0068, 0x0089, 0x00AA, 0x00CB, 0x00EC, 0x010D, + 0x012E, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0026, 0x0047, 0x0068, 0x0089, 0x00AA, 0x00CB, 0x00EC, 0x010D, + 0x012E, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0006, 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, 0x00ED, + 0x010E, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0006, 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, 0x00ED, + 0x010E, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0006, 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, 0x00ED, + 0x010E, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0006, 0x0007, 0x0028, 0x0049, 0x006A, 0x008B, 0x00AC, 0x00CD, + 0x00EE, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0006, 0x0007, 0x0028, 0x0049, 0x006A, 0x008B, 0x00AC, 0x00CD, + 0x00EE, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0006, 0x0007, 0x0008, 0x0029, 0x004A, 0x006B, 0x008C, 0x00AD, + 0x00CE, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x058F, 0x09AF, + 0x0DCF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0006, 0x0007, 0x0008, 0x0029, 0x004A, 0x006B, 0x008C, 0x00AD, + 0x00CE, 0x00EF, 0x010F, 0x012F, 0x054F, 0x096F, 0x0D8F, 0x11AF, + 0x15CF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0006, 0x0007, 0x0008, 0x0029, 0x004A, 0x006B, 0x008C, 0x00AD, + 0x00CE, 0x00EF, 0x050F, 0x092F, 0x0D4F, 0x116F, 0x158F, 0x19AF, + 0x1DCF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0006, 0x0007, 0x0008, 0x0009, 0x002A, 0x004B, 0x006C, 0x008D, + 0x04AE, 0x08CF, 0x0CEF, 0x110F, 0x152F, 0x194F, 0x1D6F, 0x218F, + 0x25AF, 0x29CF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0006, 0x0007, 0x0008, 0x0009, 0x002A, 0x004B, 0x046C, 0x088D, + 0x0CAE, 0x10CF, 0x14EF, 0x190F, 0x1D2F, 0x214F, 0x256F, 0x298F, + 0x2DAF, 0x31CF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0006, 0x0007, 0x0008, 0x0009, 0x040A, 0x082B, 0x0C4C, 0x106D, + 0x148E, 0x18AF, 0x1CCF, 0x20EF, 0x250F, 0x292F, 0x2D4F, 0x316F, + 0x358F, 0x39AF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0006, 0x0407, 0x0808, 0x0C09, 0x100A, 0x142B, 0x184C, 0x1C6D, + 0x208E, 0x24AF, 0x28CF, 0x2CEF, 0x310F, 0x352F, 0x394F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0007, 0x0408, 0x0809, 0x0C0A, 0x100B, 0x140C, 0x182D, 0x1C4E, + 0x206F, 0x248F, 0x28AF, 0x2CCF, 0x30EF, 0x350F, 0x392F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0807, 0x0C08, 0x1009, 0x140A, 0x180B, 0x1C0C, 0x202D, 0x244E, + 0x286F, 0x2C8F, 0x30AF, 0x34CF, 0x38EF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1007, 0x1408, 0x1809, 0x1C0A, 0x200B, 0x240C, 0x282D, 0x2C4E, + 0x306F, 0x348F, 0x38AF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1807, 0x1C08, 0x2009, 0x240A, 0x280B, 0x2C0C, 0x300D, 0x342E, + 0x384F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2007, 0x2408, 0x2809, 0x2C0A, 0x300B, 0x340C, 0x380D, 0x3C2E, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2807, 0x2C08, 0x3009, 0x340A, 0x380B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3007, 0x3408, 0x3809, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3807, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C07, 0x3C08, 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, 0x00ED, 0x010E, + 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, 0x00ED, 0x010E, + 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0027, 0x0048, 0x0069, 0x008A, 0x00AB, 0x00CC, 0x00ED, 0x010E, + 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0007, 0x0028, 0x0049, 0x006A, 0x008B, 0x00AC, 0x00CD, 0x00EE, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0007, 0x0028, 0x0049, 0x006A, 0x008B, 0x00AC, 0x00CD, 0x00EE, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0007, 0x0008, 0x0029, 0x004A, 0x006B, 0x008C, 0x00AD, 0x00CE, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0007, 0x0008, 0x0029, 0x004A, 0x006B, 0x008C, 0x00AD, 0x00CE, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0007, 0x0008, 0x0029, 0x004A, 0x006B, 0x008C, 0x00AD, 0x00CE, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0007, 0x0008, 0x0009, 0x002A, 0x004B, 0x006C, 0x008D, 0x00AE, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x05CF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0007, 0x0008, 0x0009, 0x002A, 0x004B, 0x006C, 0x008D, 0x00AE, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x058F, 0x09AF, + 0x0DCF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0007, 0x0008, 0x0009, 0x000A, 0x002B, 0x004C, 0x006D, 0x008E, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x052F, 0x094F, 0x0D6F, 0x118F, + 0x15AF, 0x19CF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0007, 0x0008, 0x0009, 0x000A, 0x002B, 0x004C, 0x006D, 0x008E, + 0x00AF, 0x00CF, 0x04EF, 0x090F, 0x0D2F, 0x114F, 0x156F, 0x198F, + 0x1DAF, 0x21CF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0007, 0x0008, 0x0009, 0x000A, 0x002B, 0x004C, 0x006D, 0x008E, + 0x04AF, 0x08CF, 0x0CEF, 0x110F, 0x152F, 0x194F, 0x1D6F, 0x218F, + 0x25AF, 0x29CF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x002C, 0x044D, 0x086E, + 0x0C8F, 0x10AF, 0x14CF, 0x18EF, 0x1D0F, 0x212F, 0x254F, 0x296F, + 0x2D8F, 0x31AF, 0x35CF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0007, 0x0008, 0x0009, 0x000A, 0x040B, 0x082C, 0x0C4D, 0x106E, + 0x148F, 0x18AF, 0x1CCF, 0x20EF, 0x250F, 0x292F, 0x2D4F, 0x316F, + 0x358F, 0x39AF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0007, 0x0408, 0x0809, 0x0C0A, 0x100B, 0x140C, 0x182D, 0x1C4E, + 0x206F, 0x248F, 0x28AF, 0x2CCF, 0x30EF, 0x350F, 0x392F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0009, 0x040A, 0x080B, 0x0C0C, 0x100D, 0x140E, 0x182F, 0x1C4F, + 0x206F, 0x248F, 0x28AF, 0x2CCF, 0x30EF, 0x350F, 0x392F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0809, 0x0C0A, 0x100B, 0x140C, 0x180D, 0x1C0E, 0x200F, 0x242F, + 0x284F, 0x2C6F, 0x308F, 0x34AF, 0x38CF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1009, 0x140A, 0x180B, 0x1C0C, 0x200D, 0x240E, 0x280F, 0x2C2F, + 0x304F, 0x346F, 0x388F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1809, 0x1C0A, 0x200B, 0x240C, 0x280D, 0x2C0E, 0x300F, 0x342F, + 0x384F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2009, 0x240A, 0x280B, 0x2C0C, 0x300D, 0x340E, 0x380F, 0x3C0F, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2809, 0x2C0A, 0x300B, 0x340C, 0x380D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3009, 0x340A, 0x380B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3809, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C09, 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0029, 0x004A, 0x006B, 0x008C, 0x00AD, 0x00CE, 0x00EF, 0x010F, + 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0009, 0x002A, 0x004B, 0x006C, 0x008D, 0x00AE, 0x00CF, 0x00EF, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0009, 0x002A, 0x004B, 0x006C, 0x008D, 0x00AE, 0x00CF, 0x00EF, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0009, 0x002A, 0x004B, 0x006C, 0x008D, 0x00AE, 0x00CF, 0x00EF, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0009, 0x000A, 0x002B, 0x004C, 0x006D, 0x008E, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0009, 0x000A, 0x002B, 0x004C, 0x006D, 0x008E, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0009, 0x000A, 0x000B, 0x002C, 0x004D, 0x006E, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0009, 0x000A, 0x000B, 0x002C, 0x004D, 0x006E, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0009, 0x000A, 0x000B, 0x002C, 0x004D, 0x006E, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x05CF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0009, 0x000A, 0x000B, 0x000C, 0x002D, 0x004E, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x056F, 0x098F, + 0x0DAF, 0x11CF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0009, 0x000A, 0x000B, 0x000C, 0x002D, 0x004E, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x052F, 0x094F, 0x0D6F, 0x118F, + 0x15AF, 0x19CF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x04CF, 0x08EF, 0x0D0F, 0x112F, 0x154F, 0x196F, + 0x1D8F, 0x21AF, 0x25CF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, + 0x048F, 0x08AF, 0x0CCF, 0x10EF, 0x150F, 0x192F, 0x1D4F, 0x216F, + 0x258F, 0x29AF, 0x2DCF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x002E, 0x044F, 0x086F, + 0x0C8F, 0x10AF, 0x14CF, 0x18EF, 0x1D0F, 0x212F, 0x254F, 0x296F, + 0x2D8F, 0x31AF, 0x35CF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0009, 0x000A, 0x000B, 0x000C, 0x040D, 0x080E, 0x0C2F, 0x104F, + 0x146F, 0x188F, 0x1CAF, 0x20CF, 0x24EF, 0x290F, 0x2D2F, 0x314F, + 0x356F, 0x398F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0009, 0x040A, 0x080B, 0x0C0C, 0x100D, 0x140E, 0x182F, 0x1C4F, + 0x206F, 0x248F, 0x28AF, 0x2CCF, 0x30EF, 0x350F, 0x392F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x040B, 0x080C, 0x0C0D, 0x100E, 0x140F, 0x180F, 0x1C2F, + 0x204F, 0x246F, 0x288F, 0x2CAF, 0x30CF, 0x34EF, 0x390F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x080A, 0x0C0B, 0x100C, 0x140D, 0x180E, 0x1C0F, 0x200F, 0x242F, + 0x284F, 0x2C6F, 0x308F, 0x34AF, 0x38CF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x100A, 0x140B, 0x180C, 0x1C0D, 0x200E, 0x240F, 0x280F, 0x2C0F, + 0x302F, 0x344F, 0x386F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x180A, 0x1C0B, 0x200C, 0x240D, 0x280E, 0x2C0F, 0x300F, 0x340F, + 0x382F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x200A, 0x240B, 0x280C, 0x2C0D, 0x300E, 0x340F, 0x380F, 0x3C0F, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x280A, 0x2C0B, 0x300C, 0x340D, 0x380E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x300A, 0x340B, 0x380C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x380A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0A, 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x002B, 0x004C, 0x006D, 0x008E, 0x00AF, 0x00CF, 0x00EF, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x000A, 0x002B, 0x004C, 0x006D, 0x008E, 0x00AF, 0x00CF, 0x00EF, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x000A, 0x000B, 0x002C, 0x004D, 0x006E, 0x008F, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x000A, 0x000B, 0x002C, 0x004D, 0x006E, 0x008F, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x000A, 0x000B, 0x002C, 0x004D, 0x006E, 0x008F, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x000A, 0x000B, 0x000C, 0x002D, 0x004E, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x000A, 0x000B, 0x000C, 0x002D, 0x004E, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x05AF, 0x09CF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x056F, 0x098F, + 0x0DAF, 0x11CF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x050F, 0x092F, 0x0D4F, 0x116F, + 0x158F, 0x19AF, 0x1DCF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x04CF, 0x08EF, 0x0D0F, 0x112F, 0x154F, 0x196F, + 0x1D8F, 0x21AF, 0x25CF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, + 0x046F, 0x088F, 0x0CAF, 0x10CF, 0x14EF, 0x190F, 0x1D2F, 0x214F, + 0x256F, 0x298F, 0x2DAF, 0x31CF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x042F, 0x084F, + 0x0C6F, 0x108F, 0x14AF, 0x18CF, 0x1CEF, 0x210F, 0x252F, 0x294F, + 0x2D6F, 0x318F, 0x35AF, 0x39CF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x000B, 0x000C, 0x000D, 0x040E, 0x080F, 0x0C2F, 0x104F, + 0x146F, 0x188F, 0x1CAF, 0x20CF, 0x24EF, 0x290F, 0x2D2F, 0x314F, + 0x356F, 0x398F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000A, 0x040B, 0x080C, 0x0C0D, 0x100E, 0x140F, 0x180F, 0x1C2F, + 0x204F, 0x246F, 0x288F, 0x2CAF, 0x30CF, 0x34EF, 0x390F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x040C, 0x080D, 0x0C0E, 0x100F, 0x140F, 0x180F, 0x1C2F, + 0x204F, 0x246F, 0x288F, 0x2CAF, 0x30CF, 0x34EF, 0x390F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x080B, 0x0C0C, 0x100D, 0x140E, 0x180F, 0x1C0F, 0x200F, 0x240F, + 0x282F, 0x2C4F, 0x306F, 0x348F, 0x38AF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x100B, 0x140C, 0x180D, 0x1C0E, 0x200F, 0x240F, 0x280F, 0x2C0F, + 0x302F, 0x344F, 0x386F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x180B, 0x1C0C, 0x200D, 0x240E, 0x280F, 0x2C0F, 0x300F, 0x340F, + 0x382F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x200B, 0x240C, 0x280D, 0x2C0E, 0x300F, 0x340F, 0x380F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x280B, 0x2C0C, 0x300D, 0x340E, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x300B, 0x340C, 0x380D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x380B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0B, 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x002C, 0x004D, 0x006E, 0x008F, 0x00AF, 0x00CF, 0x00EF, + 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x000B, 0x000C, 0x002D, 0x004E, 0x006F, 0x008F, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x000B, 0x000C, 0x002D, 0x004E, 0x006F, 0x008F, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x000B, 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x058F, 0x09AF, 0x0DCF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x054F, 0x096F, + 0x0D8F, 0x11AF, 0x15CF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x050F, 0x092F, 0x0D4F, 0x116F, + 0x158F, 0x19AF, 0x1DCF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x04AF, 0x08CF, 0x0CEF, 0x110F, 0x152F, 0x194F, + 0x1D6F, 0x218F, 0x25AF, 0x29CF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x002F, 0x004F, + 0x046F, 0x088F, 0x0CAF, 0x10CF, 0x14EF, 0x190F, 0x1D2F, 0x214F, + 0x256F, 0x298F, 0x2DAF, 0x31CF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x040F, 0x082F, + 0x0C4F, 0x106F, 0x148F, 0x18AF, 0x1CCF, 0x20EF, 0x250F, 0x292F, + 0x2D4F, 0x316F, 0x358F, 0x39AF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x000C, 0x000D, 0x000E, 0x040F, 0x080F, 0x0C0F, 0x102F, + 0x144F, 0x186F, 0x1C8F, 0x20AF, 0x24CF, 0x28EF, 0x2D0F, 0x312F, + 0x354F, 0x396F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000B, 0x040C, 0x080D, 0x0C0E, 0x100F, 0x140F, 0x180F, 0x1C2F, + 0x204F, 0x246F, 0x288F, 0x2CAF, 0x30CF, 0x34EF, 0x390F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x040D, 0x080E, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x202F, 0x244F, 0x286F, 0x2C8F, 0x30AF, 0x34CF, 0x38EF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x080C, 0x0C0D, 0x100E, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, + 0x282F, 0x2C4F, 0x306F, 0x348F, 0x38AF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x100C, 0x140D, 0x180E, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, + 0x300F, 0x342F, 0x384F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x180C, 0x1C0D, 0x200E, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, + 0x380F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x200C, 0x240D, 0x280E, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, + 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x280C, 0x2C0D, 0x300E, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x300C, 0x340D, 0x380E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x380C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0C, 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x000C, 0x000D, 0x002E, 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, + 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, 0x01CF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x000C, 0x000D, 0x000E, 0x002F, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x000C, 0x000D, 0x000E, 0x002F, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x05CF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x058F, 0x09AF, 0x0DCF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x052F, 0x094F, + 0x0D6F, 0x118F, 0x15AF, 0x19CF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x04EF, 0x090F, 0x0D2F, 0x114F, + 0x156F, 0x198F, 0x1DAF, 0x21CF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x04AF, 0x08CF, 0x0CEF, 0x110F, 0x152F, 0x194F, + 0x1D6F, 0x218F, 0x25AF, 0x29CF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x044F, 0x086F, 0x0C8F, 0x10AF, 0x14CF, 0x18EF, 0x1D0F, 0x212F, + 0x254F, 0x296F, 0x2D8F, 0x31AF, 0x35CF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x040F, 0x082F, + 0x0C4F, 0x106F, 0x148F, 0x18AF, 0x1CCF, 0x20EF, 0x250F, 0x292F, + 0x2D4F, 0x316F, 0x358F, 0x39AF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x000D, 0x000E, 0x000F, 0x040F, 0x080F, 0x0C0F, 0x102F, + 0x144F, 0x186F, 0x1C8F, 0x20AF, 0x24CF, 0x28EF, 0x2D0F, 0x312F, + 0x354F, 0x396F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000C, 0x040D, 0x080E, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x202F, 0x244F, 0x286F, 0x2C8F, 0x30AF, 0x34CF, 0x38EF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x040E, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x202F, 0x244F, 0x286F, 0x2C8F, 0x30AF, 0x34CF, 0x38EF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x080D, 0x0C0E, 0x100F, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, + 0x280F, 0x2C2F, 0x304F, 0x346F, 0x388F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x100D, 0x140E, 0x180F, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, + 0x300F, 0x342F, 0x384F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x180D, 0x1C0E, 0x200F, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, + 0x380F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x200D, 0x240E, 0x280F, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x280D, 0x2C0E, 0x300F, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x300D, 0x340E, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x380D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0D, 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x000D, 0x000E, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x05CF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x056F, 0x098F, 0x0DAF, 0x11CF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x052F, 0x094F, + 0x0D6F, 0x118F, 0x15AF, 0x19CF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x04EF, 0x090F, 0x0D2F, 0x114F, + 0x156F, 0x198F, 0x1DAF, 0x21CF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x048F, 0x08AF, 0x0CCF, 0x10EF, 0x150F, 0x192F, + 0x1D4F, 0x216F, 0x258F, 0x29AF, 0x2DCF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x044F, 0x086F, 0x0C8F, 0x10AF, 0x14CF, 0x18EF, 0x1D0F, 0x212F, + 0x254F, 0x296F, 0x2D8F, 0x31AF, 0x35CF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x040F, 0x080F, + 0x0C2F, 0x104F, 0x146F, 0x188F, 0x1CAF, 0x20CF, 0x24EF, 0x290F, + 0x2D2F, 0x314F, 0x356F, 0x398F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x000E, 0x000F, 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, + 0x142F, 0x184F, 0x1C6F, 0x208F, 0x24AF, 0x28CF, 0x2CEF, 0x310F, + 0x352F, 0x394F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000D, 0x040E, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x202F, 0x244F, 0x286F, 0x2C8F, 0x30AF, 0x34CF, 0x38EF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x040F, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x200F, 0x242F, 0x284F, 0x2C6F, 0x308F, 0x34AF, 0x38CF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x080E, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, + 0x280F, 0x2C2F, 0x304F, 0x346F, 0x388F, 0x3CAF, 0x3CCF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x100E, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, + 0x300F, 0x340F, 0x382F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x180E, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, + 0x380F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x200E, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x280E, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x300E, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x380E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0E, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, 0x00AF, + 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, 0x01AF, + 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x016F, 0x018F, 0x05AF, 0x09CF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x056F, 0x098F, 0x0DAF, 0x11CF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x050F, 0x092F, + 0x0D4F, 0x116F, 0x158F, 0x19AF, 0x1DCF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x008F, 0x00AF, 0x04CF, 0x08EF, 0x0D0F, 0x112F, + 0x154F, 0x196F, 0x1D8F, 0x21AF, 0x25CF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x048F, 0x08AF, 0x0CCF, 0x10EF, 0x150F, 0x192F, + 0x1D4F, 0x216F, 0x258F, 0x29AF, 0x2DCF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x042F, 0x084F, 0x0C6F, 0x108F, 0x14AF, 0x18CF, 0x1CEF, 0x210F, + 0x252F, 0x294F, 0x2D6F, 0x318F, 0x35AF, 0x39CF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x040F, 0x080F, + 0x0C2F, 0x104F, 0x146F, 0x188F, 0x1CAF, 0x20CF, 0x24EF, 0x290F, + 0x2D2F, 0x314F, 0x356F, 0x398F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x000F, 0x000F, 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, + 0x140F, 0x182F, 0x1C4F, 0x206F, 0x248F, 0x28AF, 0x2CCF, 0x30EF, + 0x350F, 0x392F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000E, 0x040F, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x200F, 0x242F, 0x284F, 0x2C6F, 0x308F, 0x34AF, 0x38CF, 0x3CEF, + 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x200F, 0x240F, 0x282F, 0x2C4F, 0x306F, 0x348F, 0x38AF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, + 0x280F, 0x2C0F, 0x302F, 0x344F, 0x386F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x100F, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, + 0x300F, 0x340F, 0x382F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x180F, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, + 0x380F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x200F, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x280F, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x300F, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x016F, 0x018F, 0x01AF, 0x01CF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x016F, 0x018F, 0x05AF, 0x09CF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, + 0x054F, 0x096F, 0x0D8F, 0x11AF, 0x15CF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x050F, 0x092F, + 0x0D4F, 0x116F, 0x158F, 0x19AF, 0x1DCF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x002F, 0x004F, 0x006F, 0x008F, 0x04AF, 0x08CF, 0x0CEF, 0x110F, + 0x152F, 0x194F, 0x1D6F, 0x218F, 0x25AF, 0x29CF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x002F, 0x004F, 0x046F, 0x088F, 0x0CAF, 0x10CF, 0x14EF, 0x190F, + 0x1D2F, 0x214F, 0x256F, 0x298F, 0x2DAF, 0x31CF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x042F, 0x084F, 0x0C6F, 0x108F, 0x14AF, 0x18CF, 0x1CEF, 0x210F, + 0x252F, 0x294F, 0x2D6F, 0x318F, 0x35AF, 0x39CF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x040F, 0x080F, + 0x0C0F, 0x102F, 0x144F, 0x186F, 0x1C8F, 0x20AF, 0x24CF, 0x28EF, + 0x2D0F, 0x312F, 0x354F, 0x396F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, + 0x140F, 0x182F, 0x1C4F, 0x206F, 0x248F, 0x28AF, 0x2CCF, 0x30EF, + 0x350F, 0x392F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x200F, 0x240F, 0x282F, 0x2C4F, 0x306F, 0x348F, 0x38AF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x200F, 0x240F, 0x282F, 0x2C4F, 0x306F, 0x348F, 0x38AF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, + 0x280F, 0x2C0F, 0x300F, 0x342F, 0x384F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x100F, 0x140F, 0x180F, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, + 0x300F, 0x340F, 0x380F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x180F, 0x1C0F, 0x200F, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, + 0x380F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, + 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x200F, 0x240F, 0x280F, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x280F, 0x2C0F, 0x300F, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, + 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x300F, 0x340F, 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x380F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, 0x3C6F, + 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, 0x3C4F, + 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C2F, + 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, 0x3C0F, + 0x3C2F, 0x3C4F, 0x3C6F, 0x3C8F, 0x3CAF, 0x3CCF, 0x3CEF, 0x3D0F, + 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, 0x008F, + 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, 0x018F, + 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, 0x006F, + 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, 0x016F, + 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, 0x004F, + 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, 0x014F, + 0x016F, 0x018F, 0x01AF, 0x01CF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, + 0x014F, 0x016F, 0x018F, 0x01AF, 0x05CF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, + 0x014F, 0x016F, 0x058F, 0x09AF, 0x0DCF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x002F, + 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, 0x00EF, 0x010F, 0x012F, + 0x054F, 0x096F, 0x0D8F, 0x11AF, 0x15CF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x002F, 0x004F, 0x006F, 0x008F, 0x00AF, 0x00CF, 0x04EF, 0x090F, + 0x0D2F, 0x114F, 0x156F, 0x198F, 0x1DAF, 0x21CF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x002F, 0x004F, 0x006F, 0x008F, 0x04AF, 0x08CF, 0x0CEF, 0x110F, + 0x152F, 0x194F, 0x1D6F, 0x218F, 0x25AF, 0x29CF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x000F, 0x002F, 0x044F, 0x086F, 0x0C8F, 0x10AF, 0x14CF, 0x18EF, + 0x1D0F, 0x212F, 0x254F, 0x296F, 0x2D8F, 0x31AF, 0x35CF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, + 0x040F, 0x082F, 0x0C4F, 0x106F, 0x148F, 0x18AF, 0x1CCF, 0x20EF, + 0x250F, 0x292F, 0x2D4F, 0x316F, 0x358F, 0x39AF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x040F, 0x080F, + 0x0C0F, 0x102F, 0x144F, 0x186F, 0x1C8F, 0x20AF, 0x24CF, 0x28EF, + 0x2D0F, 0x312F, 0x354F, 0x396F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x000F, 0x000F, 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, + 0x140F, 0x180F, 0x1C2F, 0x204F, 0x246F, 0x288F, 0x2CAF, 0x30CF, + 0x34EF, 0x390F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x000F, 0x040F, 0x080F, 0x0C0F, 0x100F, 0x140F, 0x180F, 0x1C0F, + 0x200F, 0x240F, 0x282F, 0x2C4F, 0x306F, 0x348F, 0x38AF, 0x3CCF, + 0x3CEF, 0x3D0F, 0x3D2F, 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0100, 0x0520, 0x0940, 0x0D60, 0x1180, 0x15A0, 0x19C0, 0x1DE0, + 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0900, 0x0D20, 0x1140, 0x1560, 0x1980, 0x1DA0, 0x21C0, 0x25E0, + 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x10E0, 0x1500, 0x1920, 0x1D40, 0x2160, 0x2580, 0x29A0, 0x2DC0, + 0x31E0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x18E0, 0x1D00, 0x2120, 0x2540, 0x2960, 0x2D80, 0x31A0, 0x35C0, + 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x20E0, 0x2500, 0x2920, 0x2D40, 0x3160, 0x3580, 0x39A0, 0x3DC0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x28C0, 0x2CE0, 0x3100, 0x3520, 0x3940, 0x3D60, 0x3D80, 0x3DA0, + 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x30C0, 0x34E0, 0x3900, 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, + 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x38A0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x05EC, 0x09ED, + 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x05EA, 0x09EB, 0x0DEC, 0x11ED, + 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x05E8, 0x09E9, 0x0DEA, 0x11EB, 0x15EC, 0x19ED, + 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x05E6, 0x09E7, 0x0DE8, 0x11E9, 0x15EA, 0x19EB, 0x1DEC, 0x21ED, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x05E4, 0x09E5, + 0x0DE6, 0x11E7, 0x15E8, 0x19E9, 0x1DEA, 0x21EB, 0x25EC, 0x29ED, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x05E2, 0x09E3, 0x0DE4, 0x11E5, + 0x15E6, 0x19E7, 0x1DE8, 0x21E9, 0x25EA, 0x29EB, 0x2DEC, 0x31ED, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x05E0, 0x09E1, 0x0DE2, 0x11E3, 0x15E4, 0x19E5, + 0x1DE6, 0x21E7, 0x25E8, 0x29E9, 0x2DEA, 0x31EB, 0x35EC, 0x39ED, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x05E0, 0x09E0, 0x0DE0, 0x11E1, 0x15E2, 0x19E3, 0x1DE4, 0x21E5, + 0x25E6, 0x29E7, 0x2DE8, 0x31E9, 0x35EA, 0x39EB, 0x3DEC, 0x3DED, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, + 0x0DE0, 0x11E0, 0x15E0, 0x19E1, 0x1DE2, 0x21E3, 0x25E4, 0x29E5, + 0x2DE6, 0x31E7, 0x35E8, 0x39E9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, + 0x15E0, 0x19E0, 0x1DE0, 0x21E1, 0x25E2, 0x29E3, 0x2DE4, 0x31E5, + 0x35E6, 0x39E7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, + 0x1DE0, 0x21E0, 0x25E0, 0x29E1, 0x2DE2, 0x31E3, 0x35E4, 0x39E5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, + 0x25E0, 0x29E0, 0x2DE0, 0x31E1, 0x35E2, 0x39E3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x05E0, 0x09E0, + 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, + 0x2DE0, 0x31E0, 0x35E0, 0x39E1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0120, 0x0140, 0x0160, 0x0180, 0x05A0, 0x09C0, 0x0DE0, 0x11E0, + 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, + 0x35E0, 0x39E0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0100, 0x0520, 0x0940, 0x0D60, 0x1180, 0x15A0, 0x19C0, 0x1DE0, + 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, + 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x0100, 0x0520, 0x0940, 0x0D60, 0x1180, 0x15A0, 0x19C0, 0x1DE0, + 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x08E0, 0x0D00, 0x1120, 0x1540, 0x1960, 0x1D80, 0x21A0, 0x25C0, + 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x10E0, 0x1500, 0x1920, 0x1D40, 0x2160, 0x2580, 0x29A0, 0x2DC0, + 0x31E0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x18C0, 0x1CE0, 0x2100, 0x2520, 0x2940, 0x2D60, 0x3180, 0x35A0, + 0x39C0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x20C0, 0x24E0, 0x2900, 0x2D20, 0x3140, 0x3560, 0x3980, 0x3DA0, + 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x28C0, 0x2CE0, 0x3100, 0x3520, 0x3940, 0x3D60, 0x3D80, 0x3DA0, + 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x30A0, 0x34C0, 0x38E0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x38A0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x05EE, 0x09EF, + 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x05EC, 0x09ED, 0x0DEE, 0x11EF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x05EA, 0x09EB, 0x0DEC, 0x11ED, 0x15EE, 0x19EF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x05E8, 0x09E9, 0x0DEA, 0x11EB, 0x15EC, 0x19ED, 0x1DEE, 0x21EF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x05E6, 0x09E7, + 0x0DE8, 0x11E9, 0x15EA, 0x19EB, 0x1DEC, 0x21ED, 0x25EE, 0x29EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x05E4, 0x09E5, 0x0DE6, 0x11E7, + 0x15E8, 0x19E9, 0x1DEA, 0x21EB, 0x25EC, 0x29ED, 0x2DEE, 0x31EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x05E2, 0x09E3, 0x0DE4, 0x11E5, 0x15E6, 0x19E7, + 0x1DE8, 0x21E9, 0x25EA, 0x29EB, 0x2DEC, 0x31ED, 0x35EE, 0x39EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x05E0, 0x09E1, 0x0DE2, 0x11E3, 0x15E4, 0x19E5, 0x1DE6, 0x21E7, + 0x25E8, 0x29E9, 0x2DEA, 0x31EB, 0x35EC, 0x39ED, 0x3DEE, 0x3DEF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, + 0x0DE0, 0x11E1, 0x15E2, 0x19E3, 0x1DE4, 0x21E5, 0x25E6, 0x29E7, + 0x2DE8, 0x31E9, 0x35EA, 0x39EB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, + 0x15E0, 0x19E1, 0x1DE2, 0x21E3, 0x25E4, 0x29E5, 0x2DE6, 0x31E7, + 0x35E8, 0x39E9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, + 0x1DE0, 0x21E1, 0x25E2, 0x29E3, 0x2DE4, 0x31E5, 0x35E6, 0x39E7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, + 0x25E0, 0x29E1, 0x2DE2, 0x31E3, 0x35E4, 0x39E5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x05C0, 0x09E0, + 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, + 0x2DE0, 0x31E1, 0x35E2, 0x39E3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0580, 0x09A0, 0x0DC0, 0x11E0, + 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, + 0x35E0, 0x39E1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x0100, 0x0520, 0x0940, 0x0D60, 0x1180, 0x15A0, 0x19C0, 0x1DE0, + 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, + 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x00E0, 0x0500, 0x0920, 0x0D40, 0x1160, 0x1580, 0x19A0, 0x1DC0, + 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x08E0, 0x0D00, 0x1120, 0x1540, 0x1960, 0x1D80, 0x21A0, 0x25C0, + 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x10C0, 0x14E0, 0x1900, 0x1D20, 0x2140, 0x2560, 0x2980, 0x2DA0, + 0x31C0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x18C0, 0x1CE0, 0x2100, 0x2520, 0x2940, 0x2D60, 0x3180, 0x35A0, + 0x39C0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x20A0, 0x24C0, 0x28E0, 0x2D00, 0x3120, 0x3540, 0x3960, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x28A0, 0x2CC0, 0x30E0, 0x3500, 0x3920, 0x3D40, 0x3D60, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x30A0, 0x34C0, 0x38E0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3880, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x05EF, 0x09EF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x05ED, 0x09EE, 0x0DEF, 0x11EF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x05EB, 0x09EC, 0x0DED, 0x11EE, 0x15EF, 0x19EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x05E9, 0x09EA, 0x0DEB, 0x11EC, 0x15ED, 0x19EE, 0x1DEF, 0x21EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x05E7, 0x09E8, + 0x0DE9, 0x11EA, 0x15EB, 0x19EC, 0x1DED, 0x21EE, 0x25EF, 0x29EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x05E5, 0x09E6, 0x0DE7, 0x11E8, + 0x15E9, 0x19EA, 0x1DEB, 0x21EC, 0x25ED, 0x29EE, 0x2DEF, 0x31EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x05E3, 0x09E4, 0x0DE5, 0x11E6, 0x15E7, 0x19E8, + 0x1DE9, 0x21EA, 0x25EB, 0x29EC, 0x2DED, 0x31EE, 0x35EF, 0x39EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x05E1, 0x09E2, 0x0DE3, 0x11E4, 0x15E5, 0x19E6, 0x1DE7, 0x21E8, + 0x25E9, 0x29EA, 0x2DEB, 0x31EC, 0x35ED, 0x39EE, 0x3DEF, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, + 0x0DE1, 0x11E2, 0x15E3, 0x19E4, 0x1DE5, 0x21E6, 0x25E7, 0x29E8, + 0x2DE9, 0x31EA, 0x35EB, 0x39EC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, + 0x15E1, 0x19E2, 0x1DE3, 0x21E4, 0x25E5, 0x29E6, 0x2DE7, 0x31E8, + 0x35E9, 0x39EA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, + 0x1DE1, 0x21E2, 0x25E3, 0x29E4, 0x2DE5, 0x31E6, 0x35E7, 0x39E8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, + 0x25E1, 0x29E2, 0x2DE3, 0x31E4, 0x35E5, 0x39E6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x05C0, 0x09E0, + 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, + 0x2DE1, 0x31E2, 0x35E3, 0x39E4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0560, 0x0980, 0x0DA0, 0x11C0, + 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, + 0x35E1, 0x39E2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x00E0, 0x0500, 0x0920, 0x0D40, 0x1160, 0x1580, 0x19A0, 0x1DC0, + 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, + 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x00C0, 0x04E0, 0x0900, 0x0D20, 0x1140, 0x1560, 0x1980, 0x1DA0, + 0x21C0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x08C0, 0x0CE0, 0x1100, 0x1520, 0x1940, 0x1D60, 0x2180, 0x25A0, + 0x29C0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x10C0, 0x14E0, 0x1900, 0x1D20, 0x2140, 0x2560, 0x2980, 0x2DA0, + 0x31C0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x18A0, 0x1CC0, 0x20E0, 0x2500, 0x2920, 0x2D40, 0x3160, 0x3580, + 0x39A0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x20A0, 0x24C0, 0x28E0, 0x2D00, 0x3120, 0x3540, 0x3960, 0x3D80, + 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2880, 0x2CA0, 0x30C0, 0x34E0, 0x3900, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3080, 0x34A0, 0x38C0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3880, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x05EF, 0x09EF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x05EE, 0x09EF, 0x0DEF, 0x11EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x05EC, 0x09ED, 0x0DEE, 0x11EF, 0x15EF, 0x19EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x05EA, 0x09EB, 0x0DEC, 0x11ED, 0x15EE, 0x19EF, 0x1DEF, 0x21EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x05E8, 0x09E9, + 0x0DEA, 0x11EB, 0x15EC, 0x19ED, 0x1DEE, 0x21EF, 0x25EF, 0x29EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x05E6, 0x09E7, 0x0DE8, 0x11E9, + 0x15EA, 0x19EB, 0x1DEC, 0x21ED, 0x25EE, 0x29EF, 0x2DEF, 0x31EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x01E2, 0x01E3, 0x05E4, 0x09E5, 0x0DE6, 0x11E7, 0x15E8, 0x19E9, + 0x1DEA, 0x21EB, 0x25EC, 0x29ED, 0x2DEE, 0x31EF, 0x35EF, 0x39EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, + 0x05E2, 0x09E3, 0x0DE4, 0x11E5, 0x15E6, 0x19E7, 0x1DE8, 0x21E9, + 0x25EA, 0x29EB, 0x2DEC, 0x31ED, 0x35EE, 0x39EF, 0x3DEF, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E1, + 0x0DE2, 0x11E3, 0x15E4, 0x19E5, 0x1DE6, 0x21E7, 0x25E8, 0x29E9, + 0x2DEA, 0x31EB, 0x35EC, 0x39ED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E1, + 0x15E2, 0x19E3, 0x1DE4, 0x21E5, 0x25E6, 0x29E7, 0x2DE8, 0x31E9, + 0x35EA, 0x39EB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E1, + 0x1DE2, 0x21E3, 0x25E4, 0x29E5, 0x2DE6, 0x31E7, 0x35E8, 0x39E9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E1, + 0x25E2, 0x29E3, 0x2DE4, 0x31E5, 0x35E6, 0x39E7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x05A0, 0x09C0, + 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E1, + 0x2DE2, 0x31E3, 0x35E4, 0x39E5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0560, 0x0980, 0x0DA0, 0x11C0, + 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, 0x2DE0, 0x31E1, + 0x35E2, 0x39E3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x04E0, 0x0900, 0x0D20, 0x1140, 0x1560, 0x1980, 0x1DA0, + 0x21C0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E0, 0x3DE1, + 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x04E0, 0x0900, 0x0D20, 0x1140, 0x1560, 0x1980, 0x1DA0, + 0x21C0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x08A0, 0x0CC0, 0x10E0, 0x1500, 0x1920, 0x1D40, 0x2160, 0x2580, + 0x29A0, 0x2DC0, 0x31E0, 0x35E0, 0x39E0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x10A0, 0x14C0, 0x18E0, 0x1D00, 0x2120, 0x2540, 0x2960, 0x2D80, + 0x31A0, 0x35C0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x18A0, 0x1CC0, 0x20E0, 0x2500, 0x2920, 0x2D40, 0x3160, 0x3580, + 0x39A0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2080, 0x24A0, 0x28C0, 0x2CE0, 0x3100, 0x3520, 0x3940, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2880, 0x2CA0, 0x30C0, 0x34E0, 0x3900, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3080, 0x34A0, 0x38C0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3860, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x05ED, 0x09EE, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x05EB, 0x09EC, 0x0DED, 0x11EE, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x05E9, 0x09EA, + 0x0DEB, 0x11EC, 0x15ED, 0x19EE, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x05E7, 0x09E8, 0x0DE9, 0x11EA, + 0x15EB, 0x19EC, 0x1DED, 0x21EE, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x01E3, 0x01E4, 0x05E5, 0x09E6, 0x0DE7, 0x11E8, 0x15E9, 0x19EA, + 0x1DEB, 0x21EC, 0x25ED, 0x29EE, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, + 0x05E3, 0x09E4, 0x0DE5, 0x11E6, 0x15E7, 0x19E8, 0x1DE9, 0x21EA, + 0x25EB, 0x29EC, 0x2DED, 0x31EE, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E1, 0x09E2, + 0x0DE3, 0x11E4, 0x15E5, 0x19E6, 0x1DE7, 0x21E8, 0x25E9, 0x29EA, + 0x2DEB, 0x31EC, 0x35ED, 0x39EE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE1, 0x11E2, + 0x15E3, 0x19E4, 0x1DE5, 0x21E6, 0x25E7, 0x29E8, 0x2DE9, 0x31EA, + 0x35EB, 0x39EC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E1, 0x19E2, + 0x1DE3, 0x21E4, 0x25E5, 0x29E6, 0x2DE7, 0x31E8, 0x35E9, 0x39EA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x05E0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE1, 0x21E2, + 0x25E3, 0x29E4, 0x2DE5, 0x31E6, 0x35E7, 0x39E8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x05A0, 0x09C0, + 0x0DE0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E0, 0x25E1, 0x29E2, + 0x2DE3, 0x31E4, 0x35E5, 0x39E6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0540, 0x0960, 0x0D80, 0x11A0, + 0x15C0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E0, 0x2DE1, 0x31E2, + 0x35E3, 0x39E4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x04E0, 0x0900, 0x0D20, 0x1140, 0x1560, 0x1980, 0x1DA0, + 0x21C0, 0x25E0, 0x29E0, 0x2DE0, 0x31E0, 0x35E0, 0x39E1, 0x3DE2, + 0x3DE3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x04C0, 0x08E0, 0x0D00, 0x1120, 0x1540, 0x1960, 0x1D80, + 0x21A0, 0x25C0, 0x29E0, 0x2DE0, 0x31E0, 0x35E1, 0x39E2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x08A0, 0x0CC0, 0x10E0, 0x1500, 0x1920, 0x1D40, 0x2160, 0x2580, + 0x29A0, 0x2DC0, 0x31E0, 0x35E0, 0x39E0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x10A0, 0x14C0, 0x18E0, 0x1D00, 0x2120, 0x2540, 0x2960, 0x2D80, + 0x31A0, 0x35C0, 0x39E0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1880, 0x1CA0, 0x20C0, 0x24E0, 0x2900, 0x2D20, 0x3140, 0x3560, + 0x3980, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2080, 0x24A0, 0x28C0, 0x2CE0, 0x3100, 0x3520, 0x3940, 0x3D60, + 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2860, 0x2C80, 0x30A0, 0x34C0, 0x38E0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3060, 0x3480, 0x38A0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3860, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA1, 0x3DC2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA1, 0x3DC2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D81, 0x3DA2, 0x3DC3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x05EE, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x05EC, 0x09ED, 0x0DEE, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x05EA, 0x09EB, + 0x0DEC, 0x11ED, 0x15EE, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x05E8, 0x09E9, 0x0DEA, 0x11EB, + 0x15EC, 0x19ED, 0x1DEE, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x01E4, 0x01E5, 0x05E6, 0x09E7, 0x0DE8, 0x11E9, 0x15EA, 0x19EB, + 0x1DEC, 0x21ED, 0x25EE, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, + 0x05E4, 0x09E5, 0x0DE6, 0x11E7, 0x15E8, 0x19E9, 0x1DEA, 0x21EB, + 0x25EC, 0x29ED, 0x2DEE, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x05E2, 0x09E3, + 0x0DE4, 0x11E5, 0x15E6, 0x19E7, 0x1DE8, 0x21E9, 0x25EA, 0x29EB, + 0x2DEC, 0x31ED, 0x35EE, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E0, 0x09E1, 0x0DE2, 0x11E3, + 0x15E4, 0x19E5, 0x1DE6, 0x21E7, 0x25E8, 0x29E9, 0x2DEA, 0x31EB, + 0x35EC, 0x39ED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x05E0, 0x09E0, 0x0DE0, 0x11E1, 0x15E2, 0x19E3, + 0x1DE4, 0x21E5, 0x25E6, 0x29E7, 0x2DE8, 0x31E9, 0x35EA, 0x39EB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x05C0, 0x09E0, 0x0DE0, 0x11E0, 0x15E0, 0x19E1, 0x1DE2, 0x21E3, + 0x25E4, 0x29E5, 0x2DE6, 0x31E7, 0x35E8, 0x39E9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0580, 0x09A0, + 0x0DC0, 0x11E0, 0x15E0, 0x19E0, 0x1DE0, 0x21E1, 0x25E2, 0x29E3, + 0x2DE4, 0x31E5, 0x35E6, 0x39E7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0540, 0x0960, 0x0D80, 0x11A0, + 0x15C0, 0x19E0, 0x1DE0, 0x21E0, 0x25E0, 0x29E1, 0x2DE2, 0x31E3, + 0x35E4, 0x39E5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x04C0, 0x08E0, 0x0D00, 0x1120, 0x1540, 0x1960, 0x1D80, + 0x21A0, 0x25C0, 0x29E0, 0x2DE0, 0x31E0, 0x35E1, 0x39E2, 0x3DE3, + 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x04C0, 0x08E0, 0x0D00, 0x1120, 0x1540, 0x1960, 0x1D80, + 0x21A0, 0x25C0, 0x29E0, 0x2DE0, 0x31E1, 0x35E2, 0x39E3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0880, 0x0CA0, 0x10C0, 0x14E0, 0x1900, 0x1D20, 0x2140, 0x2560, + 0x2980, 0x2DA0, 0x31C0, 0x35E0, 0x39E1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1080, 0x14A0, 0x18C0, 0x1CE0, 0x2100, 0x2520, 0x2940, 0x2D60, + 0x3180, 0x35A0, 0x39C0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1880, 0x1CA0, 0x20C0, 0x24E0, 0x2900, 0x2D20, 0x3140, 0x3560, + 0x3980, 0x3DA0, 0x3DC0, 0x3DE0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2060, 0x2480, 0x28A0, 0x2CC0, 0x30E0, 0x3500, 0x3920, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2860, 0x2C80, 0x30A0, 0x34C0, 0x38E0, 0x3D00, 0x3D20, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC0, 0x3DE1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3040, 0x3460, 0x3880, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3840, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA1, 0x3DC2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D80, 0x3DA1, 0x3DC2, 0x3DE3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D81, 0x3DA2, 0x3DC3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D81, 0x3DA2, 0x3DC3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D60, 0x3D81, 0x3DA2, 0x3DC3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D61, 0x3D82, 0x3DA3, 0x3DC4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D00, 0x3D20, 0x3D40, 0x3D61, 0x3D82, 0x3DA3, 0x3DC4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x05ED, 0x09EE, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x05EB, 0x09EC, + 0x0DED, 0x11EE, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x05E9, 0x09EA, 0x0DEB, 0x11EC, + 0x15ED, 0x19EE, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x01E5, 0x01E6, 0x05E7, 0x09E8, 0x0DE9, 0x11EA, 0x15EB, 0x19EC, + 0x1DED, 0x21EE, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, + 0x05E5, 0x09E6, 0x0DE7, 0x11E8, 0x15E9, 0x19EA, 0x1DEB, 0x21EC, + 0x25ED, 0x29EE, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x05E3, 0x09E4, + 0x0DE5, 0x11E6, 0x15E7, 0x19E8, 0x1DE9, 0x21EA, 0x25EB, 0x29EC, + 0x2DED, 0x31EE, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x01E0, 0x01E0, 0x05E1, 0x09E2, 0x0DE3, 0x11E4, + 0x15E5, 0x19E6, 0x1DE7, 0x21E8, 0x25E9, 0x29EA, 0x2DEB, 0x31EC, + 0x35ED, 0x39EE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C0, 0x01E0, 0x05E0, 0x09E0, 0x0DE1, 0x11E2, 0x15E3, 0x19E4, + 0x1DE5, 0x21E6, 0x25E7, 0x29E8, 0x2DE9, 0x31EA, 0x35EB, 0x39EC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x05C0, 0x09E0, 0x0DE0, 0x11E0, 0x15E1, 0x19E2, 0x1DE3, 0x21E4, + 0x25E5, 0x29E6, 0x2DE7, 0x31E8, 0x35E9, 0x39EA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0580, 0x09A0, + 0x0DC0, 0x11E0, 0x15E0, 0x19E0, 0x1DE1, 0x21E2, 0x25E3, 0x29E4, + 0x2DE5, 0x31E6, 0x35E7, 0x39E8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0520, 0x0940, 0x0D60, 0x1180, + 0x15A0, 0x19C0, 0x1DE0, 0x21E0, 0x25E1, 0x29E2, 0x2DE3, 0x31E4, + 0x35E5, 0x39E6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x04C0, 0x08E0, 0x0D00, 0x1120, 0x1540, 0x1960, 0x1D80, + 0x21A0, 0x25C0, 0x29E0, 0x2DE0, 0x31E1, 0x35E2, 0x39E3, 0x3DE4, + 0x3DE5, 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x04A0, 0x08C0, 0x0CE0, 0x1100, 0x1520, 0x1940, 0x1D60, + 0x2180, 0x25A0, 0x29C0, 0x2DE1, 0x31E2, 0x35E3, 0x39E4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0880, 0x0CA0, 0x10C0, 0x14E0, 0x1900, 0x1D20, 0x2140, 0x2560, + 0x2980, 0x2DA0, 0x31C0, 0x35E1, 0x39E2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1060, 0x1480, 0x18A0, 0x1CC0, 0x20E0, 0x2500, 0x2920, 0x2D40, + 0x3160, 0x3580, 0x39A0, 0x3DC1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1860, 0x1C80, 0x20A0, 0x24C0, 0x28E0, 0x2D00, 0x3120, 0x3540, + 0x3960, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2060, 0x2480, 0x28A0, 0x2CC0, 0x30E0, 0x3500, 0x3920, 0x3D40, + 0x3D60, 0x3D80, 0x3DA0, 0x3DC1, 0x3DE2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2840, 0x2C60, 0x3080, 0x34A0, 0x38C0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA1, 0x3DC2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3040, 0x3460, 0x3880, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D60, 0x3D80, 0x3DA1, 0x3DC2, 0x3DE3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3820, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D81, 0x3DA2, 0x3DC3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D81, 0x3DA2, 0x3DC3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D40, 0x3D60, 0x3D81, 0x3DA2, 0x3DC3, 0x3DE4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D61, 0x3D82, 0x3DA3, 0x3DC4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D20, 0x3D40, 0x3D61, 0x3D82, 0x3DA3, 0x3DC4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D00, 0x3D20, 0x3D41, 0x3D62, 0x3D83, 0x3DA4, 0x3DC5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D00, 0x3D20, 0x3D41, 0x3D62, 0x3D83, 0x3DA4, 0x3DC5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D00, 0x3D20, 0x3D41, 0x3D62, 0x3D83, 0x3DA4, 0x3DC5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, + 0x3CC0, 0x3CE0, 0x3D00, 0x3D21, 0x3D42, 0x3D63, 0x3D84, 0x3DA5, + 0x3DC6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x05EE, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x05EC, 0x09ED, + 0x0DEE, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x05EA, 0x09EB, 0x0DEC, 0x11ED, + 0x15EE, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x01E6, 0x01E7, 0x05E8, 0x09E9, 0x0DEA, 0x11EB, 0x15EC, 0x19ED, + 0x1DEE, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, + 0x05E6, 0x09E7, 0x0DE8, 0x11E9, 0x15EA, 0x19EB, 0x1DEC, 0x21ED, + 0x25EE, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E0, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x05E4, 0x09E5, + 0x0DE6, 0x11E7, 0x15E8, 0x19E9, 0x1DEA, 0x21EB, 0x25EC, 0x29ED, + 0x2DEE, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C0, 0x01E0, 0x01E0, 0x01E1, 0x05E2, 0x09E3, 0x0DE4, 0x11E5, + 0x15E6, 0x19E7, 0x1DE8, 0x21E9, 0x25EA, 0x29EB, 0x2DEC, 0x31ED, + 0x35EE, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C0, 0x01E0, 0x05E0, 0x09E1, 0x0DE2, 0x11E3, 0x15E4, 0x19E5, + 0x1DE6, 0x21E7, 0x25E8, 0x29E9, 0x2DEA, 0x31EB, 0x35EC, 0x39ED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, + 0x05A0, 0x09C0, 0x0DE0, 0x11E1, 0x15E2, 0x19E3, 0x1DE4, 0x21E5, + 0x25E6, 0x29E7, 0x2DE8, 0x31E9, 0x35EA, 0x39EB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0560, 0x0980, + 0x0DA0, 0x11C0, 0x15E0, 0x19E1, 0x1DE2, 0x21E3, 0x25E4, 0x29E5, + 0x2DE6, 0x31E7, 0x35E8, 0x39E9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0520, 0x0940, 0x0D60, 0x1180, + 0x15A0, 0x19C0, 0x1DE0, 0x21E1, 0x25E2, 0x29E3, 0x2DE4, 0x31E5, + 0x35E6, 0x39E7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x04A0, 0x08C0, 0x0CE0, 0x1100, 0x1520, 0x1940, 0x1D60, + 0x2180, 0x25A0, 0x29C0, 0x2DE1, 0x31E2, 0x35E3, 0x39E4, 0x3DE5, + 0x3DE6, 0x3DE7, 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x04A0, 0x08C0, 0x0CE0, 0x1100, 0x1520, 0x1940, 0x1D60, + 0x2180, 0x25A1, 0x29C2, 0x2DE3, 0x31E4, 0x35E5, 0x39E6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0860, 0x0C80, 0x10A0, 0x14C0, 0x18E0, 0x1D00, 0x2120, 0x2540, + 0x2960, 0x2D81, 0x31A2, 0x35C3, 0x39E4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1060, 0x1480, 0x18A0, 0x1CC0, 0x20E0, 0x2500, 0x2920, 0x2D40, + 0x3160, 0x3581, 0x39A2, 0x3DC3, 0x3DE4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1840, 0x1C60, 0x2080, 0x24A0, 0x28C0, 0x2CE0, 0x3100, 0x3520, + 0x3940, 0x3D61, 0x3D82, 0x3DA3, 0x3DC4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2040, 0x2460, 0x2880, 0x2CA0, 0x30C0, 0x34E0, 0x3900, 0x3D20, + 0x3D40, 0x3D61, 0x3D82, 0x3DA3, 0x3DC4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2840, 0x2C60, 0x3080, 0x34A0, 0x38C0, 0x3CE0, 0x3D00, 0x3D20, + 0x3D40, 0x3D61, 0x3D82, 0x3DA3, 0x3DC4, 0x3DE5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3020, 0x3440, 0x3860, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D41, 0x3D62, 0x3D83, 0x3DA4, 0x3DC5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3820, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D20, 0x3D41, 0x3D62, 0x3D83, 0x3DA4, 0x3DC5, 0x3DE6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D21, 0x3D42, 0x3D63, 0x3D84, 0x3DA5, 0x3DC6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D21, 0x3D42, 0x3D63, 0x3D84, 0x3DA5, 0x3DC6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D00, 0x3D21, 0x3D42, 0x3D63, 0x3D84, 0x3DA5, 0x3DC6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D01, 0x3D22, 0x3D43, 0x3D64, 0x3D85, 0x3DA6, 0x3DC7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE0, 0x3D01, 0x3D22, 0x3D43, 0x3D64, 0x3D85, 0x3DA6, 0x3DC7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, + 0x3CC0, 0x3CE1, 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, + 0x3DC8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, + 0x3CC0, 0x3CE1, 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, + 0x3DC8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, + 0x3CC0, 0x3CE1, 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, + 0x3DC8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x05EE, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x05EC, 0x09ED, 0x0DEE, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x01E8, 0x01E9, 0x05EA, 0x09EB, 0x0DEC, 0x11ED, 0x15EE, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, + 0x05E8, 0x09E9, 0x0DEA, 0x11EB, 0x15EC, 0x19ED, 0x1DEE, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C0, 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x05E6, 0x09E7, + 0x0DE8, 0x11E9, 0x15EA, 0x19EB, 0x1DEC, 0x21ED, 0x25EE, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C0, 0x01E1, 0x01E2, 0x01E3, 0x05E4, 0x09E5, 0x0DE6, 0x11E7, + 0x15E8, 0x19E9, 0x1DEA, 0x21EB, 0x25EC, 0x29ED, 0x2DEE, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, + 0x01A0, 0x01C1, 0x05E2, 0x09E3, 0x0DE4, 0x11E5, 0x15E6, 0x19E7, + 0x1DE8, 0x21E9, 0x25EA, 0x29EB, 0x2DEC, 0x31ED, 0x35EE, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, + 0x05A0, 0x09C1, 0x0DE2, 0x11E3, 0x15E4, 0x19E5, 0x1DE6, 0x21E7, + 0x25E8, 0x29E9, 0x2DEA, 0x31EB, 0x35EC, 0x39ED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0540, 0x0960, + 0x0D80, 0x11A1, 0x15C2, 0x19E3, 0x1DE4, 0x21E5, 0x25E6, 0x29E7, + 0x2DE8, 0x31E9, 0x35EA, 0x39EB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0500, 0x0920, 0x0D40, 0x1160, + 0x1580, 0x19A1, 0x1DC2, 0x21E3, 0x25E4, 0x29E5, 0x2DE6, 0x31E7, + 0x35E8, 0x39E9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x04A0, 0x08C0, 0x0CE0, 0x1100, 0x1520, 0x1940, 0x1D60, + 0x2180, 0x25A1, 0x29C2, 0x2DE3, 0x31E4, 0x35E5, 0x39E6, 0x3DE7, + 0x3DE8, 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0480, 0x08A0, 0x0CC0, 0x10E0, 0x1500, 0x1920, 0x1D40, + 0x2161, 0x2582, 0x29A3, 0x2DC4, 0x31E5, 0x35E6, 0x39E7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0860, 0x0C80, 0x10A0, 0x14C0, 0x18E0, 0x1D00, 0x2120, 0x2540, + 0x2961, 0x2D82, 0x31A3, 0x35C4, 0x39E5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1040, 0x1460, 0x1880, 0x1CA0, 0x20C0, 0x24E0, 0x2900, 0x2D20, + 0x3141, 0x3562, 0x3983, 0x3DA4, 0x3DC5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1840, 0x1C60, 0x2080, 0x24A0, 0x28C0, 0x2CE0, 0x3100, 0x3520, + 0x3941, 0x3D62, 0x3D83, 0x3DA4, 0x3DC5, 0x3DE6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2020, 0x2440, 0x2860, 0x2C80, 0x30A0, 0x34C0, 0x38E0, 0x3D00, + 0x3D21, 0x3D42, 0x3D63, 0x3D84, 0x3DA5, 0x3DC6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2820, 0x2C40, 0x3060, 0x3480, 0x38A0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D21, 0x3D42, 0x3D63, 0x3D84, 0x3DA5, 0x3DC6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3020, 0x3440, 0x3860, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, 0x3D00, + 0x3D21, 0x3D42, 0x3D63, 0x3D84, 0x3DA5, 0x3DC6, 0x3DE7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D01, 0x3D22, 0x3D43, 0x3D64, 0x3D85, 0x3DA6, 0x3DC7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE0, + 0x3D01, 0x3D22, 0x3D43, 0x3D64, 0x3D85, 0x3DA6, 0x3DC7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE1, 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, 0x3DC8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE1, 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, 0x3DC8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, + 0x3CE1, 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, 0x3DC8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, + 0x3CC1, 0x3CE2, 0x3D03, 0x3D24, 0x3D45, 0x3D66, 0x3D87, 0x3DA8, + 0x3DC9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, + 0x3CC1, 0x3CE2, 0x3D03, 0x3D24, 0x3D45, 0x3D66, 0x3D87, 0x3DA8, + 0x3DC9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, + 0x3CA1, 0x3CC2, 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, + 0x3DA9, 0x3DCA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, + 0x3CA1, 0x3CC2, 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, + 0x3DA9, 0x3DCA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, + 0x01E1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x05ED, 0x09EE, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x01E9, 0x01EA, 0x05EB, 0x09EC, 0x0DED, 0x11EE, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, + 0x01C1, 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, + 0x05E9, 0x09EA, 0x0DEB, 0x11EC, 0x15ED, 0x19EE, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, + 0x01A1, 0x01C2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x05E7, 0x09E8, + 0x0DE9, 0x11EA, 0x15EB, 0x19EC, 0x1DED, 0x21EE, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, + 0x01A1, 0x01C2, 0x01E3, 0x01E4, 0x05E5, 0x09E6, 0x0DE7, 0x11E8, + 0x15E9, 0x19EA, 0x1DEB, 0x21EC, 0x25ED, 0x29EE, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, + 0x01A1, 0x01C2, 0x05E3, 0x09E4, 0x0DE5, 0x11E6, 0x15E7, 0x19E8, + 0x1DE9, 0x21EA, 0x25EB, 0x29EC, 0x2DED, 0x31EE, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, + 0x0581, 0x09A2, 0x0DC3, 0x11E4, 0x15E5, 0x19E6, 0x1DE7, 0x21E8, + 0x25E9, 0x29EA, 0x2DEB, 0x31EC, 0x35ED, 0x39EE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0540, 0x0960, + 0x0D81, 0x11A2, 0x15C3, 0x19E4, 0x1DE5, 0x21E6, 0x25E7, 0x29E8, + 0x2DE9, 0x31EA, 0x35EB, 0x39EC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x04E0, 0x0900, 0x0D20, 0x1140, + 0x1561, 0x1982, 0x1DA3, 0x21C4, 0x25E5, 0x29E6, 0x2DE7, 0x31E8, + 0x35E9, 0x39EA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0480, 0x08A0, 0x0CC0, 0x10E0, 0x1500, 0x1920, 0x1D40, + 0x2161, 0x2582, 0x29A3, 0x2DC4, 0x31E5, 0x35E6, 0x39E7, 0x3DE8, + 0x3DE9, 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0460, 0x0880, 0x0CA0, 0x10C0, 0x14E0, 0x1900, 0x1D21, + 0x2142, 0x2563, 0x2984, 0x2DA5, 0x31C6, 0x35E7, 0x39E8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0840, 0x0C60, 0x1080, 0x14A0, 0x18C0, 0x1CE0, 0x2100, 0x2521, + 0x2942, 0x2D63, 0x3184, 0x35A5, 0x39C6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1040, 0x1460, 0x1880, 0x1CA0, 0x20C0, 0x24E0, 0x2900, 0x2D21, + 0x3142, 0x3563, 0x3984, 0x3DA5, 0x3DC6, 0x3DE7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1820, 0x1C40, 0x2060, 0x2480, 0x28A0, 0x2CC0, 0x30E0, 0x3501, + 0x3922, 0x3D43, 0x3D64, 0x3D85, 0x3DA6, 0x3DC7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2020, 0x2440, 0x2860, 0x2C80, 0x30A0, 0x34C0, 0x38E0, 0x3D01, + 0x3D22, 0x3D43, 0x3D64, 0x3D85, 0x3DA6, 0x3DC7, 0x3DE8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2800, 0x2C20, 0x3040, 0x3460, 0x3880, 0x3CA0, 0x3CC0, 0x3CE1, + 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, 0x3DC8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3000, 0x3420, 0x3840, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE1, + 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, 0x3DC8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC0, 0x3CE1, + 0x3D02, 0x3D23, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, 0x3DC8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC1, + 0x3CE2, 0x3D03, 0x3D24, 0x3D45, 0x3D66, 0x3D87, 0x3DA8, 0x3DC9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA0, 0x3CC1, + 0x3CE2, 0x3D03, 0x3D24, 0x3D45, 0x3D66, 0x3D87, 0x3DA8, 0x3DC9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA1, + 0x3CC2, 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, + 0x3DCA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA1, + 0x3CC2, 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, + 0x3DCA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA1, + 0x3CC2, 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, + 0x3DCA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C81, + 0x3CA2, 0x3CC3, 0x3CE4, 0x3D05, 0x3D26, 0x3D47, 0x3D68, 0x3D89, + 0x3DAA, 0x3DCB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C81, + 0x3CA2, 0x3CC3, 0x3CE4, 0x3D05, 0x3D26, 0x3D47, 0x3D68, 0x3D89, + 0x3DAA, 0x3DCB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C61, + 0x3C82, 0x3CA3, 0x3CC4, 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, + 0x3D8A, 0x3DAB, 0x3DCC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C0, 0x01E1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C1, + 0x01E2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A1, + 0x01C2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A1, + 0x01C2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x05EE, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A1, + 0x01C2, 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x01EA, 0x01EB, 0x05EC, 0x09ED, 0x0DEE, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0181, + 0x01A2, 0x01C3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, + 0x05EA, 0x09EB, 0x0DEC, 0x11ED, 0x15EE, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0181, + 0x01A2, 0x01C3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x05E8, 0x09E9, + 0x0DEA, 0x11EB, 0x15EC, 0x19ED, 0x1DEE, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, + 0x0182, 0x01A3, 0x01C4, 0x01E5, 0x05E6, 0x09E7, 0x0DE8, 0x11E9, + 0x15EA, 0x19EB, 0x1DEC, 0x21ED, 0x25EE, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, + 0x0182, 0x01A3, 0x05C4, 0x09E5, 0x0DE6, 0x11E7, 0x15E8, 0x19E9, + 0x1DEA, 0x21EB, 0x25EC, 0x29ED, 0x2DEE, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, + 0x0582, 0x09A3, 0x0DC4, 0x11E5, 0x15E6, 0x19E7, 0x1DE8, 0x21E9, + 0x25EA, 0x29EB, 0x2DEC, 0x31ED, 0x35EE, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0520, 0x0941, + 0x0D62, 0x1183, 0x15A4, 0x19C5, 0x1DE6, 0x21E7, 0x25E8, 0x29E9, + 0x2DEA, 0x31EB, 0x35EC, 0x39ED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x04E0, 0x0900, 0x0D20, 0x1141, + 0x1562, 0x1983, 0x1DA4, 0x21C5, 0x25E6, 0x29E7, 0x2DE8, 0x31E9, + 0x35EA, 0x39EB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0460, 0x0880, 0x0CA0, 0x10C0, 0x14E0, 0x1900, 0x1D21, + 0x2142, 0x2563, 0x2984, 0x2DA5, 0x31C6, 0x35E7, 0x39E8, 0x3DE9, + 0x3DEA, 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0460, 0x0880, 0x0CA0, 0x10C0, 0x14E0, 0x1901, 0x1D22, + 0x2143, 0x2564, 0x2985, 0x2DA6, 0x31C7, 0x35E8, 0x39E9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0820, 0x0C40, 0x1060, 0x1480, 0x18A0, 0x1CC0, 0x20E1, 0x2502, + 0x2923, 0x2D44, 0x3165, 0x3586, 0x39A7, 0x3DC8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1020, 0x1440, 0x1860, 0x1C80, 0x20A0, 0x24C0, 0x28E1, 0x2D02, + 0x3123, 0x3544, 0x3965, 0x3D86, 0x3DA7, 0x3DC8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1820, 0x1C40, 0x2060, 0x2480, 0x28A0, 0x2CC0, 0x30E1, 0x3502, + 0x3923, 0x3D44, 0x3D65, 0x3D86, 0x3DA7, 0x3DC8, 0x3DE9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2000, 0x2420, 0x2840, 0x2C60, 0x3080, 0x34A0, 0x38C1, 0x3CE2, + 0x3D03, 0x3D24, 0x3D45, 0x3D66, 0x3D87, 0x3DA8, 0x3DC9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2800, 0x2C20, 0x3040, 0x3460, 0x3880, 0x3CA0, 0x3CC1, 0x3CE2, + 0x3D03, 0x3D24, 0x3D45, 0x3D66, 0x3D87, 0x3DA8, 0x3DC9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3000, 0x3400, 0x3820, 0x3C40, 0x3C60, 0x3C80, 0x3CA1, 0x3CC2, + 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, 0x3DCA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA1, 0x3CC2, + 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, 0x3DCA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C80, 0x3CA1, 0x3CC2, + 0x3CE3, 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, 0x3DCA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C81, 0x3CA2, + 0x3CC3, 0x3CE4, 0x3D05, 0x3D26, 0x3D47, 0x3D68, 0x3D89, 0x3DAA, + 0x3DCB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C60, 0x3C81, 0x3CA2, + 0x3CC3, 0x3CE4, 0x3D05, 0x3D26, 0x3D47, 0x3D68, 0x3D89, 0x3DAA, + 0x3DCB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C61, 0x3C82, + 0x3CA3, 0x3CC4, 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, + 0x3DAB, 0x3DCC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C61, 0x3C82, + 0x3CA3, 0x3CC4, 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, + 0x3DAB, 0x3DCC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C61, 0x3C82, + 0x3CA3, 0x3CC4, 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, + 0x3DAB, 0x3DCC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C41, 0x3C62, + 0x3C83, 0x3CA4, 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, + 0x3D8B, 0x3DAC, 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C41, 0x3C62, + 0x3C83, 0x3CA4, 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, + 0x3D8B, 0x3DAC, 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A0, 0x01C1, 0x01E2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A1, 0x01C2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A1, 0x01C2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0180, 0x01A1, 0x01C2, + 0x01E3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0181, 0x01A2, + 0x01C3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0181, 0x01A2, + 0x01C3, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, 0x0182, + 0x01A3, 0x01C4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, 0x0182, + 0x01A3, 0x01C4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x01EB, 0x01EC, 0x05ED, 0x09EE, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, 0x0182, + 0x01A3, 0x01C4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, + 0x05EB, 0x09EC, 0x0DED, 0x11EE, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0141, 0x0162, + 0x0183, 0x01A4, 0x01C5, 0x01E6, 0x01E7, 0x01E8, 0x05E9, 0x09EA, + 0x0DEB, 0x11EC, 0x15ED, 0x19EE, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0141, 0x0162, + 0x0183, 0x01A4, 0x01C5, 0x01E6, 0x05E7, 0x09E8, 0x0DE9, 0x11EA, + 0x15EB, 0x19EC, 0x1DED, 0x21EE, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, + 0x0163, 0x0184, 0x05A5, 0x09C6, 0x0DE7, 0x11E8, 0x15E9, 0x19EA, + 0x1DEB, 0x21EC, 0x25ED, 0x29EE, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, + 0x0563, 0x0984, 0x0DA5, 0x11C6, 0x15E7, 0x19E8, 0x1DE9, 0x21EA, + 0x25EB, 0x29EC, 0x2DED, 0x31EE, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0521, 0x0942, + 0x0D63, 0x1184, 0x15A5, 0x19C6, 0x1DE7, 0x21E8, 0x25E9, 0x29EA, + 0x2DEB, 0x31EC, 0x35ED, 0x39EE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A0, 0x04C0, 0x08E0, 0x0D01, 0x1122, + 0x1543, 0x1964, 0x1D85, 0x21A6, 0x25C7, 0x29E8, 0x2DE9, 0x31EA, + 0x35EB, 0x39EC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0460, 0x0880, 0x0CA0, 0x10C0, 0x14E0, 0x1901, 0x1D22, + 0x2143, 0x2564, 0x2985, 0x2DA6, 0x31C7, 0x35E8, 0x39E9, 0x3DEA, + 0x3DEB, 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0440, 0x0860, 0x0C80, 0x10A0, 0x14C1, 0x18E2, 0x1D03, + 0x2124, 0x2545, 0x2966, 0x2D87, 0x31A8, 0x35C9, 0x39EA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0820, 0x0C40, 0x1060, 0x1480, 0x18A0, 0x1CC1, 0x20E2, 0x2503, + 0x2924, 0x2D45, 0x3166, 0x3587, 0x39A8, 0x3DC9, 0x3DEA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1000, 0x1420, 0x1840, 0x1C60, 0x2080, 0x24A1, 0x28C2, 0x2CE3, + 0x3104, 0x3525, 0x3946, 0x3D67, 0x3D88, 0x3DA9, 0x3DCA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1800, 0x1C20, 0x2040, 0x2460, 0x2880, 0x2CA1, 0x30C2, 0x34E3, + 0x3904, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, 0x3DCA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2000, 0x2420, 0x2840, 0x2C60, 0x3080, 0x34A1, 0x38C2, 0x3CE3, + 0x3D04, 0x3D25, 0x3D46, 0x3D67, 0x3D88, 0x3DA9, 0x3DCA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2800, 0x2C00, 0x3020, 0x3440, 0x3860, 0x3C81, 0x3CA2, 0x3CC3, + 0x3CE4, 0x3D05, 0x3D26, 0x3D47, 0x3D68, 0x3D89, 0x3DAA, 0x3DCB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3000, 0x3400, 0x3820, 0x3C40, 0x3C60, 0x3C81, 0x3CA2, 0x3CC3, + 0x3CE4, 0x3D05, 0x3D26, 0x3D47, 0x3D68, 0x3D89, 0x3DAA, 0x3DCB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C61, 0x3C82, 0x3CA3, + 0x3CC4, 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, 0x3DAB, + 0x3DCC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C61, 0x3C82, 0x3CA3, + 0x3CC4, 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, 0x3DAB, + 0x3DCC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C40, 0x3C61, 0x3C82, 0x3CA3, + 0x3CC4, 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, 0x3DAB, + 0x3DCC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C41, 0x3C62, 0x3C83, + 0x3CA4, 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, + 0x3DAC, 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C41, 0x3C62, 0x3C83, + 0x3CA4, 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, + 0x3DAC, 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C41, 0x3C62, 0x3C83, + 0x3CA4, 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, + 0x3DAC, 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C21, 0x3C42, 0x3C63, + 0x3C84, 0x3CA5, 0x3CC6, 0x3CE7, 0x3D08, 0x3D29, 0x3D4A, 0x3D6B, + 0x3D8C, 0x3DAD, 0x3DCE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C21, 0x3C42, 0x3C63, + 0x3C84, 0x3CA5, 0x3CC6, 0x3CE7, 0x3D08, 0x3D29, 0x3D4A, 0x3D6B, + 0x3D8C, 0x3DAD, 0x3DCE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C22, 0x3C43, + 0x3C64, 0x3C85, 0x3CA6, 0x3CC7, 0x3CE8, 0x3D09, 0x3D2A, 0x3D4B, + 0x3D6C, 0x3D8D, 0x3DAE, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0181, 0x01A2, 0x01C3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0160, 0x0181, 0x01A2, 0x01C3, + 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, 0x0182, 0x01A3, + 0x01C4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, 0x0182, 0x01A3, + 0x01C4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, 0x0182, 0x01A3, + 0x01C4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0141, 0x0162, 0x0183, + 0x01A4, 0x01C5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0141, 0x0162, 0x0183, + 0x01A4, 0x01C5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, + 0x0184, 0x01A5, 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x01EC, 0x01ED, 0x05EE, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, + 0x0184, 0x01A5, 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, + 0x05EC, 0x09ED, 0x0DEE, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, + 0x0184, 0x01A5, 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x05EA, 0x09EB, + 0x0DEC, 0x11ED, 0x15EE, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0101, 0x0122, 0x0143, + 0x0164, 0x0185, 0x01A6, 0x01C7, 0x05E8, 0x09E9, 0x0DEA, 0x11EB, + 0x15EC, 0x19ED, 0x1DEE, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0101, 0x0122, 0x0143, + 0x0164, 0x0185, 0x05A6, 0x09C7, 0x0DE8, 0x11E9, 0x15EA, 0x19EB, + 0x1DEC, 0x21ED, 0x25EE, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0102, 0x0123, + 0x0544, 0x0965, 0x0D86, 0x11A7, 0x15C8, 0x19E9, 0x1DEA, 0x21EB, + 0x25EC, 0x29ED, 0x2DEE, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0502, 0x0923, + 0x0D44, 0x1165, 0x1586, 0x19A7, 0x1DC8, 0x21E9, 0x25EA, 0x29EB, + 0x2DEC, 0x31ED, 0x35EE, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A0, 0x04C0, 0x08E1, 0x0D02, 0x1123, + 0x1544, 0x1965, 0x1D86, 0x21A7, 0x25C8, 0x29E9, 0x2DEA, 0x31EB, + 0x35EC, 0x39ED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0440, 0x0860, 0x0C80, 0x10A0, 0x14C1, 0x18E2, 0x1D03, + 0x2124, 0x2545, 0x2966, 0x2D87, 0x31A8, 0x35C9, 0x39EA, 0x3DEB, + 0x3DEC, 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0440, 0x0860, 0x0C80, 0x10A1, 0x14C2, 0x18E3, 0x1D04, + 0x2125, 0x2546, 0x2967, 0x2D88, 0x31A9, 0x35CA, 0x39EB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0800, 0x0C20, 0x1040, 0x1460, 0x1881, 0x1CA2, 0x20C3, 0x24E4, + 0x2905, 0x2D26, 0x3147, 0x3568, 0x3989, 0x3DAA, 0x3DCB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1000, 0x1420, 0x1840, 0x1C60, 0x2081, 0x24A2, 0x28C3, 0x2CE4, + 0x3105, 0x3526, 0x3947, 0x3D68, 0x3D89, 0x3DAA, 0x3DCB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1800, 0x1C00, 0x2020, 0x2440, 0x2861, 0x2C82, 0x30A3, 0x34C4, + 0x38E5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, 0x3DAB, 0x3DCC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2000, 0x2400, 0x2820, 0x2C40, 0x3061, 0x3482, 0x38A3, 0x3CC4, + 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, 0x3DAB, 0x3DCC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2800, 0x2C00, 0x3020, 0x3440, 0x3861, 0x3C82, 0x3CA3, 0x3CC4, + 0x3CE5, 0x3D06, 0x3D27, 0x3D48, 0x3D69, 0x3D8A, 0x3DAB, 0x3DCC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3000, 0x3400, 0x3800, 0x3C20, 0x3C41, 0x3C62, 0x3C83, 0x3CA4, + 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, 0x3DAC, + 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C00, 0x3C00, 0x3C20, 0x3C41, 0x3C62, 0x3C83, 0x3CA4, + 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, 0x3DAC, + 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C20, 0x3C41, 0x3C62, 0x3C83, 0x3CA4, + 0x3CC5, 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, 0x3DAC, + 0x3DCD, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C21, 0x3C42, 0x3C63, 0x3C84, + 0x3CA5, 0x3CC6, 0x3CE7, 0x3D08, 0x3D29, 0x3D4A, 0x3D6B, 0x3D8C, + 0x3DAD, 0x3DCE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C21, 0x3C42, 0x3C63, 0x3C84, + 0x3CA5, 0x3CC6, 0x3CE7, 0x3D08, 0x3D29, 0x3D4A, 0x3D6B, 0x3D8C, + 0x3DAD, 0x3DCE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C22, 0x3C43, 0x3C64, + 0x3C85, 0x3CA6, 0x3CC7, 0x3CE8, 0x3D09, 0x3D2A, 0x3D4B, 0x3D6C, + 0x3D8D, 0x3DAE, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C22, 0x3C43, 0x3C64, + 0x3C85, 0x3CA6, 0x3CC7, 0x3CE8, 0x3D09, 0x3D2A, 0x3D4B, 0x3D6C, + 0x3D8D, 0x3DAE, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C22, 0x3C43, 0x3C64, + 0x3C85, 0x3CA6, 0x3CC7, 0x3CE8, 0x3D09, 0x3D2A, 0x3D4B, 0x3D6C, + 0x3D8D, 0x3DAE, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C23, 0x3C44, + 0x3C65, 0x3C86, 0x3CA7, 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, + 0x3D6D, 0x3D8E, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C23, 0x3C44, + 0x3C65, 0x3C86, 0x3CA7, 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, + 0x3D6D, 0x3D8E, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00E0, 0x0100, 0x0120, 0x0140, 0x0161, 0x0182, 0x01A3, 0x01C4, + 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0141, 0x0162, 0x0183, 0x01A4, + 0x01C5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x00C0, 0x00E0, 0x0100, 0x0120, 0x0141, 0x0162, 0x0183, 0x01A4, + 0x01C5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, 0x0184, + 0x01A5, 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, 0x0184, + 0x01A5, 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x00A0, 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, 0x0184, + 0x01A5, 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0101, 0x0122, 0x0143, 0x0164, + 0x0185, 0x01A6, 0x01C7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0080, 0x00A0, 0x00C0, 0x00E0, 0x0101, 0x0122, 0x0143, 0x0164, + 0x0185, 0x01A6, 0x01C7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x01ED, 0x01EE, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0102, 0x0123, 0x0144, + 0x0165, 0x0186, 0x01A7, 0x01C8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, + 0x05ED, 0x09EE, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0102, 0x0123, 0x0144, + 0x0165, 0x0186, 0x01A7, 0x01C8, 0x01E9, 0x01EA, 0x05EB, 0x09EC, + 0x0DED, 0x11EE, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0060, 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0102, 0x0123, 0x0144, + 0x0165, 0x0186, 0x01A7, 0x01C8, 0x05E9, 0x09EA, 0x0DEB, 0x11EC, + 0x15ED, 0x19EE, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, + 0x0145, 0x0166, 0x0587, 0x09A8, 0x0DC9, 0x11EA, 0x15EB, 0x19EC, + 0x1DED, 0x21EE, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, + 0x0545, 0x0966, 0x0D87, 0x11A8, 0x15C9, 0x19EA, 0x1DEB, 0x21EC, + 0x25ED, 0x29EE, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0040, 0x0060, 0x0080, 0x00A1, 0x00C2, 0x04E3, 0x0904, + 0x0D25, 0x1146, 0x1567, 0x1988, 0x1DA9, 0x21CA, 0x25EB, 0x29EC, + 0x2DED, 0x31EE, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0040, 0x0060, 0x0080, 0x04A1, 0x08C2, 0x0CE3, 0x1104, + 0x1525, 0x1946, 0x1D67, 0x2188, 0x25A9, 0x29CA, 0x2DEB, 0x31EC, + 0x35ED, 0x39EE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0440, 0x0860, 0x0C80, 0x10A1, 0x14C2, 0x18E3, 0x1D04, + 0x2125, 0x2546, 0x2967, 0x2D88, 0x31A9, 0x35CA, 0x39EB, 0x3DEC, + 0x3DED, 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0420, 0x0840, 0x0C61, 0x1082, 0x14A3, 0x18C4, 0x1CE5, + 0x2106, 0x2527, 0x2948, 0x2D69, 0x318A, 0x35AB, 0x39CC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0800, 0x0C20, 0x1040, 0x1461, 0x1882, 0x1CA3, 0x20C4, 0x24E5, + 0x2906, 0x2D27, 0x3148, 0x3569, 0x398A, 0x3DAB, 0x3DCC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1000, 0x1400, 0x1820, 0x1C41, 0x2062, 0x2483, 0x28A4, 0x2CC5, + 0x30E6, 0x3507, 0x3928, 0x3D49, 0x3D6A, 0x3D8B, 0x3DAC, 0x3DCD, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1800, 0x1C00, 0x2020, 0x2441, 0x2862, 0x2C83, 0x30A4, 0x34C5, + 0x38E6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, 0x3DAC, 0x3DCD, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2000, 0x2400, 0x2820, 0x2C41, 0x3062, 0x3483, 0x38A4, 0x3CC5, + 0x3CE6, 0x3D07, 0x3D28, 0x3D49, 0x3D6A, 0x3D8B, 0x3DAC, 0x3DCD, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2800, 0x2C00, 0x3000, 0x3421, 0x3842, 0x3C63, 0x3C84, 0x3CA5, + 0x3CC6, 0x3CE7, 0x3D08, 0x3D29, 0x3D4A, 0x3D6B, 0x3D8C, 0x3DAD, + 0x3DCE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3000, 0x3400, 0x3800, 0x3C21, 0x3C42, 0x3C63, 0x3C84, 0x3CA5, + 0x3CC6, 0x3CE7, 0x3D08, 0x3D29, 0x3D4A, 0x3D6B, 0x3D8C, 0x3DAD, + 0x3DCE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C00, 0x3C00, 0x3C01, 0x3C22, 0x3C43, 0x3C64, 0x3C85, + 0x3CA6, 0x3CC7, 0x3CE8, 0x3D09, 0x3D2A, 0x3D4B, 0x3D6C, 0x3D8D, + 0x3DAE, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C22, 0x3C43, 0x3C64, 0x3C85, + 0x3CA6, 0x3CC7, 0x3CE8, 0x3D09, 0x3D2A, 0x3D4B, 0x3D6C, 0x3D8D, + 0x3DAE, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C22, 0x3C43, 0x3C64, 0x3C85, + 0x3CA6, 0x3CC7, 0x3CE8, 0x3D09, 0x3D2A, 0x3D4B, 0x3D6C, 0x3D8D, + 0x3DAE, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C23, 0x3C44, 0x3C65, + 0x3C86, 0x3CA7, 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, + 0x3D8E, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C23, 0x3C44, 0x3C65, + 0x3C86, 0x3CA7, 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, + 0x3D8E, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C24, 0x3C45, + 0x3C66, 0x3C87, 0x3CA8, 0x3CC9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, + 0x3D6E, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C24, 0x3C45, + 0x3C66, 0x3C87, 0x3CA8, 0x3CC9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, + 0x3D6E, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C24, 0x3C45, + 0x3C66, 0x3C87, 0x3CA8, 0x3CC9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, + 0x3D6E, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C00, 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C25, + 0x3C46, 0x3C67, 0x3C88, 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, + 0x3D4E, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, 0x0184, 0x01A5, + 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x00C0, 0x00E0, 0x0100, 0x0121, 0x0142, 0x0163, 0x0184, 0x01A5, + 0x01C6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x00A0, 0x00C0, 0x00E0, 0x0101, 0x0122, 0x0143, 0x0164, 0x0185, + 0x01A6, 0x01C7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x00A0, 0x00C0, 0x00E0, 0x0101, 0x0122, 0x0143, 0x0164, 0x0185, + 0x01A6, 0x01C7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0102, 0x0123, 0x0144, 0x0165, + 0x0186, 0x01A7, 0x01C8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0102, 0x0123, 0x0144, 0x0165, + 0x0186, 0x01A7, 0x01C8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0080, 0x00A0, 0x00C0, 0x00E1, 0x0102, 0x0123, 0x0144, 0x0165, + 0x0186, 0x01A7, 0x01C8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0060, 0x0080, 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, + 0x0166, 0x0187, 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x01EE, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0060, 0x0080, 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, + 0x0166, 0x0187, 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, + 0x05EE, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, + 0x0146, 0x0167, 0x0188, 0x01A9, 0x01CA, 0x01EB, 0x05EC, 0x09ED, + 0x0DEE, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, + 0x0146, 0x0167, 0x0188, 0x01A9, 0x05CA, 0x09EB, 0x0DEC, 0x11ED, + 0x15EE, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0040, 0x0060, 0x0080, 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, + 0x0146, 0x0167, 0x0588, 0x09A9, 0x0DCA, 0x11EB, 0x15EC, 0x19ED, + 0x1DEE, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0040, 0x0060, 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, + 0x0526, 0x0947, 0x0D68, 0x1189, 0x15AA, 0x19CB, 0x1DEC, 0x21ED, + 0x25EE, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0040, 0x0060, 0x0081, 0x00A2, 0x00C3, 0x04E4, 0x0905, + 0x0D26, 0x1147, 0x1568, 0x1989, 0x1DAA, 0x21CB, 0x25EC, 0x29ED, + 0x2DEE, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0020, 0x0040, 0x0061, 0x0482, 0x08A3, 0x0CC4, 0x10E5, + 0x1506, 0x1927, 0x1D48, 0x2169, 0x258A, 0x29AB, 0x2DCC, 0x31ED, + 0x35EE, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0420, 0x0840, 0x0C61, 0x1082, 0x14A3, 0x18C4, 0x1CE5, + 0x2106, 0x2527, 0x2948, 0x2D69, 0x318A, 0x35AB, 0x39CC, 0x3DED, + 0x3DEE, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0421, 0x0842, 0x0C63, 0x1084, 0x14A5, 0x18C6, 0x1CE7, + 0x2108, 0x2529, 0x294A, 0x2D6B, 0x318C, 0x35AD, 0x39CE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0800, 0x0C01, 0x1022, 0x1443, 0x1864, 0x1C85, 0x20A6, 0x24C7, + 0x28E8, 0x2D09, 0x312A, 0x354B, 0x396C, 0x3D8D, 0x3DAE, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1000, 0x1401, 0x1822, 0x1C43, 0x2064, 0x2485, 0x28A6, 0x2CC7, + 0x30E8, 0x3509, 0x392A, 0x3D4B, 0x3D6C, 0x3D8D, 0x3DAE, 0x3DCF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x1800, 0x1C01, 0x2002, 0x2423, 0x2844, 0x2C65, 0x3086, 0x34A7, + 0x38C8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, 0x3D8E, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2000, 0x2401, 0x2802, 0x2C23, 0x3044, 0x3465, 0x3886, 0x3CA7, + 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, 0x3D8E, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x2800, 0x2C01, 0x3002, 0x3423, 0x3844, 0x3C65, 0x3C86, 0x3CA7, + 0x3CC8, 0x3CE9, 0x3D0A, 0x3D2B, 0x3D4C, 0x3D6D, 0x3D8E, 0x3DAF, + 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3000, 0x3401, 0x3802, 0x3C03, 0x3C24, 0x3C45, 0x3C66, 0x3C87, + 0x3CA8, 0x3CC9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, 0x3D6E, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3800, 0x3C01, 0x3C02, 0x3C03, 0x3C24, 0x3C45, 0x3C66, 0x3C87, + 0x3CA8, 0x3CC9, 0x3CEA, 0x3D0B, 0x3D2C, 0x3D4D, 0x3D6E, 0x3D8F, + 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C25, 0x3C46, 0x3C67, + 0x3C88, 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C25, 0x3C46, 0x3C67, + 0x3C88, 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C25, 0x3C46, 0x3C67, + 0x3C88, 0x3CA9, 0x3CCA, 0x3CEB, 0x3D0C, 0x3D2D, 0x3D4E, 0x3D6F, + 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C26, 0x3C47, + 0x3C68, 0x3C89, 0x3CAA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C26, 0x3C47, + 0x3C68, 0x3C89, 0x3CAA, 0x3CCB, 0x3CEC, 0x3D0D, 0x3D2E, 0x3D4F, + 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, + 0x3C48, 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, + 0x3C48, 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3C00, 0x3C01, 0x3C02, 0x3C03, 0x3C04, 0x3C05, 0x3C06, 0x3C27, + 0x3C48, 0x3C69, 0x3C8A, 0x3CAB, 0x3CCC, 0x3CED, 0x3D0E, 0x3D2F, + 0x3D4F, 0x3D6F, 0x3D8F, 0x3DAF, 0x3DCF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, 0x0166, 0x0187, + 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, 0x0166, 0x0187, + 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x00A0, 0x00C1, 0x00E2, 0x0103, 0x0124, 0x0145, 0x0166, 0x0187, + 0x01A8, 0x01C9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x0080, 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, 0x0146, 0x0167, + 0x0188, 0x01A9, 0x01CA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x0080, 0x00A1, 0x00C2, 0x00E3, 0x0104, 0x0125, 0x0146, 0x0167, + 0x0188, 0x01A9, 0x01CA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x0060, 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, + 0x0168, 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x0060, 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, + 0x0168, 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x0060, 0x0081, 0x00A2, 0x00C3, 0x00E4, 0x0105, 0x0126, 0x0147, + 0x0168, 0x0189, 0x01AA, 0x01CB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + 0x01EF, 0x01EF, 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x0040, 0x0061, 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, + 0x0148, 0x0169, 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x01EE, 0x01EF, + 0x05EF, 0x09EF, 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x0040, 0x0061, 0x0082, 0x00A3, 0x00C4, 0x00E5, 0x0106, 0x0127, + 0x0148, 0x0169, 0x018A, 0x01AB, 0x01CC, 0x01ED, 0x05EE, 0x09EF, + 0x0DEF, 0x11EF, 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, + 0x0128, 0x0149, 0x016A, 0x018B, 0x05AC, 0x09CD, 0x0DEE, 0x11EF, + 0x15EF, 0x19EF, 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, + 0x0128, 0x0149, 0x056A, 0x098B, 0x0DAC, 0x11CD, 0x15EE, 0x19EF, + 0x1DEF, 0x21EF, 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0020, 0x0041, 0x0062, 0x0083, 0x00A4, 0x00C5, 0x00E6, 0x0107, + 0x0528, 0x0949, 0x0D6A, 0x118B, 0x15AC, 0x19CD, 0x1DEE, 0x21EF, + 0x25EF, 0x29EF, 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0021, 0x0042, 0x0063, 0x0084, 0x00A5, 0x04C6, 0x08E7, + 0x0D08, 0x1129, 0x154A, 0x196B, 0x1D8C, 0x21AD, 0x25CE, 0x29EF, + 0x2DEF, 0x31EF, 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0021, 0x0042, 0x0063, 0x0484, 0x08A5, 0x0CC6, 0x10E7, + 0x1508, 0x1929, 0x1D4A, 0x216B, 0x258C, 0x29AD, 0x2DCE, 0x31EF, + 0x35EF, 0x39EF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x0000, 0x0421, 0x0842, 0x0C63, 0x1084, 0x14A5, 0x18C6, 0x1CE7, + 0x2108, 0x2529, 0x294A, 0x2D6B, 0x318C, 0x35AD, 0x39CE, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, + 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF, 0x3DEF +]; diff --git a/nihav-acorn/src/demuxers/armovie.rs b/nihav-acorn/src/demuxers/armovie.rs new file mode 100644 index 0000000..4b2b3f6 --- /dev/null +++ b/nihav-acorn/src/demuxers/armovie.rs @@ -0,0 +1,430 @@ +use nihav_core::demuxers::*; + +const VIDEO_CODECS: &[(i32, &str)] = &[ + ( 1, "movinglines"), + ( 2, "arm_rawvideo"), + ( 3, "arm_rawvideo"), + ( 5, "arm_rawvideo"), + ( 7, "movingblocks"), + ( 17, "movingblockshq"), + ( 19, "supermovingblocks"), + (100, "escape100"), + (102, "escape102"), + (122, "escape122"), + (124, "escape124"), + (130, "escape130"), + (600, "msvideo1"), + (601, "msvideo1"), + (602, "cinepak"), + (800, "linepack"), + (802, "movie16_3"), +]; + +trait ReadString { + fn read_string(&mut self) -> DemuxerResult>; +} + +impl<'a> ReadString for ByteReader<'a> { + fn read_string(&mut self) -> DemuxerResult> { + let mut res = Vec::new(); + loop { + let c = self.read_byte()?; + if c == b'\n' || c == 0 { + break; + } + res.push(c); + validate!(res.len() < (1 << 10)); // insanity check + } + Ok(res) + } +} + +fn parse_int(src: &[u8]) -> DemuxerResult { + let mut val = 0; + let mut parsed = false; + let mut sign = false; + for &c in src.iter() { + match c { + b'-' if !parsed => { sign = true; }, + b'-' => return Err(DemuxerError::InvalidData), + b'0'..=b'9' => { + val = val * 10 + ((c - b'0') as i32); + if val > (1 << 27) { + return Err(DemuxerError::InvalidData); + } + parsed = true; + }, + b' ' | b'\t' if !parsed => {}, + _ => break, + } + } + if parsed { + Ok(if !sign { val } else { -val }) + } else { + Err(DemuxerError::InvalidData) + } +} + +fn parse_uint(src: &[u8]) -> DemuxerResult { + let val = parse_int(src)?; + if val < 0 { return Err(DemuxerError::InvalidData); } + Ok(val as u32) +} + +fn parse_float(src: &[u8]) -> DemuxerResult { + let mut val = 0.0f32; + let mut parsed = false; + let mut frac_part = 1.0; + for &c in src.iter() { + match c { + b'0'..=b'9' => { + if frac_part == 1.0 { + val = val * 10.0 + ((c - b'0') as f32); + if val > 1000.0 { + return Err(DemuxerError::InvalidData); + } + } else { + val += ((c - b'0') as f32) * frac_part; + frac_part *= 0.1; + } + parsed = true; + }, + b'.' if frac_part != 1.0 => return Err(DemuxerError::InvalidData), + b'.' => { + frac_part = 0.1; + }, + b' ' | b'\t' => {}, + _ => break, + } + } + if parsed { + Ok(val) + } else { + Err(DemuxerError::InvalidData) + } +} + +#[allow(clippy::while_let_on_iterator)] +fn split_sound_str(string: &[u8]) -> DemuxerResult> { + let mut start = 0; + let mut ret = Vec::new(); + let mut ref_trk_id = 2; + + let mut iter = string.iter().enumerate(); + while let Some((pos, &c)) = iter.next() { + if c == b'|' { + ret.push(&string[start..pos]); + + validate!(pos + 2 < string.len()); + + let mut num_end = pos + 2; + while let Some((pos2, c)) = iter.next() { + if !c.is_ascii_digit() { + num_end = pos2 + 1; + break; + } + } + let trk_id = parse_uint(&string[pos + 1..num_end])?; + validate!(trk_id == ref_trk_id); + ref_trk_id += 1; + start = num_end; + } + } + if start < string.len() { + ret.push(&string[start..]); + } + Ok(ret) +} + +struct ChunkInfo { + offset: u32, + vid_size: u32, + aud_sizes: Vec, +} + +enum ReadState { + None, + Video, + Audio(usize), +} + +struct ARMovieDemuxer<'a> { + src: &'a mut ByteReader<'a>, + chunk_offs: Vec, + cur_chunk: usize, + state: ReadState, + video_id: Option, + audio_ids: Vec, +} + +impl<'a> ARMovieDemuxer<'a> { + fn new(src: &'a mut ByteReader<'a>) -> Self { + Self { + src, + chunk_offs: Vec::new(), + cur_chunk: 0, + state: ReadState::None, + video_id: None, + audio_ids: Vec::new(), + } + } + fn parse_catalogue(&mut self, offset: u32, num_chunks: usize, even_csize: usize, odd_csize: usize, aud_tracks: usize) -> DemuxerResult<()> { + self.src.seek(SeekFrom::Start(u64::from(offset)))?; + self.chunk_offs.clear(); + for i in 0..num_chunks { + let cur_chunk_size = if (i & 1) == 0 { even_csize } else { odd_csize }; + + let entry = self.src.read_string()?; + let comma_pos = entry.iter().position(|&c| c == b','); + let semicolon_pos = entry.iter().position(|&c| c == b';'); + if let (Some(c_pos), Some(sc_pos)) = (comma_pos, semicolon_pos) { + validate!(c_pos > 0 && c_pos + 1 < sc_pos); + let offset = parse_uint(&entry[..c_pos])?; + let vid_size = parse_uint(&entry[c_pos + 1..sc_pos])?; + let astring = &entry[sc_pos + 1..]; + let asizes = split_sound_str(astring)?; + + let mut aud_sizes = Vec::with_capacity(aud_tracks); + if aud_tracks > 0 { + let aud_size = parse_uint(asizes[0])?; + aud_sizes.push(aud_size); + } + for &aud_entry in asizes.iter().skip(1) { + let aud_size = parse_uint(aud_entry)?; + aud_sizes.push(aud_size); + } + + let tot_size: u32 = vid_size + aud_sizes.iter().sum::(); + validate!((tot_size as usize) <= cur_chunk_size); + self.chunk_offs.push(ChunkInfo { offset, vid_size, aud_sizes }); + } else { + return Err(DemuxerError::InvalidData); + } + } + + Ok(()) + } +} + +impl<'a> RawDemuxCore<'a> for ARMovieDemuxer<'a> { + #[allow(clippy::neg_cmp_op_on_partial_ord)] + fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> { + let magic = self.src.read_string()?; + validate!(&magic == b"ARMovie"); + let _name = self.src.read_string()?; + let _date_and_copyright = self.src.read_string()?; + let _author = self.src.read_string()?; + + let video_id = self.src.read_string()?; + let video_codec = parse_int(&video_id)?; + let width = self.src.read_string()?; + let width = parse_int(&width)?; + let height = self.src.read_string()?; + let height = parse_int(&height)?; + validate!((video_codec <= 0) || (width > 0 && height > 0)); + let width = width as usize; + let height = height as usize; + let vformat = self.src.read_string()?; + let fps = self.src.read_string()?; + let fps = parse_float(&fps)?; + + let sound_id = self.src.read_string()?; + let sound_ids = split_sound_str(&sound_id)?; + let mut num_sound = sound_ids.len(); + if num_sound == 1 { + let sound_codec = parse_int(sound_ids[0])?; + if sound_codec < 1 { + num_sound = 0; + } + } + let srate = self.src.read_string()?; + let srates = split_sound_str(&srate)?; + let chan = self.src.read_string()?; + let channels = split_sound_str(&chan)?; + let sndformat = self.src.read_string()?; + let sndformats = split_sound_str(&sndformat)?; + + let frm_per_chunk = self.src.read_string()?; + let frm_per_chunk = parse_uint(&frm_per_chunk)? as usize; + validate!(frm_per_chunk > 0); + let num_chunks = self.src.read_string()?; + let num_chunks = parse_uint(&num_chunks)? as usize + 1; + let even_chunk_size = self.src.read_string()?; + let even_chunk_size = parse_uint(&even_chunk_size)? as usize; + let odd_chunk_size = self.src.read_string()?; + let odd_chunk_size = parse_uint(&odd_chunk_size)? as usize; + let cat_offset = self.src.read_string()?; + let cat_offset = parse_uint(&cat_offset)?; + + let _sprite_offset = self.src.read_string()?; + let _sprite_size = self.src.read_string()?; + let _kf_offset_res = self.src.read_string(); // may be not present for older ARMovies + + self.parse_catalogue(cat_offset, num_chunks, even_chunk_size, odd_chunk_size, num_sound)?; + + let mut stream_id = 0; + if video_codec > 0 { + let codec_name = if let Some(idx) = VIDEO_CODECS.iter().position(|&(id, _)| id == video_codec) { + VIDEO_CODECS[idx].1 + } else { + "unknown" + }; + validate!(fps > 1.0e-4); + let mut tbase = fps; + let mut tb_num = 1; + while tbase.fract() > 1.0e-4 { + tb_num *= 10; + tbase *= 10.0; + } + let tb_den = tbase as u32; + + let mut edata = vec![video_codec as u8, (video_codec >> 8) as u8]; + edata.extend_from_slice(&vformat); + + let fmt = match video_codec { + 600 => PAL8_FORMAT, + 601 => RGB565_FORMAT, + _ => YUV420_FORMAT, + }; + + let vci = NACodecTypeInfo::Video(NAVideoInfo::new(width, height, false, fmt)); + let vinfo = NACodecInfo::new(codec_name, vci, Some(edata)); + let ret = strmgr.add_stream(NAStream::new(StreamType::Video, stream_id, vinfo, tb_num, tb_den, (frm_per_chunk * num_chunks) as u64)); + if ret.is_some() { + stream_id += 1; + self.video_id = ret; + } else { + return Err(DemuxerError::MemoryError); + } + } + + if num_sound > 0 { + validate!(sound_ids.len() == srates.len()); + validate!(sound_ids.len() == channels.len()); + validate!(sound_ids.len() == sndformats.len()); + for ((&id, &sratestr), (&chan, &fmt)) in sound_ids.iter().zip(srates.iter()) + .zip(channels.iter().zip(sndformats.iter())) { + let codec_id = parse_uint(id)?; + let codec_name = if codec_id == 1 { "arm_rawaudio" } else { "unknown" }; + let channels = parse_uint(chan)?; + validate!(channels > 0 && channels < 16); + let edata = fmt.to_owned(); + let bits = parse_uint(fmt)?; + let mut srate = parse_uint(sratestr)?; + if srate > 0 && srate < 1000 { // probably in microseconds instead of Hertz + srate = 1000000 / srate; + } +//println!(" codec id {codec_id} srate {srate} chan {channels} bits {bits}"); + let fmt = if bits == 8 { SND_U8_FORMAT } else { SND_S16_FORMAT }; + + let aci = NACodecTypeInfo::Audio(NAAudioInfo::new(srate, channels as u8, fmt, 0)); + let ainfo = NACodecInfo::new(codec_name, aci, Some(edata)); + let ret = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_id, ainfo, 1, srate, 0)); + if let Some(id) = ret { + self.audio_ids.push(id); + stream_id += 1; + } else { + return Err(DemuxerError::MemoryError); + } + } + } + + Ok(()) + } + + fn get_data(&mut self, strmgr: &mut StreamManager) -> DemuxerResult { + while self.cur_chunk < self.chunk_offs.len() { + let chunk = &self.chunk_offs[self.cur_chunk]; + match self.state { + ReadState::None => { + self.src.seek(SeekFrom::Start(u64::from(chunk.offset)))?; + self.state = ReadState::Video; + } + ReadState::Video => { + self.state = ReadState::Audio(0); + if chunk.vid_size > 0 { + validate!(self.video_id.is_some()); + if let Some(stream) = strmgr.get_stream(self.video_id.unwrap_or(0)) { + let mut buf = vec![0; chunk.vid_size as usize]; + self.src.read_buf(&mut buf)?; + return Ok(NARawData::new(stream, buf)); + } else { + return Err(DemuxerError::InvalidData); + } + } + }, + ReadState::Audio(idx) => { + if idx < chunk.aud_sizes.len() { + self.state = ReadState::Audio(idx + 1); + if chunk.aud_sizes[idx] > 0 { + if let Some(stream) = strmgr.get_stream(self.audio_ids[idx]) { + let mut buf = vec![0; chunk.aud_sizes[idx] as usize]; + self.src.read_buf(&mut buf)?; + return Ok(NARawData::new(stream, buf)); + } else { + return Err(DemuxerError::InvalidData); + } + } + } else { + self.cur_chunk += 1; + self.state = ReadState::None; + } + }, + } + } + + Err(DemuxerError::EOF) + } + + fn seek(&mut self, _time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> { + Err(DemuxerError::NotPossible) + } + fn get_duration(&self) -> u64 { 0 } +} + +impl<'a> NAOptionHandler for ARMovieDemuxer<'a> { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub struct ARMovieDemuxerCreator { } + +impl RawDemuxerCreator for ARMovieDemuxerCreator { + fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { + Box::new(ARMovieDemuxer::new(br)) + } + fn get_name(&self) -> &'static str { "armovie" } + fn check_format(&self, br: &mut ByteReader) -> bool { + let mut hdr = [0; 8]; + br.read_buf(&mut hdr).is_ok() && &hdr == b"ARMovie\n" + } +} + +#[cfg(test)] +mod test { + use super::*; + use std::fs::File; + + #[test] + fn test_armovie_demux() { + // a sample from Acorn Replay Demonstration Disc 2 + let mut file = File::open("assets/Acorn/CHEMSET2").unwrap(); + let mut fr = FileReader::new_read(&mut file); + let mut br = ByteReader::new(&mut fr); + let mut dmx = ARMovieDemuxer::new(&mut br); + let mut sm = StreamManager::new(); + let mut si = SeekIndex::new(); + dmx.open(&mut sm, &mut si).unwrap(); + + loop { + let pktres = dmx.get_data(&mut sm); + if let Err(e) = pktres { + if e == DemuxerError::EOF { break; } + panic!("error"); + } + let pkt = pktres.unwrap(); + println!("Got {}", pkt); + } + } +} diff --git a/nihav-acorn/src/demuxers/mod.rs b/nihav-acorn/src/demuxers/mod.rs new file mode 100644 index 0000000..2acc820 --- /dev/null +++ b/nihav-acorn/src/demuxers/mod.rs @@ -0,0 +1,27 @@ +use nihav_core::demuxers::*; + + +#[allow(unused_macros)] +#[cfg(debug_assertions)] +macro_rules! validate { + ($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DemuxerError::InvalidData); } }; +} +#[cfg(not(debug_assertions))] +macro_rules! validate { + ($a:expr) => { if !$a { return Err(DemuxerError::InvalidData); } }; +} + +#[cfg(feature="demuxer_armovie")] +mod armovie; + +const RAW_DEMUXERS: &[&dyn RawDemuxerCreator] = &[ +#[cfg(feature="demuxer_armovie")] + &armovie::ARMovieDemuxerCreator {}, +]; + +/// Registers all available demuxers provided by this crate. +pub fn acorn_register_all_raw_demuxers(rd: &mut RegisteredRawDemuxers) { + for demuxer in RAW_DEMUXERS.iter() { + rd.add_demuxer(*demuxer); + } +} diff --git a/nihav-acorn/src/lib.rs b/nihav-acorn/src/lib.rs new file mode 100644 index 0000000..0a99f67 --- /dev/null +++ b/nihav-acorn/src/lib.rs @@ -0,0 +1,11 @@ +//! Crate for providing support for various Acorn Replay Movie formats. +extern crate nihav_core; +extern crate nihav_codec_support; + +mod codecs; + +mod demuxers; + +pub use crate::codecs::acorn_register_all_decoders; +pub use crate::codecs::acorn_register_all_packetisers; +pub use crate::demuxers::acorn_register_all_raw_demuxers; \ No newline at end of file diff --git a/nihav-allstuff/Cargo.toml b/nihav-allstuff/Cargo.toml index 33eea15..1ff2264 100644 --- a/nihav-allstuff/Cargo.toml +++ b/nihav-allstuff/Cargo.toml @@ -7,6 +7,7 @@ edition = "2018" [dependencies] nihav_core = { path = "../nihav-core" } nihav_commonfmt = { path = "../nihav-commonfmt" } +nihav_acorn = { path = "../nihav-acorn" } nihav_duck = { path = "../nihav-duck" } nihav_flash = { path = "../nihav-flash" } nihav_game = { path = "../nihav-game" } diff --git a/nihav-allstuff/src/lib.rs b/nihav-allstuff/src/lib.rs index 3b6d60f..2c3db75 100644 --- a/nihav-allstuff/src/lib.rs +++ b/nihav-allstuff/src/lib.rs @@ -8,6 +8,7 @@ use nihav_core::demuxers::RegisteredRawDemuxers; use nihav_core::muxers::RegisteredMuxers; use nihav_commonfmt::*; +use nihav_acorn::*; use nihav_duck::*; use nihav_flash::*; use nihav_game::*; @@ -25,6 +26,7 @@ use nihav_vivo::*; /// Registers all known decoders. pub fn nihav_register_all_decoders(rd: &mut RegisteredDecoders) { generic_register_all_decoders(rd); + acorn_register_all_decoders(rd); duck_register_all_decoders(rd); flash_register_all_decoders(rd); game_register_all_decoders(rd); @@ -47,6 +49,7 @@ pub fn nihav_register_all_mt_decoders(rd: &mut RegisteredMTDecoders) { /// Registers all known packetisers. pub fn nihav_register_all_packetisers(rp: &mut RegisteredPacketisers) { + acorn_register_all_packetisers(rp); llaudio_register_all_packetisers(rp); mpeg_register_all_packetisers(rp); } @@ -66,6 +69,7 @@ pub fn nihav_register_all_demuxers(rd: &mut RegisteredDemuxers) { /// Registers all known raw stream demuxers. pub fn nihav_register_all_raw_demuxers(rd: &mut RegisteredRawDemuxers) { + acorn_register_all_raw_demuxers(rd); llaudio_register_all_raw_demuxers(rd); } diff --git a/nihav-codec-support/src/test/dec_video.rs b/nihav-codec-support/src/test/dec_video.rs index 8915a73..9833f23 100644 --- a/nihav-codec-support/src/test/dec_video.rs +++ b/nihav-codec-support/src/test/dec_video.rs @@ -349,6 +349,123 @@ println!("full hash {}", md5); } } +/// Tests decoder for requested codec in provided file with raw streams. +/// +/// This functions tries to decode a stream corresponding to `dec_name` codec in input file and validate the results against expected ones. +/// +/// Since the function is intended for tests, it will panic instead of returning an error. +/// +/// # Examples +/// +/// Test FLAC decoder in test stream: +/// ```no_run +/// use nihav_codec_support::test::ExpectedTestResult; +/// use nihav_codec_support::test::dec_video::test_decoding_raw; +/// use nihav_core::codecs::RegisteredDecoders; +/// use nihav_core::demuxers::RegisteredDemuxers; +/// +/// let mut dmx_reg = RegisteredRawDemuxers::new(); +/// let mut pkt_reg = RegisteredPacketisers::new(); +/// let mut dec_reg = RegisteredDecoders::new(); +/// // ... register FLAC demuxer, packetiser and decoders ... +/// test_decoding_raw("flac", "flac", "assets/test_file.flac", None, &dmx_reg, &pkt_reg, &dec_reg, ExpectedTestResult::MD5([0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f])); +/// ``` +pub fn test_decoding_raw(demuxer: &str, dec_name: &str, filename: &str, limit: Option, + dmx_reg: &RegisteredRawDemuxers, pkt_reg: &RegisteredPacketisers, + dec_reg: &RegisteredDecoders, test: ExpectedTestResult) { + let dmx_f = dmx_reg.find_demuxer(demuxer).unwrap(); + let mut file = File::open(filename).unwrap(); + let mut fr = FileReader::new_read(&mut file); + let mut br = ByteReader::new(&mut fr); + let mut dmx = create_raw_demuxer(dmx_f, &mut br).unwrap(); + + let mut decs: Vec, Box, Box)>> = Vec::new(); + let mut found = false; + for i in 0..dmx.get_num_streams() { + let s = dmx.get_stream(i).unwrap(); + let info = s.get_info(); +println!("stream {} codec {} / {}", i, info.get_name(), dec_name); + if !found && (info.get_name() == dec_name) { + let decfunc = dec_reg.find_decoder(info.get_name()); + let pktfunc = pkt_reg.find_packetiser(info.get_name()); + if let (Some(df), Some(pf)) = (decfunc, pktfunc) { + let mut pkt = (pf)(); + pkt.attach_stream(s); + let mut dec = (df)(); + let mut dsupp = Box::new(NADecoderSupport::new()); + dec.init(&mut dsupp, info).unwrap(); + decs.push(Some((pkt, dsupp, dec))); + found = true; + } else { + decs.push(None); + } + } else { + decs.push(None); + } + } + + let mut md5 = MD5::new(); + let mut frameiter = if let ExpectedTestResult::MD5Frames(ref vec) = test { + Some(vec.iter()) + } else { + None + }; + loop { + let datares = dmx.get_data(); + if let Err(e) = datares { + if e == DemuxerError::EOF { break; } + panic!("error"); + } + let data = datares.unwrap(); + let streamno = data.get_stream().get_id() as usize; + if let Some((ref mut pktr, ref mut dsupp, ref mut dec)) = decs[streamno] { + pktr.add_data(&data.get_buffer()); + while let Ok(Some(pkt)) = pktr.get_packet(data.get_stream()) { + if limit.is_some() && pkt.get_pts().is_some() && pkt.get_pts().unwrap() > limit.unwrap() { + break; + } + let frm = dec.decode(dsupp, &pkt).unwrap(); + match &test { + ExpectedTestResult::Decodes => {}, + ExpectedTestResult::MD5(_) => { frame_checksum(&mut md5, frm); }, + ExpectedTestResult::MD5Frames(_) => { + md5 = MD5::new(); + frame_checksum(&mut md5, frm); + md5.finish(); + if let Some(ref mut iter) = frameiter { + let ret = iter.next(); + if ret.is_none() { break; } + let ref_hash = ret.unwrap(); + let mut hash = [0u32; 4]; + md5.get_hash(&mut hash); +println!("frame pts {:?} hash {}", pkt.get_pts(), md5); + assert_eq!(&hash, ref_hash); + } + }, + ExpectedTestResult::GenerateMD5Frames => { + md5 = MD5::new(); + frame_checksum(&mut md5, frm); + md5.finish(); + let mut hash = [0u32; 4]; + md5.get_hash(&mut hash); +println!("frame pts {:?} hash [0x{:08x}, 0x{:08x}, 0x{:08x}, 0x{:08x}],", pkt.get_pts(), hash[0], hash[1], hash[2], hash[3]); + }, + }; + } + } + } + if let ExpectedTestResult::MD5(ref ref_hash) = test { + md5.finish(); + let mut hash = [0u32; 4]; + md5.get_hash(&mut hash); +println!("full hash {}", md5); + assert_eq!(&hash, ref_hash); + } + if let ExpectedTestResult::GenerateMD5Frames = test { + panic!("generated hashes"); + } +} + const THREADS: usize = 3; fn check_frame(frm: NAFrameRef, test: &ExpectedTestResult, glbl_md5: &mut MD5, frameiter: &mut Option>, last_ts: &mut Option) -> bool { diff --git a/nihav-core/src/codecs/mod.rs b/nihav-core/src/codecs/mod.rs index 37857d9..80e2da8 100644 --- a/nihav-core/src/codecs/mod.rs +++ b/nihav-core/src/codecs/mod.rs @@ -427,16 +427,22 @@ impl RegisteredEncoders { /// Trait for packetisers (objects that form full packets from raw stream data). pub trait NAPacketiser { + /// Provides the reference stream from the demuxer to the packetiser. + /// + /// This may be useful in cases when packetiser cannot determine stream parameters by itself. + fn attach_stream(&mut self, stream: NAStreamRef); /// Queues new raw stream data for parsing. /// /// Returns false is the internal buffer grows too large. fn add_data(&mut self, src: &[u8]) -> bool; /// Tries to retrieve stream information from the data. /// - /// Returns [`NAStream`] reference on success (with stream ID set to `id`), [`ShortData`] when there is not enough data to parse the headers and other errors in case there was an error parsing the data. + /// Returns [`NAStream`] reference on success (with stream ID set to `id`), [`ShortData`] when there is not enough data to parse the headers, [`MissingReference`] when stream parsing is not possible without reference information provided by [`attach_stream`] and other errors in case there was an error parsing the data. /// /// [`NAStream`]: ../frame/struct.NAStream.html /// [`ShortData`]: ./enum.DecoderError.html#variant.ShortData + /// [`MissingReference`]: ./enum.DecoderError.html#variant.MissingReference + /// [`attach_stream`]: ./trait.NAPacketiser.html#tymethod.attach_stream fn parse_stream(&mut self, id: u32) -> DecoderResult; /// Tries to discard junk data until the first possible packet header. /// diff --git a/nihav-llaudio/src/codecs/flac.rs b/nihav-llaudio/src/codecs/flac.rs index 6d71981..6ebc78d 100644 --- a/nihav-llaudio/src/codecs/flac.rs +++ b/nihav-llaudio/src/codecs/flac.rs @@ -552,6 +552,7 @@ impl FLACPacketiser { } impl NAPacketiser for FLACPacketiser { + fn attach_stream(&mut self, _stream: NAStreamRef) {} fn add_data(&mut self, src: &[u8]) -> bool { self.buf.extend_from_slice(src); self.buf.len() < 4096 diff --git a/nihav-mpeg/src/codecs/aac/mod.rs b/nihav-mpeg/src/codecs/aac/mod.rs index 179134c..e37e812 100644 --- a/nihav-mpeg/src/codecs/aac/mod.rs +++ b/nihav-mpeg/src/codecs/aac/mod.rs @@ -330,12 +330,14 @@ impl ChannelPair { self.ms_used[g][sfb] = br.read_bool()?; } } + } else { + self.ms_used = [[false; MAX_SFBS]; MAX_WINDOWS]; } self.ics[1].info = self.ics[0].info; } self.ics[0].decode_ics(br, codebooks, m4atype, common_window, true)?; self.ics[1].decode_ics(br, codebooks, m4atype, common_window, true)?; - if common_window && self.ms_mask_present != 0 { + if common_window { let mut g = 0; for w in 0..self.ics[0].info.num_windows { if w > 0 && !self.ics[0].info.scale_factor_grouping[w - 1] { diff --git a/nihav-mpeg/src/codecs/mpegaudio/mod.rs b/nihav-mpeg/src/codecs/mpegaudio/mod.rs index 677e81b..e883df8 100644 --- a/nihav-mpeg/src/codecs/mpegaudio/mod.rs +++ b/nihav-mpeg/src/codecs/mpegaudio/mod.rs @@ -373,6 +373,7 @@ impl MPAPacketiser { } impl NAPacketiser for MPAPacketiser { + fn attach_stream(&mut self, _stream: NAStreamRef) {} fn add_data(&mut self, src: &[u8]) -> bool { self.buf.extend_from_slice(src); self.buf.len() < 4096 diff --git a/nihav-registry/src/detect.rs b/nihav-registry/src/detect.rs index cf17875..87226a7 100644 --- a/nihav-registry/src/detect.rs +++ b/nihav-registry/src/detect.rs @@ -250,6 +250,11 @@ const DETECTORS: &[DetectConditions] = &[ extensions: ".y4m", conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"YUV4MPEG2 ") }], }, + DetectConditions { + demux_name: "armovie", + extensions: ".rpl", + conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"ARMovie\n") }], + }, DetectConditions { demux_name: "flv", extensions: ".flv", diff --git a/nihav-registry/src/register.rs b/nihav-registry/src/register.rs index f9f0fb2..15a3f65 100644 --- a/nihav-registry/src/register.rs +++ b/nihav-registry/src/register.rs @@ -207,6 +207,20 @@ static CODEC_REGISTER: &[CodecDescription] = &[ desc!(audio; "qdesign-music2", "QDesign Music v2"), desc!(audio; "qualcomm-purevoice", "Qualcomm PureVoice"), + desc!(video-ll; "arm_rawvideo", "Acorn Replay Movie raw video formats"), + desc!(audio; "arm_rawaudio", "Acorn Replay Movie raw audio formats"), + desc!(video; "movinglines", "Acorn Moving Lines"), + desc!(video; "movingblocks", "Acorn Moving Blocks"), + desc!(video; "movingblockshq", "Acorn Moving Blocks HQ"), + desc!(video; "supermovingblocks", "Acorn Super Moving Blocks"), + desc!(video; "linepack", "Henrik Pedersen's LinePack"), + desc!(video; "movie16_3", "Henrik Pedersen's Movie 16:3"), + desc!(video; "escape100", "Eidos Escape 100"), + desc!(video; "escape102", "Eidos Escape 102"), + desc!(video; "escape122", "Eidos Escape 122"), + desc!(video; "escape124", "Eidos Escape 124"), + desc!(video; "escape130", "Eidos Escape 130"), + desc!(video; "truemotion1", "TrueMotion 1"), desc!(video-im; "truemotionrt", "TrueMotion RT"), desc!(video; "truemotion2", "TrueMotion 2"),