Showing preview only (555K chars total). Download the full file or copy to clipboard to get everything.
Repository: KyleRicardo/MentoHUST-OpenWrt-ipk
Branch: master
Commit: e0bc6ab4b29d
Files: 24
Total size: 503.5 KB
Directory structure:
gitextract_7iywx800/
├── .github/
│ └── workflows/
│ └── release-build.yml
├── Makefile
├── README.md
├── files/
│ ├── mentohust.conf
│ └── mentohust.init
└── src/
├── Makefile
├── dlfunc.c
├── dlfunc.h
├── md5.c
├── md5.h
├── mentohust.c
├── mycheck.c
├── mycheck.h
├── myconfig.c
├── myconfig.h
├── myfunc.c
├── myfunc.h
├── myini.c
├── myini.h
├── mystate.c
├── mystate.h
├── strnormalize.c
├── strnormalize.h
└── types.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/release-build.yml
================================================
name: Build
on:
release:
types:
- published
jobs:
build:
name: Build ${{ matrix.arch }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
arch:
- aarch64_cortex-a53
- aarch64_cortex-a72
- aarch64_generic
- arm_arm1176jzf-s_vfp
- arm_arm926ej-s
- arm_cortex-a15_neon-vfpv4
- arm_cortex-a5_vfpv4
- arm_cortex-a7
- arm_cortex-a7_neon-vfpv4
- arm_cortex-a8_vfpv3
- arm_cortex-a9
- arm_cortex-a9_neon
- arm_cortex-a9_vfpv3-d16
- arm_fa526
- arm_mpcore
- arm_xscale
- i386_pentium-mmx
- i386_pentium4
- mips64_octeonplus
- mips_24kc
- mips_4kec
- mips_mips32
- mipsel_24kc
- mipsel_24kc_24kf
- mipsel_74kc
- mipsel_mips32
- x86_64
steps:
- uses: actions/checkout@v3
with:
path: './mentohust'
fetch-depth: 0
- name: Building packages
uses: openwrt/gh-action-sdk@main
env:
ARCH: ${{ matrix.arch }}-openwrt-21.02
FEEDNAME: packages_ci
PACKAGES: mentohust
NO_REFRESH_CHECK: true
- name: Upload artifacts
uses: actions/upload-artifact@v3
with:
name: ${{ matrix.arch }}
path: bin/packages/${{ matrix.arch }}/packages_ci/*.ipk
- name: Upload packages
uses: ncipollo/release-action@v1
with:
token: ${{ secrets.GITHUB_TOKEN }}
allowUpdates: true
replacesArtifacts: true
artifacts: "bin/packages/${{ matrix.arch }}/packages_ci/*.ipk"
================================================
FILE: Makefile
================================================
#
# Copyright (C) 2014-2015 KyleRicardo
#
# This is free software, licensed under the GNU General Public License v3.
# See /LICENSE for more information.
#
include $(TOPDIR)/rules.mk
PKG_NAME:=mentohust
PKG_VERSION:=0.3.1
PKG_RELEASE:=1
PKG_FIXUP:=autoreconf
PKG_INSTALL:=1
include $(INCLUDE_DIR)/package.mk
define Package/mentohust
SECTION:=net
CATEGORY:=Network
DEPENDS:=+libpcap
TITLE:=A Ruijie Client Daemon
URL:=https://github.com/KyleRicardo/MentoHUST-OpenWrt-ipk.git
SUBMENU:=Ruijie
endef
define Package/mentohust/description
A Ruijie Client Daemon,
Most usually used in Chinese universities.
endef
define Build/Prepare
mkdir -p $(PKG_BUILD_DIR)
$(CP) ./src/* $(PKG_BUILD_DIR)/
$(SED) 's/dhclient/udhcpc -i/g' $(PKG_BUILD_DIR)/myconfig.c
endef
define Package/mentohust/conffiles
/etc/mentohust.conf
endef
define Build/Compile
#$(Build/Compile/$(PKG_NAME))
$(MAKE) -C $(PKG_BUILD_DIR)/ \
$(TARGET_CONFIGURE_OPTS) \
CFLAGS="$(TARGET_CFLAGS)" \
CPPFLAGS="$(TARGET_CPPFLAGS)" \
LDFLAGS="$(TARGET_LDFLAGS) -ldl"
endef
define Package/mentohust/install
$(INSTALL_DIR) $(1)/usr/sbin
$(INSTALL_BIN) $(PKG_BUILD_DIR)/mentohust $(1)/usr/sbin/
$(INSTALL_DIR) $(1)/etc
$(INSTALL_CONF) ./files/mentohust.conf $(1)/etc/mentohust.conf
$(INSTALL_DIR) $(1)/etc/init.d
$(INSTALL_BIN) ./files/mentohust.init $(1)/etc/init.d/mentohust
endef
$(eval $(call BuildPackage,$(PKG_NAME)))
================================================
FILE: README.md
================================================
# MentoHUST-OpenWrt-ipk
这是一个积累了很长时间的项目。从2014年起，就陆续在折腾这些东西，期间还自己写了一个基于OpenWrt的神州数码客户端[802.1X Evasi0n](https://github.com/KyleRicardo/802.1X-Evasi0n)，服役了大半年的时间，表现良好，内存占用小，工作效率高。后来，学校所有神州数码服务器全部换成了锐捷，导致我的项目失去了光彩，我又翻出了大名鼎鼎的MentoHUST，在反复折腾交叉编译和功能性修补过程中，有了这样一个版本。该版本非常适合于在OpenWrt的SDK环境下编译出MentoHUST的ipk包。
## 特性
- ~~修复了原MentoHUST在shell下由于libiconv库编译或工作不正常导致的反馈信息乱码问题~~
- 去除了libiconv库的依赖，加入了轻量级的strnormalize库，GBK to UTF-8转换良好
- 去除configure等冗余文件，仅保留核心src源码文件
- ~~./src/Makefile中使用通配符`*`指代libpcap版本，通用性更强~~
- Makefile使用`-lpcap`实现自动依赖`libpcap`而无需手动指定版本
- 无需手动配置环境变量，无需使用automake和configure生成所需Makefile
- 重新完全手动编写./和./src/目录下的Makefile，保证编译的有效性
- 无`--disable-notify --disable-encodepass`等配置，保证原汁原味
- 无手动`#define NO_DYLOAD`补丁，使用动态加载库函数，ipk包更小，并且更容易编译
## 贡献
本项目从开发至今已经接近10年。因为开发初衷是自用，所以并未支持最新算法。
考虑到各大高校算法不一，现准备尽可能提供更多帮助，提高项目的兼容性。欢迎小伙伴们对此项目进行贡献：
- 提供抓包的dump文件
- 提供算法参考代码或思路
- 提供测试环境
欢迎提交Issue(Feature Request)或PR。我会尽力完善这个项目。
## 从Release下载
受@sbwml启发（非常感谢），该仓库现已集成GitHub Actions。现在你可以从Release下载编译好的ipk啦。
在路由器的SSH中，使用`opkg print-architecture`命令查看支持的ipk架构。以红米AX6000为例：
```
$ opkg print-architecture
arch all 1
arch noarch 1
arch aarch64_cortex-a53 10
```
我们根据对应的架构，下载对应的ipk：
```bash
$ cd /tmp
$ wget https://github.com/KyleRicardo/MentoHUST-OpenWrt-ipk/releases/download/v0.3.1/mentohust_0.3.1-1_aarch64_cortex-a53.ipk
```
先安装`libpcap`依赖：
```bash
$ opkg update
$ opkg install libpcap
```
然后安装`MentoHUST`：
```bash
$ opkg install mentohust_0.3.1-1_aarch64_cortex-a53.ipk
```
下载的ipk安装包可以视情况保留或删除。
上述操作在红米AX6000上实机测试通过。其他架构请自行测试。
## 从源码编译
强烈建议从Release下载编译好的ipk。现如今不是所有的架构都能从OpenWrt官网找到对应的SDK，会导致编译比较麻烦。
### 预备知识
> 这里的编译是指交叉编译。所谓交叉编译，简单地说，就是在一个平台上生成另一个平台上的可执行代码。这里需要注意的是所谓 平台，实际上包含两个概念：体系结构（Architecture）、操作系统（Operating System）。同一个体系结构可以运行不同的操作系统；同样，同一个操作系统也可以在不同的体系结构上运行。
> 交叉编译通常是不得已而为之，有时是因为目的平台上不允许或不能够安装我们所需要的编译器，而我们又需要这个编译器的某些特征；有时是因为目的平台上的资源贫乏，无法运行我们所需要编译器；有时又是因为目的平台还没有建立，连操作系统都没有，根本谈不上运行什么编译器。
> OpenWrt系统是基于Linux平台的操作系统，故我们需要用到Linux的操作系统平台进行交叉编译。但由于种种原因，我们的电脑不可能使用Linux操作系统，但又要交叉编译，怎么办呢？这时候就需要用到虚拟机了。
### 需要的工具
- VMWare Workstation虚拟机工具（[官网下载](https://www.vmware.com/go/getworkstation-win)）
- 一个Ubuntu Linux镜像（可以使用最新LTS版本，[22.04LTS下载](https://releases.ubuntu.com/22.04.2/ubuntu-22.04.2-desktop-amd64.iso)）
- OpenWrt SDK（在[官网](https://downloads.openwrt.org/snapshots/targets/)寻找对应你路由器架构的版本，比如斐讯k2p是ramips的mt7621）
- SSH工具。这里推荐MobaXterm。当然你也可以用XShell等。
- 本项目的源码
注：OpenWrt SDK在[官网](https://downloads.openwrt.org/snapshots/targets/)找到对应架构后，在最下面`Supplementary Files → openwrt-sdk-<Platform>_gcc-<version>_musl.Linux-x86_64.tar.xz`，比如斐讯k2p是[openwrt-sdk-ramips-mt7621_gcc-12.2.0_musl.Linux-x86_64.tar.xz](https://downloads.openwrt.org/snapshots/targets/ramips/mt7621/openwrt-sdk-ramips-mt7621_gcc-12.2.0_musl.Linux-x86_64.tar.xz)。
### 小贴士: 关于虚拟机
关于虚拟机，在这里不多赘述，仅提供一些Tips。如果对虚拟机完全不了解，建议不要继续观看本教程，先找百度谷歌充充电。（也可以是ChatGPT或New Bing...？
- 推荐新手使用**Ubuntu**
> 虚拟机的Linux系统推荐使用Ubuntu，对于我们新手来说，这无疑是最适合于我们的系统，图形化的界面很贴心，基本操作上和Windows相差不大，可以较快的熟悉起来。
- 务必安装VMWare Tools工具
> 使用VMWare Workstation装Ubuntu的时候，千万不要选择简易安装，这样在后面安装VMware Tools会非常麻烦。先建立一个空虚拟机，然后再用镜像引导安装，这样就比较好，系统安装好了之后再安装上VMWare Tools你会发现这个Tools有多么方便。其中最大的好处有二：系统分辨率的自动调整和剪贴板的无缝连接。就是说，不管文字或者文件，你在windows里面使用Ctrl+C复制后，可以直接在Ubuntu里面粘贴，反之亦然。这在后面将给我们提供非常大的方便。所以，VMWare Tools必须安装，切记。
>
> 2021.11.28更新：现在VMWare比较先进了，似乎装好系统后自动加载了VMWare Tools。
- 务必关闭Ubuntu系统屏保和自动睡眠
> 还有一点需要提醒的是，安装好后，在右上角“系统”菜单的“首选项”中选择“屏幕保护程序”，然后去掉左下角的“计算机空闲时激活屏幕保护程序”，然后按“关闭”，这个窗口是没有“应用”或“确定”之类的，直接关闭它就会保存。用惯了WINDOWS的用户注意了。为什么要做这步呢？因为整个编译过程中有些步骤要等一段时间的，老是自动启用屏幕保护程序，然后还要重新输密码才能退出，也是麻烦事。开始的时候我忘了设置这一步，后来有一次把黑屏状态的虚拟机唤醒的时候，显卡瞬间崩溃了，虚拟机直接死机，然后编译了好久的数据丢失了，白白浪费了几个小时。这个教训也希望大家引起重视。
### 获取OpenWrt SDK
现在进入正题了，首先要做的是配置好SDK的交叉编译环境。
使用`Ctrl+Alt+T`组合快捷键打开终端，然后在左侧的Dock中，右键单击，将其锁定，方便以后打开。如下图：
在下文中，终端里执行的命令，如果是`$`开头，说明是以普通用户执行；如果是`#`开头，说明是以root用户（最高权限）执行。在输入终端时**不用输入**`$`或`#`符号。
我们的虚拟机是全新系统，缺少许多交叉编译所需的必要组件与工具。先执行如下命令将它们一并安装：
```bash
$ sudo apt install -y git curl vim build-essential libncurses5-dev zlib1g-dev gawk flex quilt python3-distutils libssl-dev xsltproc libxml-parser-perl mercurial bzr ecj cvs unzip
```
下面就是来获取trunk版本的SDK了，执行命令：
```bash
$ cd Downloads/
$ wget https://downloads.openwrt.org/snapshots/targets/ramips/mt7621/openwrt-sdk-ramips-mt7621_gcc-12.2.0_musl.Linux-x86_64.tar.xz
```
下载好SDK后，我们先解压：
```bash
$ tar -Jxf openwrt-sdk-ramips-mt7621_gcc-12.2.0_musl.Linux-x86_64.tar.xz
```
可以利用Ubuntu的自动填充，就是输入`tar -Jxf op`然后按一下Tab键，就会自动填充为上面的命令。记住这一点，以后会经常用到，熟练使用自动填充会节约不少时间。
解压好后，cd到SDK目录下：
```shell
$ cd openwrt-sdk-ramips-mt7621_gcc-11.2.0_musl.Linux-x86_64
```
### 更新feeds
Feeds，也就是软件包列表，是在OpenWrt中共用位置的包的集合。运行以下命令即可更新内置软件包列表并将我们所需的`libpcap`库编译并安装到`staging_dir`中：
```shell
$ ./scripts/feeds update -a
$ ./scripts/feeds install libpcap
```
如果网速不快，可能需要等待一段时间。静待其完成后，我们的libpcap依赖就准备完毕了。
### 添加需要编译的第三方软件包（也就是我们的MentoHUST-OpenWrt-ipk）
首先要在GitHub上clone此repo至package/mentohust目录下。执行命令：
```bash
$ git clone https://github.com/KyleRicardo/MentoHUST-OpenWrt-ipk.git package/mentohust
```
这里说一下我的Makefile。
一个工程中的源文件不计其数，其按类型、功能、模块分别放在若干个目录中，Makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为 Makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。
Makefile的语法规则并不算复杂，但是新手研究起来也很头大，也不能静下心来去花时间学习Makefile的写法。我虽然起初不会写Makefile，但是折腾了这么久之后，对于一个Makefile，已经不算什么了。于是GitHub上包含了我写的Makefile，同学们可以直接编译。下个版本可能会发布自动从网上下载源码并编译的Makefile。
原始的mentohust编码转换是使用的libiconv库，这个库问题特别多，效率低，不方便编译，受802.1X Evasi0n项目的启发，我干脆摒弃了libiconv库，使用了strnormalize这个文件代替了它，一次性解决了编码转换问题。所以现在，Makefile里面再也找不到iconv的依赖了，现在mentohust唯一依赖的库就是libpcap，编译起来也是相当轻松了。
Makefile既然已经包括在源码中，那么我们可以开始配置我们的编译器了。使用命令：
```bash
$ make menuconfig
```
这个命令会启用图形化的选项，我们在其中进行调节即可。
在Makefile里面我们已经知道，这个软件包是属于Network里的Ruijie，所以我们在主菜单中找到Network，回车进入，然后找到Ruijie这一项
然后到这里
我们会发现系统已经自动帮我们选中了该软件包。如果没有，我们按M键选中，将其编译为一个组件模块(Module)。
用M键选中后，我们用光标键右几次选中Save，保存后，再多次Exit，最终退出这个界面。
### 编译
```bash
$ make package/mentohust/compile -j$((`nproc`+1)) V=s
```
其中，`-jN`是开启多线程编译，`N`代表线程数，这里是获取逻辑CPU数量+1。`V=s`表示开启详细输出，如果有错误我们好进行排查。如果多线程编译出问题，可以试试单线程，出错概率会减小但是时间会增加不少：
```shell
$ make package/mentohust/compile V=s
```
如果顺利，编译完成之后就能在`<OpenWrt SDK>/bin/packages/<YourArchitecture>/base`中找到你的ipk包了。比如我虚拟机中的位置为：
```
~/Downloads/openwrt-sdk-ramips-mt7621_gcc-12.2.0_musl.Linux-x86_64/bin/packages/mipsel_24kc/base
```
其中还包含其依赖的libpcap.ipk。如果你的路由器默认没有安装libpcap包，可以一并安装。
### 安装
将上面拷贝出来的mentohust及libpcap的ipk，通过SCP拷贝到路由器的`/tmp`目录下。
然后`cd`到`/tmp`目录，执行：
```bash
$ opkg install libpcap1_1.10.3-1_mipsel_24kc.ipk
$ opkg install mentohust_0.3.1-1_mipsel_24kc.ipk
```
结束。现在2023年了，很多之前会出现的问题已经不复存在了。
## 用法
安装好后可以立即使用，配置文件在`/etc/mentohust.conf`，可以自行编辑。
关于mentohust的用法，想必不用我多说吧。我都已经帮忙帮到这一步了。这里提一下，mentohust未能智能识别路由器WAN口对应的网卡，请手动在mentohust.conf的末尾DHCP脚本中添加自己WAN口对应的网卡。最终脚本类似`udhcpc -i eth1`。
## 已知问题
- mentohust未能智能识别路由器WAN口对应的网卡，请手动在mentohust.conf的末尾DHCP脚本中添加自己WAN口对应的网卡。最终脚本类似`udhcpc -i eth1`
- ~~暂未加入init.d目录的mentohust脚本，可能下个版本加入。~~已加入自启动脚本
- 后续可能加入只有一个Makefile，通过自动从git下载源码进行编译的版本
================================================
FILE: files/mentohust.conf
================================================
# MentoHUST for Linux By HustMoon Studio
#
# 配置文件名称必须是小写/etc/mentohust.conf，编码格式建议是UTF-8
# 配置文件中一行开头的空格和Tab会被忽略，其他的会视为参数一部分
# 配置文件中Section与Key不区分大小写，以#或;开头的行视为注释
# 同一个参数若在命令行参数和配置文件中均有设置，使用命令行参数
# 命令行中使用参数-h或-?可查看详细参数信息，建议通过命令行设置参数
# 命令行中使用参数-w可将配置更新到/etc/mentohust.conf
[MentoHUST]
;用户名，长度不超过64
Username=
;密码(简单加密)
EncodePass=
;网卡
Nic=
;静态IP用户可以使用非本机IP
IP=
;掩码，无关紧要
Mask=
;网关，如果指定了就会监视网关ARP信息
Gateway=
;DNS服务器，无关紧要
DNS=
;Ping主机，用于掉线检测，0.0.0.0表示关闭该功能
PingHost=
;每次发包超时时间（秒）
Timeout=
;发送Echo包的间隔（秒）
EchoInterval=
;失败等待（秒）认证失败后等待RestartWait秒或者服务器请求后重启认证
RestartWait=
;寻找服务器时的组播地址类型 0标准 1锐捷 2将MentoHUST用于赛尔认证
StartMode=
;DHCP方式 0(不使用) 1(二次认证) 2(认证后) 3(认证前)
DhcpMode=
;是否后台运行: 0(否) 1(是，关闭输出) 2(是，保留输出) 3(是，输出到文件/tmp/mentohust.log)
DaemonMode=
;是否显示通知： 0(否) 1~20(是)
ShowNotify=
;客户端版本号，如果未开启客户端校验但对版本号有要求，可以在此指定，形如3.30
Version=
;认证数据文件，如果需要校验客户端，就需要正确设置
DataFile=
;进行DHCP的脚本
DhcpScript=
================================================
FILE: files/mentohust.init
================================================
#!/bin/sh /etc/rc.common
START=99
STOP=01
USE_PROCD=1
PROG=/usr/sbin/mentohust
start_service() {
procd_open_instance
procd_set_param command "$PROG"
procd_set_param respawn
procd_set_param stdout 1
procd_set_param stderr 1
procd_close_instance
}
stop_service() {
"$PROG" -k
}
================================================
FILE: src/Makefile
================================================
include $(TOPDIR)/rules.mk
include $(INCLUDE_DIR)/package.mk
CC = mips-openwrt-linux-gcc
CFLAGS = -Wall -g -O2
INC_DIR= $(STAGING_DIR)/usr/include
LINK_DIR= $(STAGING_DIR)/usr/lib
LIBS= -lpcap
OBJ = mentohust.o dlfunc.o md5.o mycheck.o myconfig.o myfunc.o strnormalize.o myini.o mystate.o
.PHONY: all
all: mentohust
mentohust: $(OBJ)
$(CC) $(CFLAGS) -o $@ $(OBJ) $(LIBS) -I$(INC_DIR) -L$(LINK_DIR) $(LDFLAGS)
mentohust.o : mentohust.c
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
dlfunc.o : dlfunc.c
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
md5.o : md5.c md5.h
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
strnormalize.o: strnormalize.c strnormalize.h
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
mycheck.o : mycheck.c
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
myconfig.o : myconfig.c
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
myfunc.o : myfunc.c
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
myini.o : myini.c
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
mystate.o : mystate.c
$(CC) $(CFLAGS) -c $< -I$(INC_DIR)
clean :
rm -v $(OBJ) mentohust
================================================
FILE: src/dlfunc.c
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：dlfunc.c
* 摘 要：动态载入库函数
* 作 者：HustMoon@BYHH
* 邮 箱：www.ehust@gmail.com
* 日 期：2009.11.11
*/
#include "dlfunc.h"
#ifndef NO_DYLOAD
#include <dlfcn.h>
int (*pcap_findalldevs)(pcap_if_t **, char *);
void (*pcap_freealldevs)(pcap_if_t *);
pcap_t *(*pcap_open_live)(const char *, int, int, int, char *);
int (*pcap_compile)(pcap_t *, struct bpf_program *, const char *, int, bpf_u_int32);
int (*pcap_setfilter)(pcap_t *, struct bpf_program *);
char *(*pcap_geterr)(pcap_t *);
void (*pcap_freecode)(struct bpf_program *);
int (*pcap_loop)(pcap_t *, int, pcap_handler, unsigned char *);
void (*pcap_close)(pcap_t *);
void (*pcap_breakloop)(pcap_t *);
int (*pcap_sendpacket)(pcap_t *, const unsigned char *, int);
static void *libpcap = NULL;
int load_libpcap(void) {
char *error;
#ifdef MAC_OS
char *file[] = {"libpcap.dylib", "libpcap.A.dylib"};
int i, count = 2;
#else
char *file[] = {"libpcap.so", "libpcap.so.1", "libpcap.so.1.0", "libpcap.so.0.9", "libpcap.so.0.8"};
int i, count = 5;
#endif
for (i=0; i<count && !libpcap; i++) {
libpcap = dlopen(file[i], RTLD_LAZY);
error = dlerror();
}
if (libpcap == NULL) {
printf("!! 打开libpcap失败，请检查是否已安装该库文件。\n");
return -1;
}
if ((pcap_findalldevs = dlsym(libpcap, "pcap_findalldevs"), error = dlerror()) != NULL
|| (pcap_freealldevs = dlsym(libpcap, "pcap_freealldevs"), error = dlerror()) != NULL
|| (pcap_open_live = dlsym(libpcap, "pcap_open_live"), error = dlerror()) != NULL
|| (pcap_compile = dlsym(libpcap, "pcap_compile"), error = dlerror()) != NULL
|| (pcap_setfilter = dlsym(libpcap, "pcap_setfilter"), error = dlerror()) != NULL
|| (pcap_geterr = dlsym(libpcap, "pcap_geterr"), error = dlerror()) != NULL
|| (pcap_freecode = dlsym(libpcap, "pcap_freecode"), error = dlerror()) != NULL
|| (pcap_loop = dlsym(libpcap, "pcap_loop"), error = dlerror()) != NULL
|| (pcap_close = dlsym(libpcap, "pcap_close"), error = dlerror()) != NULL
|| (pcap_breakloop = dlsym(libpcap, "pcap_breakloop"), error = dlerror()) != NULL
|| (pcap_sendpacket = dlsym(libpcap, "pcap_sendpacket"), error = dlerror()) != NULL) {
printf("!! 从libpcap获取函数失败: %s\n", error);
free_libpcap();
return -1;
}
return 0;
}
void free_libpcap(void) {
if (libpcap) {
dlclose(libpcap);
dlerror();
libpcap = NULL;
}
}
#endif /* NO_DYLOAD */
#ifndef NO_NOTIFY
#include <dlfcn.h>
typedef void NotifyNotification, GtkWidget, GError;
typedef char gchar;
typedef int gint, gboolean;
static gboolean (*notify_notification_update)(NotifyNotification *, const gchar *,
const gchar *, const gchar *);
static void (*notify_notification_set_timeout)(NotifyNotification *, gint);
static gboolean (*notify_notification_show)(NotifyNotification *, GError **);
static void *libnotify = NULL;
static NotifyNotification *notify = NULL;
int load_libnotify(void) {
char *error;
gboolean (*notify_init)(const char *);
NotifyNotification *(*notify_notification_new)(const gchar *, const gchar *,
const gchar *, GtkWidget *);
#ifdef MAC_OS
char *file[] = {"libnotify.dylib", "libnotify.1.dylib"};
int i, count = 2;
#else
char *file[] = {"libnotify.so", "libnotify.so.1"};
int i, count = 2;
#endif
for (i=0; i<count && !libnotify; i++) {
libnotify = dlopen(file[i], RTLD_LAZY);
error = dlerror();
}
if (libnotify == NULL) {
printf("!! 打开libnotify失败，请检查是否已安装该库文件。\n");
return -1;
}
if ((notify_init = dlsym(libnotify, "notify_init"), error = dlerror()) != NULL
|| (notify_notification_new = dlsym(libnotify, "notify_notification_new"), error = dlerror()) != NULL
|| (notify_notification_show = dlsym(libnotify, "notify_notification_show"), error = dlerror()) != NULL
|| (notify_notification_update = dlsym(libnotify, "notify_notification_update"), error = dlerror()) != NULL
|| (notify_notification_set_timeout = dlsym(libnotify, "notify_notification_set_timeout"), error = dlerror()) != NULL) {
printf("!! 从libnotify获取函数失败: %s\n", error);
free_libnotify();
return -1;
}
if (!notify_init("mentohust")) {
printf("!! 初始化libnotify失败。\n");
free_libnotify();
return -1;
}
notify = notify_notification_new("MentoHUST", NULL, NULL, NULL);
return 0;
}
void free_libnotify(void) {
void (*notify_uninit)(void);
if (notify) {
notify_uninit = dlsym(libnotify, "notify_uninit");
if (!dlerror())
notify_uninit();
notify = NULL;
}
if (libnotify) {
dlclose(libnotify);
dlerror();
libnotify = NULL;
}
}
void set_timeout(int timeout) {
notify_notification_set_timeout(notify, timeout);
}
void show_notify(const char *summary, char *body) {
notify_notification_update(notify, summary, body, NULL);
notify_notification_show(notify, NULL);
}
#endif /* NO_NOTIFY */
================================================
FILE: src/dlfunc.h
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* 文件名称：dlfunc.h
* 摘 要：动态载入库函数
*/
#ifndef HUSTMOON_DLFUNC_H
#define HUSTMOON_DLFUNC_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <sys/time.h>
#define PCAP_ERRBUF_SIZE 256
#define PCAP_IF_LOOPBACK 0x00000001
typedef unsigned int bpf_u_int32;
typedef void pcap_t;
typedef struct pcap_if {
struct pcap_if *next;
char *name;
char *description;
void *addresses;
bpf_u_int32 flags;
}pcap_if_t;
struct bpf_program {
unsigned int bf_len;
void *bf_insns;
};
struct pcap_pkthdr {
struct timeval ts;
bpf_u_int32 caplen;
bpf_u_int32 len;
};
typedef void (*pcap_handler)(unsigned char *, const struct pcap_pkthdr *, const unsigned char *);
#ifdef NO_DYLOAD
int pcap_findalldevs(pcap_if_t **, char *);
void pcap_freealldevs(pcap_if_t *);
pcap_t *pcap_open_live(const char *, int, int, int, char *);
int pcap_compile(pcap_t *, struct bpf_program *, const char *, int, bpf_u_int32);
int pcap_setfilter(pcap_t *, struct bpf_program *);
char *pcap_geterr(pcap_t *);
void pcap_freecode(struct bpf_program *);
int pcap_loop(pcap_t *, int, pcap_handler, unsigned char *);
void pcap_close(pcap_t *);
void pcap_breakloop(pcap_t *);
int pcap_sendpacket(pcap_t *, const unsigned char *, int);
#else
extern int (*pcap_findalldevs)(pcap_if_t **, char *);
extern void (*pcap_freealldevs)(pcap_if_t *);
extern pcap_t *(*pcap_open_live)(const char *, int, int, int, char *);
extern int (*pcap_compile)(pcap_t *, struct bpf_program *, const char *, int, bpf_u_int32);
extern int (*pcap_setfilter)(pcap_t *, struct bpf_program *);
extern char *(*pcap_geterr)(pcap_t *);
extern void (*pcap_freecode)(struct bpf_program *);
extern int (*pcap_loop)(pcap_t *, int, pcap_handler, unsigned char *);
extern void (*pcap_close)(pcap_t *);
extern void (*pcap_breakloop)(pcap_t *);
extern int (*pcap_sendpacket)(pcap_t *, const unsigned char *, int);
int load_libpcap(void); /* 载入libpcap.so */
void free_libpcap(void); /* 释放libpcap.so */
#endif /* NO_DYLOAD */
#ifndef NO_NOTIFY
int load_libnotify(void); /* 载入libnotify.so */
void free_libnotify(void); /* 释放libnotify.so */
void set_timeout(int timeout); /* 设置超时间隔 */
void show_notify(const char *summary, char *body); /* 显示通知:概要、正文 */
#endif /* NO_NOTIFY */
#endif /* HUSTMOON_DLFUNC_H */
================================================
FILE: src/md5.c
================================================
/* MD5.c - an implementation of md5 algorithm */
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#include "md5.h"
#include <string.h>
/* Constants for MD5Transform routine. */
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform(UINT4 [4], UCHAR [64]);
static void Encode(UCHAR *, UINT4 *, UINT4);
static void Decode(UINT4 *, UCHAR *, UINT4);
static UCHAR PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
/* F, G, H and I are basic MD5 functions.
*/
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
/* MD5 initialization. Begins an MD5 operation, writing a new context.
*/
void MD5Init (MD5_CTX * context)
{
context->count[0] = context->count[1] = 0;
/* Load magic initialization constants.
*/
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}
/* MD5 block update operation. Continues an MD5 message-digest
operation, processing another message block, and updating the
context.
*/
void MD5Update (MD5_CTX *context, UCHAR *input, UINT4 inputLen)
{
UINT4 i, index, partLen;
/* Compute number of bytes mod 64 */
index = (UINT4)((context->count[0] >> 3) & 0x3F);
/* Update number of bits */
if ((context->count[0] += ((UINT4)inputLen << 3))
< ((UINT4)inputLen << 3))
context->count[1]++;
context->count[1] += ((UINT4)inputLen >> 29);
partLen = 64 - index;
/* Transform as many times as possible.
*/
if (inputLen >= partLen) {
memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
MD5Transform (context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, &input[i]);
index = 0;
}
else
i = 0;
/* Buffer remaining input */
memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],inputLen-i);
}
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
the message digest and zeroizing the context.
*/
void MD5Final (UCHAR digest[16], MD5_CTX *context)
{
UCHAR bits[8];
UINT4 index, padLen;
/* Save number of bits */
Encode (bits, context->count, 8);
/* Pad out to 56 mod 64.
*/
index = (UINT4)((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MD5Update (context, PADDING, padLen);
/* Append length (before padding) */
MD5Update (context, bits, 8);
/* Store state in digest */
Encode (digest, context->state, 16);
/* Zeroize sensitive information.
*/
memset ((POINTER)context, 0, sizeof (*context));
}
/* MD5 basic transformation. Transforms state based on block.
*/
static void MD5Transform (UINT4 state[4],UCHAR block[64])
{
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode (x, block, 64);
/* Round 1 */
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
/* Zeroize sensitive information.
*/
memset ((POINTER)x, 0, sizeof (x));
}
/* Encodes input (UINT4) into output (UCHAR). Assumes len is
a multiple of 4.
*/
static void Encode (UCHAR *output, UINT4 *input, UINT4 len)
{
UINT4 i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
output[j] = (UCHAR)(input[i] & 0xff);
output[j+1] = (UCHAR)((input[i] >> 8) & 0xff);
output[j+2] = (UCHAR)((input[i] >> 16) & 0xff);
output[j+3] = (UCHAR)((input[i] >> 24) & 0xff);
}
}
/* Decodes input (UCHAR) into output (UINT4). Assumes len is
a multiple of 4.
*/
static void Decode (UINT4 *output, UCHAR *input, UINT4 len)
{
UINT4 i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
(((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
}
/*Compute the md5sum (return static-local-variable),whose length is 16 bytes.*/
UCHAR* ComputeHash(UCHAR* src, UINT4 len)
{
MD5_CTX context;
static UCHAR digest[16];
MD5Init(&context);
MD5Update(&context, src, len);
MD5Final(digest, &context);
return digest;
}
================================================
FILE: src/md5.h
================================================
/* MD5.H - header file for MD5.C */
/*
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.*/
#ifndef MD5_H
#define MD5_H
#include "types.h"
/* MD5 context. */
typedef struct
{
UINT4 state[4]; /* state (ABCD) */
UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */
UCHAR buffer[64]; /* input buffer */
} MD5_CTX;
void MD5Init(MD5_CTX * context);
void MD5Update(MD5_CTX *context, UCHAR *input, UINT4 inputLen);
void MD5Final(UCHAR digest[16], MD5_CTX *context);
UCHAR* ComputeHash(UCHAR *src, UINT4 len);
#endif /* MD5_H */
================================================
FILE: src/mentohust.c
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：mentohust.c
* 摘 要：MentoHUST主函数
* 作 者：HustMoon@BYHH
* 邮 箱：www.ehust@gmail.com
*/
#include "strnormalize.h"
#include "myconfig.h"
#include "mystate.h"
#include "myfunc.h"
#include "dlfunc.h"
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <unistd.h>
extern pcap_t *hPcap;
extern volatile int state;
extern u_char *fillBuf;
extern const u_char *capBuf;
extern unsigned startMode, dhcpMode, maxFail;
extern u_char destMAC[];
extern int lockfd;
#ifndef NO_NOTIFY
extern int showNotify;
#endif
#ifndef NO_ARP
extern u_int32_t rip, gateway;
extern u_char gateMAC[];
#endif
static void exit_handle(void); /* 退出回调 */
static void sig_handle(int sig); /* 信号回调 */
static void pcap_handle(u_char *user, const struct pcap_pkthdr *h, const u_char *buf); /* pcap_loop回调 */
static void showRuijieMsg(const u_char *buf, unsigned bufLen); /* 显示锐捷服务器提示信息 */
static void showCernetMsg(const u_char *buf); /* 显示赛尔服务器提示信息 */
int main(int argc, char **argv)
{
atexit(exit_handle);
initConfig(argc, argv);
signal(SIGALRM, sig_handle); /* 定时器 */
signal(SIGHUP, sig_handle); /* 注销时 */
signal(SIGINT, sig_handle); /* Ctrl+C */
signal(SIGQUIT, sig_handle); /* Ctrl+\ */
signal(SIGTSTP, sig_handle); /* Ctrl+Z */
signal(SIGTERM, sig_handle); /* 被结束时 */
if (dhcpMode == 3) /* 认证前DHCP */
switchState(ID_DHCP);
else
switchState(ID_START); /* 开始认证 */
if (-1 == pcap_loop(hPcap, -1, pcap_handle, NULL)) { /* 开始捕获数据包 */
printf("!! 捕获数据包失败，请检查网络连接！\n");
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 错误提示", "捕获数据包失败，请检查网络连接！");
#endif
}
exit(EXIT_FAILURE);
}
static void exit_handle(void)
{
if (state != ID_DISCONNECT)
switchState(ID_DISCONNECT);
if (hPcap != NULL)
pcap_close(hPcap);
if (fillBuf != NULL)
free(fillBuf);
if (lockfd > -1)
close(lockfd);
#ifndef NO_NOTIFY
free_libnotify();
#endif
#ifndef NO_DYLOAD
free_libpcap();
#endif
printf(">> 认证已退出。\n");
}
static void sig_handle(int sig)
{
if (sig == SIGALRM) /* 定时器 */
{
if (-1 == switchState(state))
{
pcap_breakloop(hPcap);
printf("!! 发送数据包失败, 请检查网络连接！\n");
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 错误提示", "发送数据包失败, 请检查网络连接！");
#endif
exit(EXIT_FAILURE);
}
}
else /* 退出 */
{
pcap_breakloop(hPcap);
exit(EXIT_SUCCESS);
}
}
static void pcap_handle(u_char *user, const struct pcap_pkthdr *h, const u_char *buf)
{
static unsigned failCount = 0;
#ifndef NO_ARP
if (buf[0x0c]==0x88 && buf[0x0d]==0x8e) {
#endif
if (memcmp(destMAC, buf+6, 6)!=0 && startMode>2) /* 服务器MAC地址不符 */
return;
capBuf = buf;
if (buf[0x0F]==0x00 && buf[0x12]==0x01 && buf[0x16]==0x01) { /* 验证用户名 */
if (startMode < 3) {
memcpy(destMAC, buf+6, 6);
printf("** 认证MAC:\t%s\n", formatHex(destMAC, 6));
startMode += 3; /* 标记为已获取 */
}
if (startMode==3 && memcmp(buf+0x17, "User name", 9)==0) /* 塞尔 */
startMode = 5;
switchState(ID_IDENTITY);
}
else if (buf[0x0F]==0x00 && buf[0x12]==0x01 && buf[0x16]==0x04) /* 验证密码 */
switchState(ID_CHALLENGE);
else if (buf[0x0F]==0x00 && buf[0x12]==0x03) { /* 认证成功 */
printf(">> 认证成功!\n");
failCount = 0;
if (!(startMode%3 == 2)) {
getEchoKey(buf);
showRuijieMsg(buf, h->caplen);
}
if (dhcpMode==1 || dhcpMode==2) /* 二次认证第一次或者认证后 */
switchState(ID_DHCP);
else if (startMode%3 == 2)
switchState(ID_WAITECHO);
else
switchState(ID_ECHO);
}
else if (buf[0x0F]==0x00 && buf[0x12]==0x01 && buf[0x16]==0x02) /* 显示赛尔提示信息 */
showCernetMsg(buf);
else if (buf[0x0F] == 0x05) /* (赛尔)响应在线 */
switchState(ID_ECHO);
else if (buf[0x0F]==0x00 && buf[0x12]==0x04) { /* 认证失败或被踢下线 */
if (state==ID_WAITECHO || state==ID_ECHO) {
printf(">> 认证掉线，开始重连!\n");
switchState(ID_START);
}
else if (buf[0x1b]!=0 || startMode%3==2) {
printf(">> 认证失败!\n");
if (startMode%3 != 2)
showRuijieMsg(buf, h->caplen);
if (maxFail && ++failCount>=maxFail) {
printf(">> 连续认证失败%u次，退出认证。\n", maxFail);
exit(EXIT_SUCCESS);
}
restart();
}
else
switchState(ID_START);
}
#ifndef NO_ARP
} else if (gateMAC[0]!=0xFE && buf[0x0c]==0x08 && buf[0x0d]==0x06) {
if (*(u_int32_t *)(buf+0x1c) == gateway) {
char str[50];
if (gateMAC[0] == 0xFF) {
memcpy(gateMAC, buf+0x16, 6);
printf("** 网关MAC:\t%s\n", formatHex(gateMAC, 6));
fflush(stdout);
sprintf(str, "arp -s %s %s", formatIP(gateway), formatHex(gateMAC, 6));
system(str);
} else if (buf[0x15]==0x02 && *(u_int32_t *)(buf+0x26)==rip
&& memcmp(gateMAC, buf+0x16, 6)!=0) {
printf("** ARP欺骗:\t%s\n", formatHex(buf+0x16, 6));
fflush(stdout);
#ifndef NO_NOTIFY
if (showNotify) {
sprintf(str, "欺骗源: %s", formatHex(buf+0x16, 6));
show_notify("MentoHUST - ARP提示", str);
}
#endif
}
}
}
#endif
}
#ifndef MAC_OS
static char *gbk2utf(char *gbksrc, size_t gbklen) /* GBK转UTF－8 */
#else
static char *gbk2utf(const char *gbksrc, size_t gbklen) /* GBK转UTF－8 */
#endif
{
/* GBK一汉字俩字节，UTF-8一汉字3字节，二者ASCII字符均一字节
所以这样申请是足够的了，要记得释放 */
str_normalize_init();
size_t utf8len = gbklen * 3 + 1;
char *utf8dst = (char *)malloc(utf8len);
memset(utf8dst,0,utf8len);
char *temp=(char *)malloc(gbklen+5);
memset(temp, 0, gbklen+5);
memcpy(temp,gbksrc,gbklen);
gbksrc = temp;
gbklen = strlen(gbksrc);
gbk_to_utf8(gbksrc, gbklen, &utf8dst, &utf8len);
free(temp);
return utf8dst;
}
static void showRuijieMsg(const u_char *buf, unsigned bufLen)
{
char *serverMsg;
int length = buf[0x1b];
if (length > 0)
{
for (serverMsg=(char *)(buf+0x1c); *serverMsg=='\r'||*serverMsg=='\n'; serverMsg++,length--); /* 跳过开头的换行符 */
if (strlen(serverMsg) < length)
length = strlen(serverMsg);
if (length>0 && (serverMsg=gbk2utf(serverMsg, length))!=NULL)
{
printf("$$ 系统提示:\t%s\n", serverMsg);
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 系统提示", serverMsg);
#endif
free(serverMsg);
}
}
if ((length=0x1c+buf[0x1b]+0x69+39) < bufLen)
{
serverMsg=(char *)(buf+length);
if (buf[length-1]-2 > bufLen-length)
length = bufLen - length;
else
length = buf[length-1]-2;
for (; *serverMsg=='\r'||*serverMsg=='\n'; serverMsg++,length--);
if (length>0 && (serverMsg=gbk2utf(serverMsg, length))!=NULL)
{
printf("$$ 计费提示:\t%s\n", serverMsg);
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 计费提示", serverMsg);
#endif
free(serverMsg);
}
}
fflush(stdout);
}
static void showCernetMsg(const u_char *buf)
{
char *serverMsg = (char *)(buf+0x17);
int length = ntohs(*(u_int16_t *)(buf+0x14)) - 5;
if (strlen(serverMsg) < length)
length = strlen(serverMsg);
if (length>0 && (serverMsg=gbk2utf(serverMsg, length))!=NULL)
{
printf("$$ 系统提示:\t%s\n", serverMsg);
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 系统提示", serverMsg);
#endif
free(serverMsg);
}
fflush(stdout);
}
================================================
FILE: src/mycheck.c
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：mycheck.c
* 摘 要：客户端校验算法
* 作 者：kkHAIKE & HustMoon
*/
#include "mycheck.h"
#include "md5.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static BYTE *bin_8021x = NULL;
static DWORD size_8021x;
static BYTE hex[][17]={"0123456789ABCDEF", "0123456789abcdef"};
#ifdef WORDS_BIGENDIAN
WORD ltobs(WORD x) {
return ((x & 0xff) << 8) | ((x & 0xff00) >> 8);
}
DWORD ltobl(DWORD x) {
return ((x & 0xff) << 24) |\
((x & 0xff00) << 8) |\
((x & 0xff0000) >> 8) |\
((x & 0xff000000) >> 24);
}
#endif
void hex_to_str(const BYTE *a, char *b, int hexsize, int upper) {
BYTE *q = (BYTE *)b;
int i;
for (i=0; i<hexsize; i++) {
*q = hex[upper][a[i]>>4]; q++;
*q = hex[upper][a[i]&0xf]; q++;
}
*q = 0;
}
BYTE *ReadCode(const char *file, DWORD *size) {
BYTE *data = NULL;
int i;
FILE *fp;
PPE_HEADER_MAP hpe;
if ((fp=fopen(file, "rb")) == NULL)
goto fileError;
data = (BYTE *)malloc(0x1000);
if (fread(data, 0x1000, 1, fp) < 1)
goto fileError;
hpe = (PPE_HEADER_MAP)(data + LTOBL(((PIMAGE_DOS_HEADER)data)->e_lfanew));
for (i=0; i<LTOBS(hpe->_head.NumberOfSections); i++) {
if (LTOBL(hpe->section_header[i].Characteristics) & (IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_CNT_CODE)) {
fseek(fp, LTOBL(hpe->section_header[i].PointerToRawData), SEEK_SET);
*size = LTOBL(hpe->section_header[i].SizeOfRawData);
free(data);
data = (BYTE *)malloc(*size);
if (fread(data, *size, 1, fp) < 1)
goto fileError;
fclose(fp);
return data;
}
}
fileError:
if (fp != NULL)
fclose(fp);
if (data != NULL)
free(data);
return NULL;
}
BYTE *ReadCode2(const char *dataFile, DWORD *size) {
BYTE Buf[16], *buf=Buf;
FILE *fp = NULL;
if ((fp=fopen(dataFile, "rb")) == NULL
|| fread(buf, 16, 1, fp ) < 1)
goto fileError;
*size = LTOBL(*(UINT4 *)buf ^ *(UINT4 *)(buf + 4));
if ((int)*size <= 0)
goto fileError;
buf = (BYTE *)malloc(*size+0x100);
if (fread(buf, *size, 1, fp) < 1) {
free(buf);
goto fileError;
}
fclose(fp);
return buf;
fileError:
if (fp != NULL)
fclose(fp);
return NULL;
}
void check_free() {
if (bin_8021x) {
free(bin_8021x);
bin_8021x = NULL;
}
}
int check_init(const char *dataFile) {
char name[0x100];
char *p;
check_free();
strcpy(name, dataFile);
if ((p=strrchr(name, '/')+1) == (void *)1)
p = name;
strcpy(p, "8021x.exe");
if ((bin_8021x=ReadCode(name, &size_8021x)) == NULL
&& (bin_8021x=ReadCode2(dataFile, &size_8021x)) == NULL)
return -1;
return 0;
}
void V2_check(const BYTE *seed, char *final_str) {
int i, size = size_8021x / 8;
BYTE table[144], *md5Dig, *b8021x = (BYTE *)malloc(size+16);
memcpy(b8021x, seed, 16);
for (i=0; i<8; i++) {
memcpy(b8021x+16, bin_8021x+size*i, size);
md5Dig = ComputeHash(b8021x, size+16);
table[18*i] = seed[2*i];
memcpy(table+18*i+1, md5Dig, 16);
table[18*i+17] = seed[2*i+1];
}
free(b8021x);
md5Dig = ComputeHash(table, 144);
hex_to_str(md5Dig, final_str, 16, 1);
}
DWORD getVer(const char *file) {
FILE *fp;
BYTE *data = NULL;
int i, j;
DWORD size, VirtualAddress;
PPE_HEADER_MAP hpe;
PIMAGE_RESOURCE_DIRECTORY prd;
PIMAGE_RESOURCE_DATA_ENTRY prde;
PVS_VERSIONINFO pvs;
if ((fp=fopen(file, "rb")) == NULL)
goto fileError;
data = (BYTE *)malloc(0x1000);
if (fread(data, 0x1000, 1, fp) < 1)
goto fileError;
hpe = (PPE_HEADER_MAP)(data + LTOBL(((PIMAGE_DOS_HEADER)data)->e_lfanew));
for (i=LTOBS(hpe->_head.NumberOfSections)-1; i>=0; i--) {
if (strcmp(hpe->section_header[i].Name, ".rsrc") == 0) {
fseek(fp, LTOBL(hpe->section_header[i].PointerToRawData), SEEK_SET);
size = LTOBL(hpe->section_header[i].SizeOfRawData);
VirtualAddress = LTOBL(hpe->section_header[i].VirtualAddress);
free(data);
data = (BYTE *)malloc(size);
if (fread(data, size, 1, fp) < 1)
goto fileError;
prd = (PIMAGE_RESOURCE_DIRECTORY)data;
for (j=0; j<LTOBS(prd->NumberOfIdEntries); j++) {
prd->DirectoryEntries[j].Name = LTOBL(prd->DirectoryEntries[j].Name);
if (prd->DirectoryEntries[j].Id==16 && prd->DirectoryEntries[j].NameIsString==0) {
prd->DirectoryEntries[j].OffsetToData = LTOBL(prd->DirectoryEntries[j].OffsetToData);
prd = (PIMAGE_RESOURCE_DIRECTORY)(data+prd->DirectoryEntries[j].OffsetToDirectory);
prd->DirectoryEntries[0].OffsetToData = LTOBL(prd->DirectoryEntries[0].OffsetToData);
prd = (PIMAGE_RESOURCE_DIRECTORY)(data+prd->DirectoryEntries[0].OffsetToDirectory);
prde = (PIMAGE_RESOURCE_DATA_ENTRY)(data+LTOBL(prd->DirectoryEntries[0].OffsetToData));
pvs = (PVS_VERSIONINFO)(data+LTOBL(prde->OffsetToData)-VirtualAddress);
size = pvs->Value.dwFileVersionMS;
fclose(fp);
free(data);
return size;
}
}
goto fileError;
}
}
fileError:
if (fp != NULL)
fclose(fp);
if (data != NULL)
free(data);
return -1;
}
================================================
FILE: src/mycheck.h
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：mycheck.h
* 摘 要：客户端校验算法
* 作 者：kkHAIKE
*/
#ifndef MYCHECK_H
#define MYCHECK_H
#include "types.h"
typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header
WORD e_magic; // Magic number
WORD e_cblp; // Bytes on last page of file
WORD e_cp; // Pages in file
WORD e_crlc; // Relocations
WORD e_cparhdr; // Size of header in paragraphs
WORD e_minalloc; // Minimum extra paragraphs needed
WORD e_maxalloc; // Maximum extra paragraphs needed
WORD e_ss; // Initial (relative) SS value
WORD e_sp; // Initial SP value
WORD e_csum; // Checksum
WORD e_ip; // Initial IP value
WORD e_cs; // Initial (relative) CS value
WORD e_lfarlc; // File address of relocation table
WORD e_ovno; // Overlay number
WORD e_res[4]; // Reserved words
WORD e_oemid; // OEM identifier (for e_oeminfo)
WORD e_oeminfo; // OEM information; e_oemid specific
WORD e_res2[10]; // Reserved words
LONG e_lfanew; // File address of new exe header
} IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
typedef struct _IMAGE_FILE_HEADER {
WORD Machine;
WORD NumberOfSections;
DWORD TimeDateStamp;
DWORD PointerToSymbolTable;
DWORD NumberOfSymbols;
WORD SizeOfOptionalHeader;
WORD Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16
typedef struct _IMAGE_OPTIONAL_HEADER {
//
// Standard fields.
//
WORD Magic;
BYTE MajorLinkerVersion;
BYTE MinorLinkerVersion;
DWORD SizeOfCode;
DWORD SizeOfInitializedData;
DWORD SizeOfUninitializedData;
DWORD AddressOfEntryPoint;
DWORD BaseOfCode;
DWORD BaseOfData;
//
// NT additional fields.
//
DWORD ImageBase;
DWORD SectionAlignment;
DWORD FileAlignment;
WORD MajorOperatingSystemVersion;
WORD MinorOperatingSystemVersion;
WORD MajorImageVersion;
WORD MinorImageVersion;
WORD MajorSubsystemVersion;
WORD MinorSubsystemVersion;
DWORD Win32VersionValue;
DWORD SizeOfImage;
DWORD SizeOfHeaders;
DWORD CheckSum;
WORD Subsystem;
WORD DllCharacteristics;
DWORD SizeOfStackReserve;
DWORD SizeOfStackCommit;
DWORD SizeOfHeapReserve;
DWORD SizeOfHeapCommit;
DWORD LoaderFlags;
DWORD NumberOfRvaAndSizes;
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;
#define IMAGE_SIZEOF_SHORT_NAME 8
typedef struct _IMAGE_SECTION_HEADER {
char Name[IMAGE_SIZEOF_SHORT_NAME];
union {
DWORD PhysicalAddress;
DWORD VirtualSize;
} Misc;
DWORD VirtualAddress;
DWORD SizeOfRawData;
DWORD PointerToRawData;
DWORD PointerToRelocations;
DWORD PointerToLinenumbers;
WORD NumberOfRelocations;
WORD NumberOfLinenumbers;
DWORD Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
typedef struct _PE_HEADER_MAP
{
DWORD signature;
IMAGE_FILE_HEADER _head;
IMAGE_OPTIONAL_HEADER opt_head;
IMAGE_SECTION_HEADER section_header[8];
}PE_HEADER_MAP,*PPE_HEADER_MAP;
typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
#ifdef WORDS_BIGENDIAN
union {
struct {
DWORD NameIsString:1;
DWORD NameOffset:31;
};
DWORD Name;
struct {
WORD Id_unuse;
WORD Id;
};
};
union {
DWORD OffsetToData;
struct {
DWORD DataIsDirectory:1;
DWORD OffsetToDirectory:31;
};
};
#else
union {
struct {
DWORD NameOffset:31;
DWORD NameIsString:1;
};
DWORD Name;
WORD Id;
};
union {
DWORD OffsetToData;
struct {
DWORD OffsetToDirectory:31;
DWORD DataIsDirectory:1;
};
};
#endif
} IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;
typedef struct _IMAGE_RESOURCE_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp;
WORD MajorVersion;
WORD MinorVersion;
WORD NumberOfNamedEntries;
WORD NumberOfIdEntries;
IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[];
} IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;
typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
DWORD OffsetToData;
DWORD Size;
DWORD CodePage;
DWORD Reserved;
} IMAGE_RESOURCE_DATA_ENTRY, *PIMAGE_RESOURCE_DATA_ENTRY;
typedef struct tagVS_FIXEDFILEINFO {
DWORD dwSignature; /* e.g. 0xfeef04bd */
DWORD dwStrucVersion; /* e.g. 0x00000042 = "0.42" */
DWORD dwFileVersionMS; /* e.g. 0x00030075 = "3.75" */
DWORD dwFileVersionLS; /* e.g. 0x00000031 = "0.31" */
DWORD dwProductVersionMS; /* e.g. 0x00030010 = "3.10" */
DWORD dwProductVersionLS; /* e.g. 0x00000031 = "0.31" */
DWORD dwFileFlagsMask; /* = 0x3F for version "0.42" */
DWORD dwFileFlags; /* e.g. VFF_DEBUG | VFF_PRERELEASE */
DWORD dwFileOS; /* e.g. VOS_DOS_WINDOWS16 */
DWORD dwFileType; /* e.g. VFT_DRIVER */
DWORD dwFileSubtype; /* e.g. VFT2_DRV_KEYBOARD */
DWORD dwFileDateMS; /* e.g. 0 */
DWORD dwFileDateLS; /* e.g. 0 */
} VS_FIXEDFILEINFO;
typedef struct _VS_VERSIONINFO {
WORD wLength;
WORD wValueLength;
WORD wType;
WORD szKey[16];
WORD Padding1[1];
VS_FIXEDFILEINFO Value;
} VS_VERSIONINFO, *PVS_VERSIONINFO;
#define IMAGE_SCN_CNT_CODE 0x00000020 // Section contains code
#define IMAGE_SCN_MEM_EXECUTE 0x20000000 // Section is executable
#ifdef WORDS_BIGENDIAN
#define LTOBS(x) ltobs(x)
#define LTOBL(x) ltobl(x)
WORD ltobs(WORD x);
DWORD ltobl(DWORD x);
#else
#define LTOBS(x) (x)
#define LTOBL(x) (x)
#endif
int check_init(const char *dataFile);
void V2_check(const BYTE *seed, char *final_str);
void check_free();
DWORD getVer(const char *file);
#endif
================================================
FILE: src/myconfig.c
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：myconfig.c
* 摘 要：初始化认证参数
* 作 者：HustMoon@BYHH
* 邮 箱：www.ehust@gmail.com
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#else
static const char *VERSION = "0.3.1";
static const char *PACKAGE_BUGREPORT = "http://code.google.com/p/mentohust/issues/list";
#endif
#include "myconfig.h"
#include "myini.h"
#include "myfunc.h"
#include "dlfunc.h"
#include <string.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <sys/stat.h>
#define ACCOUNT_SIZE 65 /* 用户名密码长度*/
#define NIC_SIZE 16 /* 网卡名最大长度 */
#define MAX_PATH 255 /* FILENAME_MAX */
#define D_TIMEOUT 8 /* 默认超时间隔 */
#define D_ECHOINTERVAL 30 /* 默认心跳间隔 */
#define D_RESTARTWAIT 15 /* 默认重连间隔 */
#define D_STARTMODE 0 /* 默认组播模式 */
#define D_DHCPMODE 0 /* 默认DHCP模式 */
#define D_DAEMONMODE 0 /* 默认daemon模式 */
#define D_MAXFAIL 0 /* 默认允许失败次数 */
static const char *D_DHCPSCRIPT = "dhclient"; /* 默认DHCP脚本 */
static const char *CFG_FILE = "/etc/mentohust.conf"; /* 配置文件 */
static const char *LOG_FILE = "/tmp/mentohust.log"; /* 日志文件 */
static const char *LOCK_FILE = "/tmp/mentohust.pid"; /* 锁文件 */
#define LOCKMODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) /* 创建掩码 */
#ifndef NO_NOTIFY
#define D_SHOWNOTIFY 5 /* 默认Show Notify模式 */
int showNotify = D_SHOWNOTIFY; /* 显示通知 */
#endif
extern int bufType; /*0内置xrgsu 1内置Win 2仅文件 3文件+校验*/
extern u_char version[]; /* 版本 */
char userName[ACCOUNT_SIZE] = ""; /* 用户名 */
char password[ACCOUNT_SIZE] = ""; /* 密码 */
char nic[NIC_SIZE] = ""; /* 网卡名 */
char dataFile[MAX_PATH] = ""; /* 数据文件 */
char dhcpScript[MAX_PATH] = ""; /* DHCP脚本 */
u_int32_t ip = 0; /* 本机IP */
u_int32_t mask = 0; /* 子网掩码 */
u_int32_t gateway = 0; /* 网关 */
u_int32_t dns = 0; /* DNS */
u_int32_t pingHost = 0; /* ping */
u_char localMAC[6]; /* 本机MAC */
u_char destMAC[6]; /* 服务器MAC */
unsigned timeout = D_TIMEOUT; /* 超时间隔 */
unsigned echoInterval = D_ECHOINTERVAL; /* 心跳间隔 */
unsigned restartWait = D_RESTARTWAIT; /* 失败等待 */
unsigned startMode = D_STARTMODE; /* 组播模式 */
unsigned dhcpMode = D_DHCPMODE; /* DHCP模式 */
unsigned maxFail = D_MAXFAIL; /* 允许失败次数 */
pcap_t *hPcap = NULL; /* Pcap句柄 */
int lockfd = -1; /* 锁文件描述符 */
static int readFile(int *daemonMode); /* 读取配置文件来初始化 */
static void readArg(char argc, char **argv, int *saveFlag, int *exitFlag, int *daemonMode); /* 读取命令行参数来初始化 */
static void showHelp(const char *fileName); /* 显示帮助信息 */
static int getAdapter(); /* 查找网卡名 */
static void printConfig(); /* 显示初始化后的认证参数 */
static int openPcap(); /* 初始化pcap、设置过滤器 */
static void saveConfig(int daemonMode); /* 保存参数 */
static void checkRunning(int exitFlag, int daemonMode); /* 检测是否已运行 */
#ifndef NO_ENCODE_PASS
static const unsigned char base64Tab[] = {"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"};
static const char xorRuijie[] = {"~!:?$*<(qw2e5o7i8x12c6m67s98w43d2l45we82q3iuu1z4xle23rt4oxclle34e54u6r8m"};
static int encodePass(char *dst, const char *osrc) {
unsigned char in[3], buf[70];
unsigned char *src = buf;
int sz = strlen(osrc);
int i, len;
if (sizeof(xorRuijie) < sz)
return -1;
for(i=0; i<sz; i++)
src[i] = osrc[i] ^ xorRuijie[i];
while (sz > 0) {
for (len=0, i=0; i<3; i++, sz--) {
if (sz > 0) {
len++;
in[i] = src[i];
} else in[i] = 0;
}
src += 3;
if (len) {
dst[0] = base64Tab[ in[0] >> 2 ];
dst[1] = base64Tab[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ];
dst[2] = len > 1 ? base64Tab[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '=';
dst[3] = len > 2 ? base64Tab[ in[2] & 0x3f ] : '=';
dst += 4;
}
}
*dst = '\0';
return 0;
}
static int decodePass(char *dst, const char *src) {
unsigned esi = 0, idx = 0;
int i=0, j=0, equal=0;
for(; src[i]!='\0'; i++) {
if (src[i] == '=') {
if (++equal > 2)
return -1;
} else {
for(idx=0; base64Tab[idx]!='\0'; idx++) {
if(base64Tab[idx] == src[i])
break;
}
if (idx == 64)
return -1;
esi += idx;
}
if(i%4 == 3) {
dst[j++] = (char)(esi>>16);
if(equal < 2)
dst[j++] = (char)(esi>>8);
if(equal < 1)
dst[j++] = (char)esi;
esi = 0;
equal = 0;
}
esi <<= 6;
}
if (i%4!=0 || sizeof(xorRuijie)<j)
return -1;
for(i=0; i<j; i++)
dst[i] ^= xorRuijie[i];
dst[j] = '\0';
return 0;
}
#endif
void initConfig(int argc, char **argv)
{
int saveFlag = 0; /* 是否需要保存参数 */
int exitFlag = 0; /* 0Nothing 1退出 2重启 */
int daemonMode = D_DAEMONMODE; /* 是否后台运行 */
printf("\n欢迎使用MentoHUST\t版本: %s\n"
"Copyright (C) 2009-2010 HustMoon Studio\n"
"人到华中大，有甜亦有辣。明德厚学地，求是创新家。\n"
"Bug report to %s\n\n", VERSION, PACKAGE_BUGREPORT);
saveFlag = (readFile(&daemonMode)==0 ? 0 : 1);
readArg(argc, argv, &saveFlag, &exitFlag, &daemonMode);
#ifndef NO_NOTIFY
if (showNotify) {
seteuid(getuid());
if (load_libnotify() == -1)
showNotify = 0;
else
set_timeout(1000 * showNotify);
seteuid(0);
}
#endif
#ifndef NO_DYLOAD
if (load_libpcap() == -1) {
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 错误提示", "载入libpcap失败, 请检查该库文件！");
#endif
exit(EXIT_FAILURE);
}
#endif
if (nic[0] == '\0')
{
saveFlag = 1;
if (getAdapter() == -1) { /* 找不到（第一块）网卡？ */
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 错误提示", "找不到网卡！");
#endif
exit(EXIT_FAILURE);
}
}
if (userName[0]=='\0' || password[0]=='\0') /* 未写用户名密码？ */
{
saveFlag = 1;
printf("?? 请输入用户名: ");
scanf("%s", userName);
printf("?? 请输入密码: ");
scanf("%s", password);
printf("?? 请选择组播地址(0标准 1锐捷私有 2赛尔): ");
scanf("%u", &startMode);
startMode %= 3;
printf("?? 请选择DHCP方式(0不使用 1二次认证 2认证后 3认证前): ");
scanf("%u", &dhcpMode);
dhcpMode %= 4;
}
checkRunning(exitFlag, daemonMode);
if (startMode%3==2 && gateway==0) /* 赛尔且未填写网关地址 */
{
gateway = ip; /* 据说赛尔的网关是ip前三字节，后一字节是2 */
((u_char *)&gateway)[3] = 0x02;
}
if (dhcpScript[0] == '\0') /* 未填写DHCP脚本？ */
strcpy(dhcpScript, D_DHCPSCRIPT);
newBuffer();
printConfig();
if (fillHeader()==-1 || openPcap()==-1) { /* 获取IP、MAC，打开网卡 */
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 错误提示", "获取MAC地址或打开网卡失败！");
#endif
exit(EXIT_FAILURE);
}
if (saveFlag)
saveConfig(daemonMode);
}
static int readFile(int *daemonMode)
{
char tmp[16];
char *buf = loadFile(CFG_FILE);
if (buf == NULL)
return -1;
getString(buf, "MentoHUST", "Username", "", userName, sizeof(userName));
getString(buf, "MentoHUST", "Password", "", password, sizeof(password));
#ifndef NO_ENCODE_PASS
char pass[ACCOUNT_SIZE*4/3];
if (password[0] == '\0') {
getString(buf, "MentoHUST", "EncodePass", "", pass, sizeof(pass));
decodePass(password, pass);
} else {
encodePass(pass, password);
setString(&buf, "MentoHUST", "Password", NULL);
setString(&buf, "MentoHUST", "EncodePass", pass);
saveFile(buf, CFG_FILE);
}
#endif
getString(buf, "MentoHUST", "Nic", "", nic, sizeof(nic));
getString(buf, "MentoHUST", "Datafile", "", dataFile, sizeof(dataFile));
getString(buf, "MentoHUST", "DhcpScript", "", dhcpScript, sizeof(dhcpScript));
getString(buf, "MentoHUST", "Version", "", tmp, sizeof(tmp));
if (strlen(tmp) >= 3) {
unsigned ver[2];
if (sscanf(tmp, "%u.%u", ver, ver+1)!=EOF && ver[0]!=0) {
version[0] = ver[0];
version[1] = ver[1];
bufType = 1;
}
}
getString(buf, "MentoHUST", "IP", "255.255.255.255", tmp, sizeof(tmp));
ip = inet_addr(tmp);
getString(buf, "MentoHUST", "Mask", "255.255.255.255", tmp, sizeof(tmp));
mask = inet_addr(tmp);
getString(buf, "MentoHUST", "Gateway", "0.0.0.0", tmp, sizeof(tmp));
gateway = inet_addr(tmp);
getString(buf, "MentoHUST", "DNS", "0.0.0.0", tmp, sizeof(tmp));
dns = inet_addr(tmp);
getString(buf, "MentoHUST", "PingHost", "0.0.0.0", tmp, sizeof(tmp));
pingHost = inet_addr(tmp);
timeout = getInt(buf, "MentoHUST", "Timeout", D_TIMEOUT) % 100;
echoInterval = getInt(buf, "MentoHUST", "EchoInterval", D_ECHOINTERVAL) % 1000;
restartWait = getInt(buf, "MentoHUST", "RestartWait", D_RESTARTWAIT) % 100;
startMode = getInt(buf, "MentoHUST", "StartMode", D_STARTMODE) % 3;
dhcpMode = getInt(buf, "MentoHUST", "DhcpMode", D_DHCPMODE) % 4;
#ifndef NO_NOTIFY
showNotify = getInt(buf, "MentoHUST", "ShowNotify", D_SHOWNOTIFY) % 21;
#endif
*daemonMode = getInt(buf, "MentoHUST", "DaemonMode", D_DAEMONMODE) % 4;
maxFail = getInt(buf, "MentoHUST", "MaxFail", D_MAXFAIL);
free(buf);
return 0;
}
static void readArg(char argc, char **argv, int *saveFlag, int *exitFlag, int *daemonMode)
{
char *str, c;
int i;
for (i=1; i<argc; i++)
{
str = argv[i];
if (str[0]!='-' && str[0]!='/')
continue;
c = str[1];
if (c=='h' || c=='?' || strcmp(str, "--help")==0)
showHelp(argv[0]);
else if (c == 'w')
*saveFlag = 1;
else if (c == 'k') {
if (strlen(str) > 2)
*exitFlag = 2;
else {
*exitFlag = 1;
return;
}
} else if (strlen(str) > 2) {
if (c == 'u')
strncpy(userName, str+2, sizeof(userName)-1);
else if (c == 'p')
strncpy(password, str+2, sizeof(password)-1);
else if (c == 'n')
strncpy(nic, str+2, sizeof(nic)-1);
else if (c == 'f')
strncpy(dataFile, str+2, sizeof(dataFile)-1);
else if (c == 'c')
strncpy(dhcpScript, str+2, sizeof(dhcpScript)-1);
else if (c=='v' && strlen(str+2)>=3) {
unsigned ver[2];
if (sscanf(str+2, "%u.%u", ver, ver+1) != EOF) {
if (ver[0] == 0)
bufType = 0;
else {
version[0] = ver[0];
version[1] = ver[1];
bufType = 1;
}
}
}
else if (c == 'i')
ip = inet_addr(str+2);
else if (c == 'm')
mask = inet_addr(str+2);
else if (c == 'g')
gateway = inet_addr(str+2);
else if (c == 's')
dns = inet_addr(str+2);
else if (c == 'o')
pingHost = inet_addr(str+2);
else if (c == 't')
timeout = atoi(str+2) % 100;
else if (c == 'e')
echoInterval = atoi(str+2) % 1000;
else if (c == 'r')
restartWait = atoi(str+2) % 100;
else if (c == 'a')
startMode = atoi(str+2) % 3;
else if (c == 'd')
dhcpMode = atoi(str+2) % 4;
#ifndef NO_NOTIFY
else if (c == 'y')
showNotify = atoi(str+2) % 21;
#endif
else if (c == 'b')
*daemonMode = atoi(str+2) % 4;
else if (c == 'l')
maxFail = atoi(str+2);
}
}
}
static void showHelp(const char *fileName)
{
char *helpString =
"用法:\t%s [-选项][参数]\n"
"选项:\t-h 显示本帮助信息\n"
"\t-k -k(退出程序) 其他(重启程序)\n"
"\t-w 保存参数到配置文件\n"
"\t-u 用户名\n"
"\t-p 密码\n"
"\t-n 网卡名\n"
"\t-i IP[默认本机IP]\n"
"\t-m 子网掩码[默认本机掩码]\n"
"\t-g 网关[默认0.0.0.0]\n"
"\t-s DNS[默认0.0.0.0]\n"
"\t-o Ping主机[默认0.0.0.0，表示关闭该功能]\n"
"\t-t 认证超时(秒)[默认8]\n"
"\t-e 响应间隔(秒)[默认30]\n"
"\t-r 失败等待(秒)[默认15]\n"
"\t-l 允许失败次数[默认0，表示无限制]\n"
"\t-a 组播地址: 0(标准) 1(锐捷) 2(赛尔) [默认0]\n"
"\t-d DHCP方式: 0(不使用) 1(二次认证) 2(认证后) 3(认证前) [默认0]\n"
"\t-b 是否后台运行: 0(否) 1(是，关闭输出) 2(是，保留输出) 3(是，输出到文件) [默认0]\n"
#ifndef NO_NOTIFY
"\t-y 是否显示通知: 0(否) 1~20(是) [默认5]\n"
#endif
"\t-v 客户端版本号[默认0.00表示兼容xrgsu]\n"
"\t-f 自定义数据文件[默认不使用]\n"
"\t-c DHCP脚本[默认dhclient]\n"
"例如:\t%s -uusername -ppassword -neth0 -i192.168.0.1 -m255.255.255.0 -g0.0.0.0 -s0.0.0.0 -o0.0.0.0 -t8 -e30 -r15 -a0 -d1 -b0 -v4.10 -fdefault.mpf -cdhclient\n"
"注意：使用时请确保是以root权限运行！\n\n";
printf(helpString, fileName, fileName);
exit(EXIT_SUCCESS);
}
static int getAdapter()
{
pcap_if_t *alldevs, *d;
int num = 0, avail = 0, i;
char errbuf[PCAP_ERRBUF_SIZE];
if (pcap_findalldevs(&alldevs, errbuf)==-1 || alldevs==NULL)
{
printf("!! 查找网卡失败: %s\n", errbuf);
return -1;
}
for (d=alldevs; d!=NULL; d=d->next)
{
num++;
if (!(d->flags & PCAP_IF_LOOPBACK) && strcmp(d->name, "any")!=0)
{
printf("** 网卡[%d]:\t%s\n", num, d->name);
avail++;
i = num;
}
}
if (avail == 0)
{
pcap_freealldevs(alldevs);
printf("!! 找不到网卡！\n");
return -1;
}
if (avail > 1)
{
printf("?? 请选择网卡[1-%d]: ", num);
scanf("%d", &i);
if (i < 1)
i = 1;
else if (i > num)
i = num;
}
printf("** 您选择了第[%d]块网卡。\n", i);
for (d=alldevs; i>1; d=d->next, i--);
strncpy(nic, d->name, sizeof(nic)-1);
pcap_freealldevs(alldevs);
return 0;
}
static void printConfig()
{
char *addr[] = {"标准", "锐捷", "赛尔"};
char *dhcp[] = {"不使用", "二次认证", "认证后", "认证前"};
printf("** 用户名:\t%s\n", userName);
/* printf("** 密码:\t%s\n", password); */
printf("** 网卡: \t%s\n", nic);
if (gateway)
printf("** 网关地址:\t%s\n", formatIP(gateway));
if (dns)
printf("** DNS地址:\t%s\n", formatIP(dns));
if (pingHost)
printf("** 智能重连:\t%s\n", formatIP(pingHost));
printf("** 认证超时:\t%u秒\n", timeout);
printf("** 响应间隔:\t%u秒\n", echoInterval);
printf("** 失败等待:\t%u秒\n", restartWait);
printf("** 允许失败:\t%u次\n", maxFail);
printf("** 组播地址:\t%s\n", addr[startMode]);
printf("** DHCP方式:\t%s\n", dhcp[dhcpMode]);
#ifndef NO_NOTIFY
if (showNotify)
printf("** 通知超时:\t%d秒\n", showNotify);
#endif
if (bufType >= 2)
printf("** 数据文件:\t%s\n", dataFile);
if (dhcpMode != 0)
printf("** DHCP脚本:\t%s\n", dhcpScript);
}
static int openPcap()
{
char buf[PCAP_ERRBUF_SIZE], *fmt;
struct bpf_program fcode;
if ((hPcap = pcap_open_live(nic, 2048, 1, 1000, buf)) == NULL)
{
printf("!! 打开网卡%s失败: %s\n", nic, buf);
return -1;
}
fmt = formatHex(localMAC, 6);
#ifndef NO_ARP
sprintf(buf, "((ether proto 0x888e and (ether dst %s or ether dst 01:80:c2:00:00:03)) "
"or ether proto 0x0806) and not ether src %s", fmt, fmt);
#else
sprintf(buf, "ether proto 0x888e and (ether dst %s or ether dst 01:80:c2:00:00:03) "
"and not ether src %s", fmt, fmt);
#endif
if (pcap_compile(hPcap, &fcode, buf, 0, 0xffffffff) == -1
|| pcap_setfilter(hPcap, &fcode) == -1)
{
printf("!! 设置pcap过滤器失败: %s\n", pcap_geterr(hPcap));
return -1;
}
pcap_freecode(&fcode);
return 0;
}
static void saveConfig(int daemonMode)
{
char *buf = loadFile(CFG_FILE);
if (buf == NULL) {
buf = (char *)malloc(1);
buf[0] = '\0';
}
setString(&buf, "MentoHUST", "DhcpScript", dhcpScript);
setString(&buf, "MentoHUST", "DataFile", dataFile);
if (bufType != 0) {
char ver[10];
sprintf(ver, "%u.%u", version[0], version[1]);
setString(&buf, "MentoHUST", "Version", ver);
} else
setString(&buf, "MentoHUST", "Version", "0.00");
#ifndef NO_NOTIFY
setInt(&buf, "MentoHUST", "ShowNotify", showNotify);
#endif
setInt(&buf, "MentoHUST", "DaemonMode", daemonMode);
setInt(&buf, "MentoHUST", "DhcpMode", dhcpMode);
setInt(&buf, "MentoHUST", "StartMode", startMode);
setInt(&buf, "MentoHUST", "MaxFail", maxFail);
setInt(&buf, "MentoHUST", "RestartWait", restartWait);
setInt(&buf, "MentoHUST", "EchoInterval", echoInterval);
setInt(&buf, "MentoHUST", "Timeout", timeout);
setString(&buf, "MentoHUST", "PingHost", formatIP(pingHost));
setString(&buf, "MentoHUST", "DNS", formatIP(dns));
setString(&buf, "MentoHUST", "Gateway", formatIP(gateway));
setString(&buf, "MentoHUST", "Mask", formatIP(mask));
setString(&buf, "MentoHUST", "IP", formatIP(ip));
setString(&buf, "MentoHUST", "Nic", nic);
#ifdef NO_ENCODE_PASS
setString(&buf, "MentoHUST", "Password", password);
#else
char pass[ACCOUNT_SIZE*4/3];
encodePass(pass, password);
setString(&buf, "MentoHUST", "EncodePass", pass);
#endif
setString(&buf, "MentoHUST", "Username", userName);
if (saveFile(buf, CFG_FILE) != 0)
printf("!! 保存认证参数到%s失败！\n", CFG_FILE);
else
printf("** 认证参数已成功保存到%s.\n", CFG_FILE);
free(buf);
}
static void checkRunning(int exitFlag, int daemonMode)
{
struct flock fl;
lockfd = open (LOCK_FILE, O_RDWR|O_CREAT, LOCKMODE);
if (lockfd < 0) {
perror("!! 打开锁文件失败"); /* perror真的很好啊，以前没用它真是太亏了 */
goto error_exit;
}
fl.l_start = 0;
fl.l_whence = SEEK_SET;
fl.l_len = 0;
fl.l_type = F_WRLCK;
if (fcntl(lockfd, F_GETLK, &fl) < 0) {
perror("!! 获取文件锁失败");
goto error_exit;
}
if (exitFlag) {
if (fl.l_type != F_UNLCK) {
printf(">> 已发送退出信号给MentoHUST进程(PID=%d).\n", fl.l_pid);
if (kill(fl.l_pid, SIGINT) == -1)
perror("!! 结束进程失败");
}
else
printf("!! 没有MentoHUST正在运行！\n");
if (exitFlag == 1)
exit(EXIT_SUCCESS);
}
else if (fl.l_type != F_UNLCK) {
printf("!! MentoHUST已经运行(PID=%d)!\n", fl.l_pid);
exit(EXIT_FAILURE);
}
if (daemonMode) { /* 貌似我过早进入后台模式了，就给个选项保留输出或者输出到文件吧 */
printf(">> 进入后台运行模式，使用参数-k可退出认证。\n");
if (daemon(0, (daemonMode+1)%2))
perror("!! 后台运行失败");
else if (daemonMode == 3) {
freopen(LOG_FILE, "w", stdout);
freopen(LOG_FILE, "a", stderr);
}
}
fl.l_type = F_WRLCK;
fl.l_pid = getpid();
if (fcntl(lockfd, F_SETLKW, &fl) < 0) {
perror("!! 加锁失败");
goto error_exit;
}
return;
error_exit:
#ifndef NO_NOTIFY
if (showNotify)
show_notify("MentoHUST - 错误提示", "操作锁文件失败，请检查是否为root权限！");
#endif
exit(EXIT_FAILURE);
}
================================================
FILE: src/myconfig.h
================================================
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：myconfig.h
* 摘 要：初始化认证参数
* 作 者：HustMoon@BYHH
*/
#ifndef HUSTMOON_MYCONFIG_H
#define HUSTMOON_MYCONFIG_H
void initConfig(int argc, char **argv); /* 初始化配置 */
#endif
================================================
FILE: src/myfunc.c
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：myfunc.c
* 摘 要：认证相关算法及方法
* 作 者：HustMoon@BYHH
*/
#include "myfunc.h"
#include "md5.h"
#include "mycheck.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <arpa/inet.h>
#ifndef SIOCGIFHWADDR /* BSD、MacOS */
#include <net/if_dl.h>
#include <ifaddrs.h>
#endif
#include <sys/poll.h>
const u_char STANDARD_ADDR[] = {0x01,0x80,0xC2,0x00,0x00,0x03};
const u_char RUIJIE_ADDR[] = {0x01,0xD0,0xF8,0x00,0x00,0x03};
static const char *DATAFILE = "/etc/mentohust/"; /* 默认数据文件(目录) */
static int dataOffset; /* 抓包偏移 */
static u_int32_t echoKey = 0, echoNo = 0; /* Echo阶段所需 */
u_char *fillBuf = NULL; /* 填充包地址 */
int fillSize = 0; /* 填充包大小 */
int bufType = 0; /*0内置xrgsu 1内置Win 2仅文件 3文件+校验*/
u_char version[2]; /* 版本 */
#ifndef NO_ARP
u_int32_t rip = 0; /* 实际IP */
u_char gateMAC[6]; /* 网关MAC */
#endif
extern char password[];
extern char nic[];
extern char dataFile[];
extern u_int32_t ip, mask, gateway, dns, pingHost;
extern u_char localMAC[], destMAC[];
extern unsigned startMode, dhcpMode;
static int checkFile(); /* 检查数据文件 */
static int getVersion(); /* 获取8021x.exe版本号 */
static int getAddress(); /* 获取网络地址 */
static u_char encode(u_char base); /* 锐捷算法，颠倒一个字节的8位 */
static void checkSum(u_char *buf); /* 锐捷算法，计算两个字节的检验值 */
static int setProperty(u_char type, const u_char *value, int length); /* 设置指定属性 */
static int readPacket(int type); /* 读取数据 */
static int Check(const u_char *md5Seed); /* 校验算法 */
char *formatIP(u_int32_t ip)
{
static char tmp[16];
u_char *p = (u_char *)(&ip);
sprintf(tmp, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
return tmp;
}
char *formatHex(const void *buf, int length)
{
static char hex[385];
u_char *p = (u_char *)buf;
int i;
if (length > 128)
length = 128;
for (i=0; i<length; i++)
sprintf(hex+3*i,"%02x:", p[i]);
hex[3*length-1] = '\0';
return hex;
}
static int checkFile() {
u_char Buf[16], *buf=Buf;
FILE *fp = NULL;
if ((fp=fopen(dataFile, "rb")) == NULL)
goto fileError;
if (fread(buf, 16, 1, fp)<1 || memcmp(buf, "HUST", 4)!=0) {
fclose(fp);
goto fileError;
}
dataOffset = (int)LTOBL(*(u_int32_t *)buf ^ *(u_int32_t *)(buf + 8)) + 16;
fseek(fp, 0, SEEK_END);
fillSize = ftell(fp);
fclose(fp);
if (dataOffset < 16)
goto fileError;
fillSize = (fillSize - dataOffset) / 2 + 0x17;
if (fillSize<0x80 || fillSize>0x397)
goto fileError;
return 0;
fileError:
if (dataFile[strlen(dataFile)-1] != '/')
printf("!! 所选文件%s无效，改用内置数据认证。\n", dataFile);
return -1;
}
static int getVersion() {
char file[0x100], *p;
DWORD ver;
strcpy(file, dataFile);
if ((p=strrchr(file, '/')+1) == (void *)1)
p = file;
strcpy(p, "8021x.exe");
if ((ver=getVer(file)) == (DWORD)-1)
return -1;
p = (char *)&ver;
version[0] = p[2];
version[1] = p[0];
bufType = 1;
return 0;
}
void newBuffer()
{
if (dataFile[0] == '\0')
strcpy(dataFile, DATAFILE);
getVersion();
if (checkFile() == 0)
bufType += 2;
else fillSize = (bufType==0 ? 0x80 : 0x1d7);
fillBuf = (u_char *)malloc(fillSize);
}
static int getAddress()
{
struct ifreq ifr;
#ifndef SIOCGIFHWADDR /* BSD、MacOS */
struct ifaddrs *ifap, *p = NULL;
struct sockaddr_dl *sdl;
#endif
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0)
{
printf("!! 创建套接字失败!\n");
return -1;
}
strcpy(ifr.ifr_name, nic);
#ifdef SIOCGIFHWADDR
if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0)
goto getMACError;
memcpy(localMAC, ifr.ifr_hwaddr.sa_data, 6);
#else
if (getifaddrs(&ifap) == 0)
{
for (p=ifap; p; p=p->ifa_next)
{
if (p->ifa_name && strcmp(p->ifa_name, nic)==0)
{
sdl = (struct sockaddr_dl *)p->ifa_addr;
memcpy(localMAC, sdl->sdl_data + sdl->sdl_nlen, 6);
break;
}
}
freeifaddrs(ifap);
}
if (p == NULL)
goto getMACError;
#endif
if (startMode == 0)
memcpy(destMAC, STANDARD_ADDR, 6);
else if (startMode == 1)
memcpy(destMAC, RUIJIE_ADDR, 6);
#ifndef NO_ARP
gateMAC[0] = 0xFE;
if (ioctl(sock, SIOCGIFADDR, &ifr) < 0)
printf("!! 在网卡%s上获取IP失败!\n", nic);
else {
rip = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;
if (gateway!=0 && (startMode%3!=2 || ((u_char *)&gateway)[3]!=0x02))
gateMAC[0] = 0xFF;
}
if (dhcpMode!=0 || ip==-1)
ip = rip;
#else
if (dhcpMode!=0 || ip==-1) {
if (ioctl(sock, SIOCGIFADDR, &ifr) < 0)
printf("!! 在网卡%s上获取IP失败!\n", nic);
else
ip = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;
}
#endif
if (dhcpMode!=0 || mask==-1) {
if (ioctl(sock, SIOCGIFNETMASK, &ifr) < 0)
printf("!! 在网卡%s上获取子网掩码失败!\n", nic);
else
mask = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;
}
close(sock);
printf("** 本机MAC:\t%s\n", formatHex(localMAC, 6));
printf("** 使用IP:\t%s\n", formatIP(ip));
printf("** 子网掩码:\t%s\n", formatIP(mask));
return 0;
getMACError:
close(sock);
printf("!! 在网卡%s上获取MAC失败!\n", nic);
return -1;
}
static u_char encode(u_char base) /* 算法，将一个字节的8位颠倒并取反 */
{
u_char result = 0;
int i;
for (i=0; i<8; i++)
{
result <<= 1;
result |= base&0x01;
base >>= 1;
}
return ~result;
}
static void checkSum(u_char *buf) /* 算法，计算两个字节的checksum */
{
u_char table[] =
{
0x00,0x00,0x21,0x10,0x42,0x20,0x63,0x30,0x84,0x40,0xA5,0x50,0xC6,0x60,0xE7,0x70,
0x08,0x81,0x29,0x91,0x4A,0xA1,0x6B,0xB1,0x8C,0xC1,0xAD,0xD1,0xCE,0xE1,0xEF,0xF1,
0x31,0x12,0x10,0x02,0x73,0x32,0x52,0x22,0xB5,0x52,0x94,0x42,0xF7,0x72,0xD6,0x62,
0x39,0x93,0x18,0x83,0x7B,0xB3,0x5A,0xA3,0xBD,0xD3,0x9C,0xC3,0xFF,0xF3,0xDE,0xE3,
0x62,0x24,0x43,0x34,0x20,0x04,0x01,0x14,0xE6,0x64,0xC7,0x74,0xA4,0x44,0x85,0x54,
0x6A,0xA5,0x4B,0xB5,0x28,0x85,0x09,0x95,0xEE,0xE5,0xCF,0xF5,0xAC,0xC5,0x8D,0xD5,
0x53,0x36,0x72,0x26,0x11,0x16,0x30,0x06,0xD7,0x76,0xF6,0x66,0x95,0x56,0xB4,0x46,
0x5B,0xB7,0x7A,0xA7,0x19,0x97,0x38,0x87,0xDF,0xF7,0xFE,0xE7,0x9D,0xD7,0xBC,0xC7,
0xC4,0x48,0xE5,0x58,0x86,0x68,0xA7,0x78,0x40,0x08,0x61,0x18,0x02,0x28,0x23,0x38,
0xCC,0xC9,0xED,0xD9,0x8E,0xE9,0xAF,0xF9,0x48,0x89,0x69,0x99,0x0A,0xA9,0x2B,0xB9,
0xF5,0x5A,0xD4,0x4A,0xB7,0x7A,0x96,0x6A,0x71,0x1A,0x50,0x0A,0x33,0x3A,0x12,0x2A,
0xFD,0xDB,0xDC,0xCB,0xBF,0xFB,0x9E,0xEB,0x79,0x9B,0x58,0x8B,0x3B,0xBB,0x1A,0xAB,
0xA6,0x6C,0x87,0x7C,0xE4,0x4C,0xC5,0x5C,0x22,0x2C,0x03,0x3C,0x60,0x0C,0x41,0x1C,
0xAE,0xED,0x8F,0xFD,0xEC,0xCD,0xCD,0xDD,0x2A,0xAD,0x0B,0xBD,0x68,0x8D,0x49,0x9D,
0x97,0x7E,0xB6,0x6E,0xD5,0x5E,0xF4,0x4E,0x13,0x3E,0x32,0x2E,0x51,0x1E,0x70,0x0E,
0x9F,0xFF,0xBE,0xEF,0xDD,0xDF,0xFC,0xCF,0x1B,0xBF,0x3A,0xAF,0x59,0x9F,0x78,0x8F,
0x88,0x91,0xA9,0x81,0xCA,0xB1,0xEB,0xA1,0x0C,0xD1,0x2D,0xC1,0x4E,0xF1,0x6F,0xE1,
0x80,0x10,0xA1,0x00,0xC2,0x30,0xE3,0x20,0x04,0x50,0x25,0x40,0x46,0x70,0x67,0x60,
0xB9,0x83,0x98,0x93,0xFB,0xA3,0xDA,0xB3,0x3D,0xC3,0x1C,0xD3,0x7F,0xE3,0x5E,0xF3,
0xB1,0x02,0x90,0x12,0xF3,0x22,0xD2,0x32,0x35,0x42,0x14,0x52,0x77,0x62,0x56,0x72,
0xEA,0xB5,0xCB,0xA5,0xA8,0x95,0x89,0x85,0x6E,0xF5,0x4F,0xE5,0x2C,0xD5,0x0D,0xC5,
0xE2,0x34,0xC3,0x24,0xA0,0x14,0x81,0x04,0x66,0x74,0x47,0x64,0x24,0x54,0x05,0x44,
0xDB,0xA7,0xFA,0xB7,0x99,0x87,0xB8,0x97,0x5F,0xE7,0x7E,0xF7,0x1D,0xC7,0x3C,0xD7,
0xD3,0x26,0xF2,0x36,0x91,0x06,0xB0,0x16,0x57,0x66,0x76,0x76,0x15,0x46,0x34,0x56,
0x4C,0xD9,0x6D,0xC9,0x0E,0xF9,0x2F,0xE9,0xC8,0x99,0xE9,0x89,0x8A,0xB9,0xAB,0xA9,
0x44,0x58,0x65,0x48,0x06,0x78,0x27,0x68,0xC0,0x18,0xE1,0x08,0x82,0x38,0xA3,0x28,
0x7D,0xCB,0x5C,0xDB,0x3F,0xEB,0x1E,0xFB,0xF9,0x8B,0xD8,0x9B,0xBB,0xAB,0x9A,0xBB,
0x75,0x4A,0x54,0x5A,0x37,0x6A,0x16,0x7A,0xF1,0x0A,0xD0,0x1A,0xB3,0x2A,0x92,0x3A,
0x2E,0xFD,0x0F,0xED,0x6C,0xDD,0x4D,0xCD,0xAA,0xBD,0x8B,0xAD,0xE8,0x9D,0xC9,0x8D,
0x26,0x7C,0x07,0x6C,0x64,0x5C,0x45,0x4C,0xA2,0x3C,0x83,0x2C,0xE0,0x1C,0xC1,0x0C,
0x1F,0xEF,0x3E,0xFF,0x5D,0xCF,0x7C,0xDF,0x9B,0xAF,0xBA,0xBF,0xD9,0x8F,0xF8,0x9F,
0x17,0x6E,0x36,0x7E,0x55,0x4E,0x74,0x5E,0x93,0x2E,0xB2,0x3E,0xD1,0x0E,0xF0,0x1E
};
u_char *checkSum = buf + 0x15;
int i, index;
for (i=0; i<0x15; i++)
{
index = checkSum[0] ^ buf[i];
checkSum[0] = checkSum[1] ^ table[index*2+1];
checkSum[1] = table[index*2];
}
for (i=0; i<0x17; i++)
buf[i] = encode(buf[i]);
}
int fillHeader()
{
if (getAddress() == -1)
return -1;
memset(fillBuf, 0, fillSize);
fillBuf[0x02] = 0x13;
fillBuf[0x03] = 0x11;
if (dhcpMode != 0)
fillBuf[0x04] = 0x01; /* DHCP位，使用1、不使用0 */
memcpy(fillBuf+0x05, &ip, 4);
memcpy(fillBuf+0x09, &mask, 4);
memcpy(fillBuf+0x0D, &gateway, 4);
memcpy(fillBuf+0x11, &dns, 4);
checkSum(fillBuf);
return 0;
}
static int setProperty(u_char type, const u_char *value, int length)
{
u_char *p = fillBuf+0x46, *end = fillBuf+fillSize-length-8; /* 形如1a 28 00 00 13 11 17 22，至少8个字节 */
while (p < end)
{
if (*p == 0x1a) /* 有些老版本没有前两个字节，包括xrgsu */
p += 2;
if (p[4] == type)
{
memcpy(p+4+p[5]-length, value, length);
return 0;
}
p += p[5] + 4;
}
return -1;
}
static int readPacket(int type)
{
u_char dhcp[] = {0x00};
FILE *fp = fopen(dataFile, "rb");
if (fp == NULL)
goto fileError;
type %= 2; /* 偶数读Start包，奇数读Md5包 */
fseek(fp, dataOffset+(fillSize-0x17)*type, SEEK_SET);
if (fread(fillBuf+0x17, fillSize-0x17, 1, fp) < 1) /* 前0x17字节是地址及校验值 */
{
fclose(fp);
goto fileError;
}
fclose(fp);
if (dhcpMode == 1) /* 二次认证第一次 */
dhcp[0] = 0x01;
setProperty(0x18, dhcp, 1);
setProperty(0x2D, localMAC, 6);
if (bufType == 3)
memcpy(fillBuf+0x3b, version, 2);
return 0;
fileError:
printf("!! 所选文件%s无效，改用内置数据认证。\n", dataFile);
bufType -= 2;
if (bufType==1 && fillSize<0x1d7) {
free(fillBuf);
fillSize = 0x1d7;
fillBuf = (u_char *)malloc(fillSize);
}
return -1;
}
void fillStartPacket()
{
if (bufType <= 1) { /* 使用xrgsu？ */
const u_char packet0[] = {
0x00,0x00,0x13,0x11,0x38,0x30,0x32,0x31,0x78,0x2e,0x65,0x78,0x65,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,0x00,0x13,0x11,0x00,0x28,0x1a,
0x28,0x00,0x00,0x13,0x11,0x17,0x22,0x91,0x66,0x64,0x93,0x67,0x60,0x65,0x62,0x62,
0x94,0x61,0x69,0x67,0x63,0x91,0x93,0x92,0x68,0x66,0x93,0x91,0x66,0x95,0x65,0xaa,
0xdc,0x64,0x98,0x96,0x6a,0x9d,0x66,0x00,0x00,0x13,0x11,0x18,0x06,0x02,0x00,0x00
};
const u_char packet1[] = {
0x00,0x00,0x13,0x11,0x38,0x30,0x32,0x31,0x78,0x2e,0x65,0x78,0x65,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x04,0x0a,0x00,0x02,0x00,0x00,0x00,0x13,0x11,0x01,0x8c,0x1a,
0x28,0x00,0x00,0x13,0x11,0x17,0x22,0x36,0x38,0x44,0x43,0x31,0x32,0x33,0x42,0x37,
0x45,0x42,0x32,0x33,0x39,0x46,0x32,0x33,0x41,0x38,0x43,0x30,0x30,0x30,0x33,0x38,
0x38,0x34,0x39,0x38,0x36,0x33,0x39,0x1a,0x0c,0x00,0x00,0x13,0x11,0x18,0x06,0x00,
0x00,0x00,0x00,0x1a,0x0e,0x00,0x00,0x13,0x11,0x2d,0x08,0x00,0x00,0x00,0x00,0x00,
0x00,0x1a,0x08,0x00,0x00,0x13,0x11,0x2f,0x02,0x1a,0x09,0x00,0x00,0x13,0x11,0x35,
0x03,0x01,0x1a,0x18,0x00,0x00,0x13,0x11,0x36,0x12,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1a,0x18,0x00,0x00,0x13,0x11,
0x38,0x12,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0x86,
0x13,0x4c,0x1a,0x88,0x00,0x00,0x13,0x11,0x4d,0x82,0x36,0x38,0x64,0x63,0x31,0x32,
0x33,0x62,0x30,0x37,0x65,0x62,0x32,0x33,0x39,0x66,0x32,0x33,0x61,0x38,0x30,0x64,
0x63,0x66,0x32,0x35,0x38,0x37,0x35,0x64,0x30,0x35,0x37,0x37,0x30,0x63,0x37,0x32,
0x31,0x65,0x34,0x35,0x36,0x34,0x35,0x65,0x35,0x33,0x37,0x61,0x62,0x33,0x35,0x31,
0x62,0x62,0x36,0x33,0x31,0x35,0x35,0x61,0x65,0x31,0x36,0x32,0x36,0x31,0x36,0x37,
0x65,0x62,0x30,0x39,0x32,0x32,0x33,0x65,0x32,0x61,0x30,0x61,0x37,0x38,0x30,0x33,
0x31,0x31,0x36,0x31,0x61,0x63,0x30,0x39,0x64,0x61,0x32,0x64,0x63,0x30,0x37,0x33,
0x36,0x39,0x33,0x61,0x34,0x66,0x35,0x61,0x32,0x39,0x32,0x38,0x36,0x37,0x35,0x31,
0x66,0x39,0x37,0x66,0x34,0x64,0x30,0x34,0x36,0x38,0x1a,0x28,0x00,0x00,0x13,0x11,
0x39,0x22,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x1a,0x48,0x00,0x00,0x13,0x11,0x54,0x42,0x48,0x55,0x53,0x54,0x4d,0x4f,
0x4f,0x4e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1a,0x08,0x00,0x00,0x13,0x11,
0x55,0x02,0x1a,0x09,0x00,0x00,0x13,0x11,0x62,0x03,0x00,0x00,0x00,0x00,0x00,0x00
};
u_char dhcp[] = {0x00};
if (dhcpMode == 1) /* 二次认证第一次 */
dhcp[0] = 0x01;
if (bufType == 1) {
memcpy(fillBuf+0x17, packet1, sizeof(packet1));
memcpy(fillBuf+0x3b, version, 2);
} else
memcpy(fillBuf+0x17, packet0, sizeof(packet0));
setProperty(0x18, dhcp, 1);
setProperty(0x2D, localMAC, 6);
}
else if (readPacket(0) == -1) /* 读取数据失败就用默认的填充 */
fillStartPacket();
}
void fillMd5Packet(const u_char *md5Seed)
{
if (bufType <= 1) { /* 不使用数据包？ */
/* xrgsu的Md5包与Start包只有一个字节的差异，若以其他版本为基础，可进一步区别对待 */
fillStartPacket();
if (bufType == 1)
Check(md5Seed);
} else {
if (readPacket(1) == -1)
fillMd5Packet(md5Seed);
else
Check(md5Seed);
}
echoNo = 0x0000102B; /* 初始化echoNo */
}
static int Check(const u_char *md5Seed) /* 客户端校验 */
{
char final_str[129];
int value;
printf("** 客户端版本:\t%d.%d\n", fillBuf[0x3B], fillBuf[0x3C]);
printf("** MD5种子:\t%s\n", formatHex(md5Seed, 16));
value = check_init(dataFile);
if (value == -1) {
printf("!! 缺少8021x.exe信息，客户端校验无法继续！\n");
return 1;
}
V2_check(md5Seed, final_str);
printf("** V2校验值:\t%s\n", final_str);
setProperty(0x17, (u_char *)final_str, 32);
check_free();
return 0;
}
void fillEchoPacket(u_char *echoBuf)
{
int i;
u_int32_t dd1=htonl(echoKey + echoNo), dd2=htonl(echoNo);
u_char *bt1=(u_char *)&dd1, *bt2=(u_char *)&dd2;
echoNo++;
for (i=0; i<4; i++)
{
echoBuf[0x18+i] = encode(bt1[i]);
echoBuf[0x22+i] = encode(bt2[i]);
}
}
void getEchoKey(const u_char *capBuf)
{
int i, offset = 0x1c+capBuf[0x1b]+0x69+24; /* 通过比较了大量抓包，通用的提取点就是这样的 */
u_char *base;
echoKey = ntohl(*(u_int32_t *)(capBuf+offset));
base = (u_char *)(&echoKey);
for (i=0; i<4; i++)
base[i] = encode(base[i]);
}
u_char *checkPass(u_char id, const u_char *md5Seed, int seedLen)
{
u_char md5Src[80];
int md5Len = strlen(password);
md5Src[0] = id;
memcpy(md5Src+1, password, md5Len);
md5Len++;
if (startMode % 3 == 2) /* 赛尔？ */
{
memcpy(md5Src+md5Len, "xxghlmxhzb", 10);
md5Len += 10;
}
memcpy(md5Src+md5Len, md5Seed, seedLen);
md5Len += seedLen;
return ComputeHash(md5Src, md5Len);
}
void fillCernetAddr(u_char *buf)
{
memcpy(buf+0x18, &ip, 4);
memcpy(buf+0x1C, &mask, 4);
memcpy(buf+0x20, &gateway, 4);
memset(buf+0x24, 0, 4); /* memcpy(buf+0x24, &dns, 4); */
}
int isOnline()
{
u_char echoPacket[] =
{
0x08,0x00,0x61,0xb2,0x02,0x00,0x01,0x00,0x57,0x65,0x6C,0x63,0x6F,0x6D,0x65,0x20,
0x74,0x6F,0x20,0x4D,0x65,0x6E,0x74,0x6F,0x48,0x55,0x53,0x54,0x21,0x0A,0x43,0x6F,
0x70,0x79,0x72,0x69,0x67,0x68,0x74,0x20,0x28,0x63,0x29,0x20,0x32,0x30,0x30,0x39,
0x20,0x48,0x75,0x73,0x74,0x4D,0x6F,0x6F,0x6E,0x20,0x53,0x74,0x75,0x64,0x69,0x6F
};
int sock=-1, rtVal, t;
struct pollfd pfd;
struct sockaddr_in dest;
if (pingHost == 0)
return 0;
memset(&dest, 0, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_addr.s_addr = pingHost;
if ((sock=socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0)
goto pingError;
pfd.fd = sock;
pfd.events = POLLIN;
for (t=1; t<=3; t++) {
if (sendto(sock, echoPacket, sizeof(echoPacket), 0,
(struct sockaddr *)&dest, sizeof(dest)) < 0)
goto pingError;
rtVal = poll(&pfd, 1, t*1000);
if (rtVal == -1)
goto pingError;
if (rtVal > 0) {
close(sock);
return 0;
}
}
close(sock);
return -1;
pingError:
perror("!! Ping主机出错，关闭该功能");
if (sock != -1)
close(sock);
pingHost = 0;
return 0;
}
================================================
FILE: src/myfunc.h
================================================
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：myfunc.h
* 摘 要：认证相关算法及方法
* 作 者：HustMoon@BYHH
*/
#ifndef HUSTMOON_MYFUNC_H
#define HUSTMOON_MYFUNC_H
#include <sys/types.h>
char *formatIP(u_int32_t ip); /* 格式化IP */
char *formatHex(const void *buf, int length); /* 格式化成十六进制形式 */
void newBuffer(); /* 检测数据文件有效性并分配内存 */
int fillHeader(); /* 填充网络地址及校验值部分 */
void fillStartPacket(); /* 填充Start包 */
void fillMd5Packet(const u_char *md5Seed); /* 填充Md5包 */
void fillEchoPacket(u_char *buf); /* 填充Echo包 */
void getEchoKey(const u_char *capBuf); /* 获取EchoKey */
u_char *checkPass(u_char id, const u_char *md5Seed, int seedLen); /* 计算密码的md5 */
void fillCernetAddr(u_char *buf); /* 填充赛尔网络地址 */
int isOnline(); /* ping主机判断是否掉线 */
#endif
================================================
FILE: src/myini.c
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：myini.c
* 摘 要：读取ini文件+写入ini文件
* 作 者：HustMoon@BYHH
* 修 改：2009.10.8
*/
#include "myini.h"
#include <stdio.h>
#include <string.h>
#define NOT_COMMENT(c) (c!=';' && c!='#') /* 不是注释行 */
#ifndef strnicmp
#define strnicmp strncasecmp
#endif
static void getLine(const char *buf, int inStart, int *lineStart, int *lineEnd);
static int findKey(const char *buf, const char *section, const char *key,
int *sectionStart, int *valueStart, unsigned long *valueSize);
static int getSection(const char *buf, int inStart);
char *loadFile(const char *fileName)
{
FILE *fp = NULL;
long size = 0;
char *buf = NULL;
if ((fp=fopen(fileName, "rb")) == NULL)
return NULL;
fseek(fp, 0, SEEK_END);
size = ftell(fp);
rewind(fp);
buf = (char *)malloc(size+1);
buf[size] = '\0';
if (fread(buf, size, 1, fp) < 1)
{
free(buf);
buf = NULL;
}
fclose(fp);
return buf;
}
static void getLine(const char *buf, int inStart, int *lineStart, int *lineEnd)
{
int start, end;
for (start=inStart; buf[start]==' ' || buf[start]=='\t' || buf[start]=='\r' || buf[start]=='\n'; start++);
for (end=start; buf[end]!='\r' && buf[end]!='\n' && buf[end]!='\0'; end++);
*lineStart = start;
*lineEnd = end;
}
static int findKey(const char *buf, const char *section, const char *key,
int *sectionStart, int *valueStart, unsigned long *valueSize)
{
int lineStart, lineEnd, i;
for (*sectionStart=-1, lineEnd=0; buf[lineEnd]!='\0'; )
{
getLine(buf, lineEnd, &lineStart, &lineEnd);
if (buf[lineStart] == '[')
{
for (i=++lineStart; i<lineEnd && buf[i]!=']'; i++);
if (i<lineEnd && strnicmp(buf+lineStart, section, i-lineStart)==0) /* 找到Section？ */
{
*sectionStart = lineStart-1;
if (key == NULL)
return -1;
}
else if (*sectionStart != -1) /* 找到Section但未找到Key */
return -1;
}
else if (*sectionStart!=-1 && NOT_COMMENT(buf[lineStart])) /* 找到Section且该行不是注释 */
{
for (i=lineStart+1; i<lineEnd && buf[i]!='='; i++);
if (i<lineEnd && strnicmp(buf+lineStart, key, i-lineStart)==0) /* 找到Key？ */
{
*valueStart = i + 1;
*valueSize = lineEnd - *valueStart;
return 0;
}
}
}
return -1;
}
int getString(const char *buf, const char *section, const char *key,
const char *defaultValue, char *value, unsigned long size)
{
int sectionStart, valueStart;
unsigned long valueSize;
if (findKey(buf, section, key, §ionStart, &valueStart, &valueSize)!=0 || valueSize==0) /* 未找到？ */
{
strncpy(value, defaultValue, size);
return -1;
}
if (size-1 < valueSize) /* 找到但太长？ */
valueSize = size - 1;
memset(value, 0, size);
strncpy(value, buf+valueStart, valueSize);
return 0;
}
int getInt(const char *buf, const char *section, const char *key, int defaultValue)
{
char value[21] = {0};
getString(buf, section, key, "", value, sizeof(value));
if (value[0] == '\0') /* 找不到或找到但为空？ */
return defaultValue;
return atoi(value);
}
void setString(char **buf, const char *section, const char *key, const char *value)
{
int sectionStart, valueStart;
unsigned long valueSize;
char *newBuf = NULL;
if (findKey(*buf, section, key, §ionStart, &valueStart, &valueSize) == 0) /* 找到key */
{
if (value == NULL) /* 删除key? */
memmove(*buf+valueStart-strlen(key)-1, *buf+valueStart+valueSize,
strlen(*buf)+1-valueStart-valueSize);
else /* 修改key */
{
newBuf = (char *)malloc(strlen(*buf)-valueSize+strlen(value)+1);
memcpy(newBuf, *buf, valueStart);
strcpy(newBuf+valueStart, value);
strcpy(newBuf+valueStart+strlen(value), *buf+valueStart+valueSize);
free(*buf);
*buf = newBuf;
}
}
else if (sectionStart != -1) /* 找到section，找不到key */
{
if (key == NULL) /* 删除section? */
{
valueStart = getSection(*buf, sectionStart+3);
if (valueStart <= sectionStart) /* 后面没有section */
(*buf)[sectionStart] = '\0';
else
memmove(*buf+sectionStart, *buf+valueStart, strlen(*buf)+1-valueStart);
}
else if (value != NULL) /* 不是要删除key */
{
newBuf = (char *)malloc(strlen(*buf)+strlen(key)+strlen(value)+4);
valueSize = sectionStart+strlen(section)+2;
memcpy(newBuf, *buf, valueSize);
sprintf(newBuf+valueSize, "\n%s=%s", key, value);
strcpy(newBuf+strlen(newBuf), *buf+valueSize);
free(*buf);
*buf = newBuf;
}
}
else /* 找不到section? */
{
if (key!=NULL && value!=NULL)
{
newBuf = (char *)malloc(strlen(*buf)+strlen(section)+strlen(key)+strlen(value)+8);
strcpy(newBuf, *buf);
sprintf(newBuf+strlen(newBuf), "\n[%s]\n%s=%s", section, key, value);
free(*buf);
*buf = newBuf;
}
}
}
static int getSection(const char *buf, int inStart)
{
int lineStart, lineEnd, i;
for (lineEnd=inStart; buf[lineEnd]!='\0'; )
{
getLine(buf, lineEnd, &lineStart, &lineEnd);
if (buf[lineStart] == '[')
{
for (i=lineStart+1; i<lineEnd && buf[i]!=']'; i++);
if (i < lineEnd)
return lineStart;
}
}
return -1;
}
void setInt(char **buf, const char *section, const char *key, int value)
{
char svalue[21];
sprintf(svalue, "%d", value);
setString(buf, section, key, svalue);
}
int saveFile(const char *buf, const char *fileName)
{
FILE *fp;
int result;
if ((fp=fopen(fileName, "wb")) == NULL)
return -1;
result = fwrite(buf, strlen(buf), 1, fp)<1 ? -1 : 0;
fclose(fp);
return result;
}
================================================
FILE: src/myini.h
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：myini.h
* 摘 要：读取ini文件+写入ini文件
* 作 者：HustMoon@BYHH
* 修 改：2009.10.8
*/
#ifndef HUSTMOON_MYINI_H
#define HUSTMOON_MYINI_H
#include <stdlib.h> /* for free() */
#ifdef __cplusplus
extern "C"
{
#endif
char *loadFile(const char *fileName); /* 读取文件 */
int getString(const char *buf, const char *section, const char *key,
const char *defaultValue, char *value, unsigned long size); /* 读取字符串 */
int getInt(const char *buf, const char *section, const char *key, int defaultValue); /* 读取整数 */
void setString(char **buf, const char *section, const char *key, const char *value); /* 设置字符串，value=NULL则删除key，key=NULL则删除section */
void setInt(char **buf, const char *section, const char *key, int value); /* 设置整数 */
int saveFile(const char *buf, const char *fileName); /* 写入文件 */
#ifdef __cplusplus
};
#endif
#endif
================================================
FILE: src/mystate.c
================================================
/* -*- Mode: C; tab-width: 4; -*- */
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：mystate.c
* 摘 要：改变认证状态
* 作 者：HustMoon@BYHH
* 邮 箱：www.ehust@gmail.com
*/
#include "mystate.h"
#include "myfunc.h"
#include "dlfunc.h"
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#define MAX_SEND_COUNT 3 /* 最大超时次数 */
volatile int state = ID_DISCONNECT; /* 认证状态 */
const u_char *capBuf = NULL; /* 抓到的包 */
static u_char sendPacket[0x3E8]; /* 用来发送的包 */
static int sendCount = 0; /* 同一阶段发包计数 */
extern const u_char STANDARD_ADDR[];
extern char userName[];
extern unsigned startMode;
extern unsigned dhcpMode;
extern u_char localMAC[], destMAC[];
extern unsigned timeout;
extern unsigned echoInterval;
extern unsigned restartWait;
extern char dhcpScript[];
extern pcap_t *hPcap;
extern u_char *fillBuf;
extern unsigned fillSize;
extern u_int32_t pingHost;
#ifndef NO_ARP
extern u_int32_t rip, gateway;
extern u_char gateMAC[];
static void sendArpPacket(); /* ARP监视 */
#endif
static void setTimer(unsigned interval); /* 设置定时器 */
static int renewIP(); /* 更新IP */
static void fillEtherAddr(u_int32_t protocol); /* 填充MAC地址和协议 */
static int sendStartPacket(); /* 发送Start包 */
static int sendIdentityPacket(); /* 发送Identity包 */
static int sendChallengePacket(); /* 发送Md5 Challenge包 */
static int sendEchoPacket(); /* 发送心跳包 */
static int sendLogoffPacket(); /* 发送退出包 */
static int waitEchoPacket(); /* 等候响应包 */
static void setTimer(unsigned interval) /* 设置定时器 */
{
struct itimerval timer;
timer.it_value.tv_sec = interval;
timer.it_value.tv_usec = 0;
timer.it_interval.tv_sec = interval;
timer.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &timer, NULL);
}
int switchState(int type)
{
if (state == type) /* 跟上次是同一状态？ */
sendCount++;
else
{
state = type;
sendCount = 0;
}
if (sendCount>=MAX_SEND_COUNT && type!=ID_ECHO) /* 超时太多次？ */
{
switch (type)
{
case ID_START:
printf(">> 找不到服务器，重启认证!\n");
break;
case ID_IDENTITY:
printf(">> 发送用户名超时，重启认证!\n");
break;
case ID_CHALLENGE:
printf(">> 发送密码超时，重启认证!\n");
break;
case ID_WAITECHO:
printf(">> 等候响应包超时，自行响应!\n");
return switchState(ID_ECHO);
}
return restart();
}
switch (type)
{
case ID_DHCP:
return renewIP();
case ID_START:
return sendStartPacket();
case ID_IDENTITY:
return sendIdentityPacket();
case ID_CHALLENGE:
return sendChallengePacket();
case ID_WAITECHO: /* 塞尔的就不ping了，不好计时 */
return waitEchoPacket();
case ID_ECHO:
if (pingHost && sendCount*echoInterval > 60) { /* 1分钟左右 */
if (isOnline() == -1) {
printf(">> 认证掉线，开始重连!\n");
return switchState(ID_START);
}
sendCount = 1;
}
#ifndef NO_ARP
if (gateMAC[0] != 0xFE)
sendArpPacket();
#endif
return sendEchoPacket();
case ID_DISCONNECT:
return sendLogoffPacket();
}
return 0;
}
int restart()
{
if (startMode >= 3) /* 标记服务器地址为未获取 */
startMode -= 3;
state = ID_START;
sendCount = -1;
setTimer(restartWait); /* restartWait秒后或者服务器请求后重启认证 */
return 0;
}
static int renewIP()
{
setTimer(0); /* 取消定时器 */
printf(">> 正在获取IP...\n");
system(dhcpScript);
printf(">> 操作结束。\n");
dhcpMode += 3; /* 标记为已获取，123变为456，5不需再认证*/
if (fillHeader() == -1)
exit(EXIT_FAILURE);
if (dhcpMode == 5)
return switchState(ID_ECHO);
return switchState(ID_START);
}
static void fillEtherAddr(u_int32_t protocol)
{
memset(sendPacket, 0, 0x3E8);
memcpy(sendPacket, destMAC, 6);
memcpy(sendPacket+0x06, localMAC, 6);
*(u_int32_t *)(sendPacket+0x0C) = htonl(protocol);
}
static int sendStartPacket()
{
if (startMode%3 == 2) /* 赛尔 */
{
if (sendCount == 0)
{
printf(">> 寻找服务器...\n");
memcpy(sendPacket, STANDARD_ADDR, 6);
memcpy(sendPacket+0x06, localMAC, 6);
*(u_int32_t *)(sendPacket+0x0C) = htonl(0x888E0101);
*(u_int16_t *)(sendPacket+0x10) = 0;
memset(sendPacket+0x12, 0xa5, 42);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, 60);
}
if (sendCount == 0)
{
printf(">> 寻找服务器...\n");
fillStartPacket();
fillEtherAddr(0x888E0101);
memcpy(sendPacket+0x12, fillBuf, fillSize);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, 0x3E8);
}
static int sendIdentityPacket()
{
int nameLen = strlen(userName);
if (startMode%3 == 2) /* 赛尔 */
{
if (sendCount == 0)
{
printf(">> 发送用户名...\n");
*(u_int16_t *)(sendPacket+0x0E) = htons(0x0100);
*(u_int16_t *)(sendPacket+0x10) = *(u_int16_t *)(sendPacket+0x14) = htons(nameLen+30);
sendPacket[0x12] = 0x02;
sendPacket[0x16] = 0x01;
sendPacket[0x17] = 0x01;
fillCernetAddr(sendPacket);
memcpy(sendPacket+0x28, "03.02.05", 8);
memcpy(sendPacket+0x30, userName, nameLen);
setTimer(timeout);
}
sendPacket[0x13] = capBuf[0x13];
return pcap_sendpacket(hPcap, sendPacket, nameLen+48);
}
if (sendCount == 0)
{
printf(">> 发送用户名...\n");
fillEtherAddr(0x888E0100);
nameLen = strlen(userName);
*(u_int16_t *)(sendPacket+0x14) = *(u_int16_t *)(sendPacket+0x10) = htons(nameLen+5);
sendPacket[0x12] = 0x02;
sendPacket[0x13] = capBuf[0x13];
sendPacket[0x16] = 0x01;
memcpy(sendPacket+0x17, userName, nameLen);
memcpy(sendPacket+0x17+nameLen, fillBuf, fillSize);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, 0x3E8);
}
static int sendChallengePacket()
{
int nameLen = strlen(userName);
if (startMode%3 == 2) /* 赛尔 */
{
if (sendCount == 0)
{
printf(">> 发送密码...\n");
*(u_int16_t *)(sendPacket+0x0E) = htons(0x0100);
*(u_int16_t *)(sendPacket+0x10) = *(u_int16_t *)(sendPacket+0x14) = htons(nameLen+22);
sendPacket[0x12] = 0x02;
sendPacket[0x13] = capBuf[0x13];
sendPacket[0x16] = 0x04;
sendPacket[0x17] = 16;
memcpy(sendPacket+0x18, checkPass(capBuf[0x13], capBuf+0x18, capBuf[0x17]), 16);
memcpy(sendPacket+0x28, userName, nameLen);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, nameLen+40);
}
if (sendCount == 0)
{
printf(">> 发送密码...\n");
fillMd5Packet(capBuf+0x18);
fillEtherAddr(0x888E0100);
*(u_int16_t *)(sendPacket+0x14) = *(u_int16_t *)(sendPacket+0x10) = htons(nameLen+22);
sendPacket[0x12] = 0x02;
sendPacket[0x13] = capBuf[0x13];
sendPacket[0x16] = 0x04;
sendPacket[0x17] = 16;
memcpy(sendPacket+0x18, checkPass(capBuf[0x13], capBuf+0x18, capBuf[0x17]), 16);
memcpy(sendPacket+0x28, userName, nameLen);
memcpy(sendPacket+0x28+nameLen, fillBuf, fillSize);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, 0x3E8);
}
static int sendEchoPacket()
{
if (startMode%3 == 2) /* 赛尔 */
{
*(u_int16_t *)(sendPacket+0x0E) = htons(0x0106);
*(u_int16_t *)(sendPacket+0x10) = 0;
memset(sendPacket+0x12, 0xa5, 42);
switchState(ID_WAITECHO); /* 继续等待 */
return pcap_sendpacket(hPcap, sendPacket, 60);
}
if (sendCount == 0)
{
u_char echo[] =
{
0x00,0x1E,0xFF,0xFF,0x37,0x77,0x7F,0x9F,0xFF,0xFF,0xD9,0x13,0xFF,0xFF,0x37,0x77,
0x7F,0x9F,0xFF,0xFF,0xF7,0x2B,0xFF,0xFF,0x37,0x77,0x7F,0x3F,0xFF
};
printf(">> 发送心跳包以保持在线...\n");
fillEtherAddr(0x888E01BF);
memcpy(sendPacket+0x10, echo, sizeof(echo));
setTimer(echoInterval);
}
fillEchoPacket(sendPacket);
return pcap_sendpacket(hPcap, sendPacket, 0x2D);
}
static int sendLogoffPacket()
{
setTimer(0); /* 取消定时器 */
if (startMode%3 == 2) /* 赛尔 */
{
*(u_int16_t *)(sendPacket+0x0E) = htons(0x0102);
*(u_int16_t *)(sendPacket+0x10) = 0;
memset(sendPacket+0x12, 0xa5, 42);
return pcap_sendpacket(hPcap, sendPacket, 60);
}
fillStartPacket(); /* 锐捷的退出包与Start包类似，不过其实不这样也是没问题的 */
fillEtherAddr(0x888E0102);
memcpy(sendPacket+0x12, fillBuf, fillSize);
return pcap_sendpacket(hPcap, sendPacket, 0x3E8);
}
static int waitEchoPacket()
{
if (sendCount == 0)
setTimer(echoInterval);
return 0;
}
#ifndef NO_ARP
static void sendArpPacket()
{
u_char arpPacket[0x3C] = {
0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x06,0x00,0x01,
0x08,0x00,0x06,0x04,0x00};
if (gateMAC[0] != 0xFF) {
memcpy(arpPacket, gateMAC, 6);
memcpy(arpPacket+0x06, localMAC, 6);
arpPacket[0x15]=0x02;
memcpy(arpPacket+0x16, localMAC, 6);
memcpy(arpPacket+0x1c, &rip, 4);
memcpy(arpPacket+0x20, gateMAC, 6);
memcpy(arpPacket+0x26, &gateway, 4);
pcap_sendpacket(hPcap, arpPacket, 0x3C);
}
memset(arpPacket, 0xFF, 6);
memcpy(arpPacket+0x06, localMAC, 6);
arpPacket[0x15]=0x01;
memcpy(arpPacket+0x16, localMAC, 6);
memcpy(arpPacket+0x1c, &rip, 4);
memset(arpPacket+0x20, 0, 6);
memcpy(arpPacket+0x26, &gateway, 4);
pcap_sendpacket(hPcap, arpPacket, 0x2A);
}
#endif
================================================
FILE: src/mystate.h
================================================
/*
* Copyright (C) 2009, HustMoon Studio
*
* 文件名称：mystate.h
* 摘 要：改变认证状态
* 作 者：HustMoon@BYHH
*/
#ifndef HUSTMOON_MYSTATE_H
#define HUSTMOON_MYSTATE_H
#define ID_DISCONNECT 0 /* 断开状态 */
#define ID_START 1 /* 寻找服务器 */
#define ID_IDENTITY 2 /* 发送用户名 */
#define ID_CHALLENGE 3 /* 发送密码 */
#define ID_ECHO 4 /* 发送心跳包 */
#define ID_DHCP 5 /* 更新IP */
#define ID_WAITECHO 6 /* 等待心跳包 */
int switchState(int type); /* 改变状态 */
int restart(); /* 重启认证 */
#endif
================================================
FILE: src/strnormalize.c
================================================
#include "strnormalize.h"
#include <stdlib.h>
#define SWAPBYTE(x) (((unsigned short)(x) >> 8) | (unsigned short)(x) << 8)
#define COMPBYTE(x, y) ((unsigned char)(x) << 8 | (unsigned char)(y))
static const unsigned short *_pTrad2Simp_gbk;
static const unsigned short *_pTrad2Simp_utf16;
static const unsigned short *_pPlain_gbk;
static const unsigned short *_pPlain_utf16;
static const char *_pUpper2Lower;
static const char *_pLower2Upper;
static const char *_pPlain;
static const unsigned short *_pGbk2Utf16;
static const unsigned short *_pUtf162Gbk;
static const unsigned short *_pTns;
static unsigned short _tns_size;
static const unsigned short *_pGbk2utf16_2;
static unsigned short _gbk2utf16_2_size;
static const unsigned short *_pGbk2utf16_3;
static unsigned short _gbk2utf16_3_size;
const unsigned short *_initTns();
const unsigned short *_initGbk2utf16_2();
const unsigned short *_initGbk2utf16_3();
const unsigned short *_initTrad2Simp_utf16();
const unsigned short *_initTrad2Simp_gbk();
const unsigned short *_initPlain_utf16();
const unsigned short *_initPlain_gbk();
const char *_initUpper2Lower();
const char *_initLower2Upper();
const char *_initPlain();
const unsigned short *_initGbk2Utf16();
const unsigned short *_initUtf162Gbk();
void str_normalize_init()
{
_pTns = _initTns();
_pGbk2utf16_2 = _initGbk2utf16_2();
_pGbk2utf16_3 = _initGbk2utf16_3();
_pTrad2Simp_gbk = _initTrad2Simp_gbk();
_pTrad2Simp_utf16 = _initTrad2Simp_utf16();
_pPlain_gbk = _initPlain_gbk();
_pPlain_utf16 = _initPlain_utf16();
_pUpper2Lower = _initUpper2Lower();
_pLower2Upper = _initLower2Upper();
_pPlain = _initPlain();
_pGbk2Utf16 = _initGbk2Utf16();
_pUtf162Gbk = _initUtf162Gbk();
}
const unsigned short *_initTns()
{
static const unsigned short _tns[] =
{
0x8147 /* 丟 */, 0xB6AA /* 丢 */, // {{{ Simplified-Traditional table
0x814B /* 並 */, 0xB2A2 /* 并 */,
0x8179 /* 亂 */, 0xC2D2 /* 乱 */,
0x8183 /* 亙 */, 0xD8A8 /* 亘 */,
0x8186 /* 亞 */, 0xD1C7 /* 亚 */,
0x81B2 /* 伈 */, 0xD0C4 /* 心 */,
0x81B8 /* 伕 */, 0xB7F2 /* 夫 */,
0x81D0 /* 佇 */, 0xD8F9 /* 伫 */,
0x81D1 /* 佈 */, 0xB2BC /* 布 */,
0x81D7 /* 佔 */, 0xD5BC /* 占 */,
0x81E3 /* 併 */, 0xB2A2 /* 并 */,
0x81ED /* 來 */, 0xC0B4 /* 来 */,
0x81F6 /* 侖 */, 0xC2D8 /* 仑 */,
0x81F9 /* 侚 */, 0xE1DF /* 徇 */,
0x8248 /* 侶 */, 0xC2C2 /* 侣 */,
0x8249 /* 侷 */, 0xBED6 /* 局 */,
0x8252 /* 俁 */, 0xD9B6 /* 俣 */,
0x8253 /* 係 */, 0xCFB5 /* 系 */,
0x8262 /* 俠 */, 0xCFC0 /* 侠 */,
0x826C /* 俵 */, 0xB1ED /* 表 */,
0x8274 /* 倀 */, 0xD8F6 /* 伥 */,
0x827A /* 倆 */, 0xC1A9 /* 俩 */,
0x827D /* 倉 */, 0xB2D6 /* 仓 */,
0x8280 /* 個 */, 0xB8F6 /* 个 */,
0x8283 /* 們 */, 0xC3C7 /* 们 */,
0x8286 /* 倖 */, 0xD0D2 /* 幸 */,
0x828D /* 倣 */, 0xB7C2 /* 仿 */,
0x8290 /* 倫 */, 0xC2D7 /* 伦 */,
0x82A5 /* 偉 */, 0xCEB0 /* 伟 */,
0x82BF /* 偪 */, 0xB1C6 /* 逼 */,
0x82C8 /* 側 */, 0xB2E0 /* 侧 */,
0x82C9 /* 偵 */, 0xD5EC /* 侦 */,
0x82CA /* 偸 */, 0xCDB5 /* 偷 */,
0x82CC /* 偺 */, 0xD4DB /* 咱 */,
0x82CE /* 偽 */, 0xCEB1 /* 伪 */,
0x82DC /* 傑 */, 0xBDDC /* 杰 */,
0x82E1 /* 傖 */, 0xD8F7 /* 伧 */,
0x82E3 /* 傘 */, 0xC9A1 /* 伞 */,
0x82E4 /* 備 */, 0xB1B8 /* 备 */,
0x82E5 /* 傚 */, 0xD0A7 /* 效 */,
0x82ED /* 傢 */, 0xBCD2 /* 家 */,
0x82F2 /* 傭 */, 0xD3B6 /* 佣 */,
0x82F4 /* 傯 */, 0xD9CC /* 偬 */,
0x82F7 /* 傳 */, 0xB4AB /* 传 */,
0x82F8 /* 傴 */, 0xD8F1 /* 伛 */,
0x82F9 /* 債 */, 0xD5AE /* 债 */,
0x82FB /* 傷 */, 0xC9CB /* 伤 */,
0x8341 /* 傾 */, 0xC7E3 /* 倾 */,
0x8345 /* 僂 */, 0xD9CD /* 偻 */,
0x8348 /* 僅 */, 0xBDF6 /* 仅 */,
0x834C /* 僉 */, 0xD9DD /* 佥 */,
0x834D /* 僊 */, 0xCFC9 /* 仙 */,
0x8353 /* 僑 */, 0xC7C8 /* 侨 */,
0x8357 /* 僕 */, 0xC6CD /* 仆 */,
0x835E /* 僞 */, 0xCEB1 /* 伪 */,
0x8365 /* 僥 */, 0xBDC4 /* 侥 */,
0x8366 /* 僨 */, 0xD9C7 /* 偾 */,
0x836C /* 僱 */, 0xB9CD /* 雇 */,
0x8372 /* 價 */, 0xBCDB /* 价 */,
0x8378 /* 儀 */, 0xD2C7 /* 仪 */,
0x837A /* 儂 */, 0xD9AF /* 侬 */,
0x837C /* 億 */, 0xD2DA /* 亿 */,
0x837D /* 儅 */, 0xB5B1 /* 当 */,
0x837E /* 儈 */, 0xBFEB /* 侩 */,
0x8380 /* 儉 */, 0xBCF3 /* 俭 */,
0x8386 /* 儐 */, 0xD9CF /* 傧 */,
0x8389 /* 儔 */, 0xD9B1 /* 俦 */,
0x838A /* 儕 */, 0xD9AD /* 侪 */,
0x838D /* 儘 */, 0xBEA1 /* 尽 */,
0x8394 /* 償 */, 0xB3A5 /* 偿 */,
0x839E /* 優 */, 0xD3C5 /* 优 */,
0x83A6 /* 儲 */, 0xB4A2 /* 储 */,
0x83A7 /* 儳 */, 0xB2F6 /* 馋 */,
0x83AB /* 儷 */, 0xD9B3 /* 俪 */,
0x83AC /* 儸 */, 0xC2DE /* 罗 */,
0x83AD /* 儹 */, 0xD4DC /* 攒 */,
0x83AE /* 儺 */, 0xD9D0 /* 傩 */,
0x83AF /* 儻 */, 0xD9CE /* 傥 */,
0x83B0 /* 儼 */, 0xD9B2 /* 俨 */,
0x83B4 /* 兇 */, 0xD0D7 /* 凶 */,
0x83B6 /* 兌 */, 0xB6D2 /* 兑 */,
0x83BA /* 兒 */, 0xB6F9 /* 儿 */,
0x83BC /* 兗 */, 0xD9F0 /* 兖 */,
0x83C8 /* 內 */, 0xC4DA /* 内 */,
0x83C9 /* 兩 */, 0xC1BD /* 两 */,
0x83D4 /* 冊 */, 0xB2E1 /* 册 */,
0x83D9 /* 冑 */, 0xEBD0 /* 胄 */,
0x83E7 /* 冪 */, 0xC3DD /* 幂 */,
0x83F2 /* 凃 */, 0xCDBF /* 涂 */,
0x83F3 /* 凅 */, 0xB9CC /* 固 */,
0x83F4 /* 凈 */, 0xBEBB /* 净 */,
0x83F6 /* 凍 */, 0xB6B3 /* 冻 */,
0x8443 /* 凜 */, 0xC1DD /* 凛 */,
0x8445 /* 凟 */, 0xE4C2 /* 渎 */,
0x8449 /* 処 */, 0xB4A6 /* 处 */,
0x8450 /* 凱 */, 0xBFAD /* 凯 */,
0x8452 /* 凴 */, 0xC6BE /* 凭 */,
0x8465 /* 別 */, 0xB1F0 /* 别 */,
0x8468 /* 刪 */, 0xC9BE /* 删 */,
0x8471 /* 剄 */, 0xD8D9 /* 刭 */,
0x8474 /* 則 */, 0xD4F2 /* 则 */,
0x8476 /* 剉 */, 0xEFB1 /* 锉 */,
0x8477 /* 剋 */, 0xBFCB /* 克 */,
0x8478 /* 剎 */, 0xC9B2 /* 刹 */,
0x847D /* 剗 */, 0x8469 /* 刬 */,
0x8482 /* 剛 */, 0xB8D5 /* 刚 */,
0x8483 /* 剝 */, 0xB0FE /* 剥 */,
0x848E /* 剮 */, 0xB9D0 /* 剐 */,
0x8492 /* 剴 */, 0xD8DC /* 剀 */,
0x8493 /* 創 */, 0xB4B4 /* 创 */,
0x8495 /* 剷 */, 0xB2F9 /* 铲 */,
0x849D /* 劃 */, 0xBBAE /* 划 */,
0x849E /* 劄 */, 0xD4FD /* 札 */,
0x84A1 /* 劇 */, 0xBEE7 /* 剧 */,
0x84A2 /* 劉 */, 0xC1F5 /* 刘 */,
0x84A3 /* 劊 */, 0xB9F4 /* 刽 */,
0x84A5 /* 劌 */, 0xD8DB /* 刿 */,
0x84A6 /* 劍 */, 0xBDA3 /* 剑 */,
0x84A9 /* 劑 */, 0xBCC1 /* 剂 */,
0x84AA /* 劒 */, 0xBDA3 /* 剑 */,
0x84C5 /* 勁 */, 0xBEA2 /* 劲 */,
0x84CD /* 勍 */, 0xC7E6 /* 擎 */,
0x84D3 /* 動 */, 0xB6AF /* 动 */,
0x84D4 /* 勗 */, 0xDBC3 /* 勖 */,
0x84D5 /* 務 */, 0xCEF1 /* 务 */,
0x84D7 /* 勛 */, 0xD1AB /* 勋 */,
0x84D9 /* 勝 */, 0xCAA4 /* 胜 */,
0x84DA /* 勞 */, 0xC0CD /* 劳 */,
0x84DD /* 勢 */, 0xCAC6 /* 势 */,
0x84DE /* 勣 */, 0xBCA8 /* 绩 */,
0x84E0 /* 勦 */, 0xBDCB /* 剿 */,
0x84E3 /* 勩 */, 0x84D6 /* 勚 */,
0x84EA /* 勱 */, 0xDBBD /* 劢 */,
0x84EC /* 勳 */, 0xD1AB /* 勋 */,
0x84EE /* 勵 */, 0xC0F8 /* 励 */,
0x84F1 /* 勸 */, 0xC8B0 /* 劝 */,
0x84F2 /* 勻 */, 0xD4C8 /* 匀 */,
0x84FC /* 匋 */, 0xCCD5 /* 陶 */,
0x8551 /* 匭 */, 0xD8D0 /* 匦 */,
0x8552 /* 匯 */, 0xBBE3 /* 汇 */,
0x8554 /* 匱 */, 0xD8D1 /* 匮 */,
0x8555 /* 匲 */, 0xDEC6 /* 奁 */,
0x8556 /* 匳 */, 0xDEC6 /* 奁 */,
0x8558 /* 匵 */, 0xE8FC /* 椟 */,
0x855E /* 區 */, 0xC7F8 /* 区 */,
0x8564 /* 卍 */, 0xCDF2 /* 万 */,
0x8566 /* 協 */, 0xD0AD /* 协 */,
0x856E /* 卬 */, 0xB0BA /* 昂 */,
0x8572 /* 卹 */, 0xD0F4 /* 恤 */,
0x8573 /* 卻 */, 0xC8B4 /* 却 */,
0x8587 /* 厙 */, 0xD8C7 /* 厍 */,
0x8588 /* 厛 */, 0xCCFC /* 厅 */,
0x858B /* 厠 */, 0xB2DE /* 厕 */,
0x858D /* 厤 */, 0xC0FA /* 历 */,
0x8592 /* 厭 */, 0xD1E1 /* 厌 */,
0x8594 /* 厰 */, 0xB3A7 /* 厂 */,
0x8596 /* 厲 */, 0xC0F7 /* 厉 */,
0x8598 /* 厴 */, 0xD8C9 /* 厣 */,
0x85A2 /* 參 */, 0xB2CE /* 参 */,
0x85B2 /* 叢 */, 0xB4D4 /* 丛 */,
0x85BC /* 吋 */, 0xB4E7 /* 寸 */,
0x85C7 /* 吳 */, 0xCEE2 /* 吴 */,
0x85C8 /* 吶 */, 0xC4C5 /* 呐 */,
0x85CE /* 呂 */, 0xC2C0 /* 吕 */,
0x85D5 /* 呎 */, 0xB3DF /* 尺 */,
0x8647 /* 咷 */, 0xDFFB /* 啕 */,
0x864A /* 咼 */, 0xDFC3 /* 呙 */,
0x8654 /* 員 */, 0xD4B1 /* 员 */,
0x8655 /* 哢 */, 0xDFC7 /* 咔 */,
0x8668 /* 唄 */, 0xDFC2 /* 呗 */,
0x8672 /* 唕 */, 0xDFF0 /* 唣 */,
0x8677 /* 唚 */, 0xDFC4 /* 吣 */,
0x8688 /* 唸 */, 0xC4EE /* 念 */,
0x8696 /* 問 */, 0xCECA /* 问 */,
0x8699 /* 啓 */, 0xC6F4 /* 启 */,
0x869B /* 啗 */, 0xE0A2 /* 啖 */,
0x86A1 /* 啞 */, 0xD1C6 /* 哑 */,
0x86A2 /* 啟 */, 0xC6F4 /* 启 */,
0x86A4 /* 啢 */, 0x867C /* 唡 */,
0x86A5 /* 啣 */, 0xCFCE /* 衔 */,
0x86B9 /* 喒 */, 0xD4DB /* 咱 */,
0x86BE /* 喚 */, 0xBBBD /* 唤 */,
0x86C7 /* 喦 */, 0xD1D2 /* 岩 */,
0x86CA /* 喪 */, 0xC9A5 /* 丧 */,
0x86CB /* 喫 */, 0xB3D4 /* 吃 */,
0x86CC /* 喬 */, 0xC7C7 /* 乔 */,
0x86CE /* 單 */, 0xB5A5 /* 单 */,
0x86D1 /* 喲 */, 0xD3B4 /* 哟 */,
0x86DC /* 嗆 */, 0xC7BA /* 呛 */,
0x86DD /* 嗇 */, 0xD8C4 /* 啬 */,
0x86DF /* 嗊 */, 0x8679 /* 唝 */,
0x86E1 /* 嗎 */, 0xC2F0 /* 吗 */,
0x86E8 /* 嗚 */, 0xCED8 /* 呜 */,
0x86EE /* 嗩 */, 0xDFEF /* 唢 */,
0x86F4 /* 嗶 */, 0xDFD9 /* 哔 */,
0x8740 /* 嘆 */, 0xCCBE /* 叹 */,
0x8744 /* 嘍 */, 0xE0B6 /* 喽 */,
0x8749 /* 嘔 */, 0xC5BB /* 呕 */,
0x874B /* 嘖 */, 0xDFF5 /* 啧 */,
0x874C /* 嘗 */, 0xB3A2 /* 尝 */,
0x874F /* 嘜 */, 0xDFE9 /* 唛 */,
0x8757 /* 嘩 */, 0xBBA9 /* 哗 */,
0x875A /* 嘮 */, 0xDFEB /* 唠 */,
0x875B /* 嘯 */, 0xD0A5 /* 啸 */,
0x875C /* 嘰 */, 0xDFB4 /* 叽 */,
0x875E /* 嘵 */, 0xDFD8 /* 哓 */,
0x8760 /* 嘸 */, 0xDFBC /* 呒 */,
0x8763 /* 嘽 */, 0x86AE /* 啴 */,
0x8766 /* 噁 */, 0xB6F1 /* 恶 */,
0x876A /* 噅 */, 0xDFD4 /* 咴 */,
0x8775 /* 噓 */, 0xD0EA /* 嘘 */,
0x8778 /* 噚 */, 0xD1B0 /* 寻 */,
0x877A /* 噝 */, 0xDFD0 /* 咝 */,
0x877D /* 噠 */, 0xDFD5 /* 哒 */,
0x8781 /* 噥 */, 0xDFE6 /* 哝 */,
0x8782 /* 噦 */, 0xDFDC /* 哕 */,
0x8786 /* 噯 */, 0xE0C8 /* 嗳 */,
0x8788 /* 噲 */, 0xDFE0 /* 哙 */,
0x878A /* 噴 */, 0xC5E7 /* 喷 */,
0x878D /* 噸 */, 0xB6D6 /* 吨 */,
0x878E /* 噹 */, 0xB5B1 /* 当 */,
0x8793 /* 嚀 */, 0xDFCC /* 咛 */,
0x8798 /* 嚇 */, 0xCFC5 /* 吓 */,
0x879D /* 嚌 */, 0xDFE2 /* 哜 */,
0x879F /* 嚐 */, 0xB3A2 /* 尝 */,
0x87A3 /* 嚕 */, 0xE0E0 /* 噜 */,
0x87A7 /* 嚙 */, 0xC4F6 /* 啮 */,
0x87B2 /* 嚥 */, 0xD1CA /* 咽 */,
0x87B3 /* 嚦 */, 0xDFBF /* 呖 */,
0x87B5 /* 嚨 */, 0xC1FC /* 咙 */,
0x87BB /* 嚮 */, 0xCFF2 /* 向 */,
0x87BE /* 嚲 */, 0x818F /* 亸 */,
0x87BF /* 嚳 */, 0xE0B7 /* 喾 */,
0x87C0 /* 嚴 */, 0xD1CF /* 严 */,
0x87C2 /* 嚶 */, 0xE0D3 /* 嘤 */,
0x87C6 /* 嚻 */, 0xCFF9 /* 嚣 */,
0x87CA /* 囀 */, 0xDFF9 /* 啭 */,
0x87CB /* 囁 */, 0xE0BF /* 嗫 */,
0x87CC /* 囂 */, 0xCFF9 /* 嚣 */,
0x87CF /* 囅 */, 0xD9E6 /* 冁 */,
0x87D2 /* 囈 */, 0xDFBD /* 呓 */,
0x87D3 /* 囉 */, 0x86AA /* 啰 */,
0x87D5 /* 囌 */, 0xCBD5 /* 苏 */,
0x87DA /* 囑 */, 0xD6F6 /* 嘱 */,
0x87DF /* 囘 */, 0xBBD8 /* 回 */,
0x87E8 /* 囪 */, 0xB4D1 /* 囱 */,
0x87E9 /* 囬 */, 0xBBD8 /* 回 */,
0x87EB /* 囯 */, 0xB9FA /* 国 */,
0x87F7 /* 圇 */, 0xE0F0 /* 囵 */,
0x87F8 /* 國 */, 0xB9FA /* 国 */,
0x87FA /* 圍 */, 0xCEA7 /* 围 */,
0x8840 /* 園 */, 0xD4B0 /* 园 */,
0x8841 /* 圓 */, 0xD4B2 /* 圆 */,
0x8844 /* 圖 */, 0xCDBC /* 图 */,
0x8846 /* 團 */, 0xCDC5 /* 团 */,
0x8873 /* 坰 */, 0xDBF0 /* 垧 */,
0x8877 /* 坵 */, 0xC7F0 /* 丘 */,
0x889D /* 垵 */, 0xDBFB /* 埯 */,
0x88A2 /* 垻 */, 0xB0D3 /* 坝 */,
0x88BA /* 埡 */, 0xDBEB /* 垭 */,
0x88C6 /* 埰 */, 0xB2C9 /* 采 */,
0x88CC /* 執 */, 0xD6B4 /* 执 */,
0x88D4 /* 堅 */, 0xBCE1 /* 坚 */,
0x88D7 /* 堊 */, 0xDBD1 /* 垩 */,
0x88DF /* 堖 */, 0xDBF1 /* 垴 */,
0x88E5 /* 堝 */, 0xDBF6 /* 埚 */,
0x88EA /* 堦 */, 0xBDD7 /* 阶 */,
0x88F2 /* 堯 */, 0xD2A2 /* 尧 */,
0x88F3 /* 報 */, 0xB1A8 /* 报 */,
0x88F6 /* 場 */, 0xB3A1 /* 场 */,
0x8941 /* 堿 */, 0xBCEE /* 碱 */,
0x894B /* 塊 */, 0xBFE9 /* 块 */,
0x894C /* 塋 */, 0xDCE3 /* 茔 */,
0x894E /* 塏 */, 0xDBEE /* 垲 */,
0x8950 /* 塒 */, 0xDBF5 /* 埘 */,
0x8954 /* 塗 */, 0xCDBF /* 涂 */,
0x8956 /* 塚 */, 0xDAA3 /* 冢 */,
0x895D /* 塢 */, 0xCEEB /* 坞 */,
0x895F /* 塤 */, 0xDBF7 /* 埙 */,
0x8965 /* 塭 */, 0xCEC1 /* 瘟 */,
0x896A /* 塲 */, 0xB3A1 /* 场 */,
0x896D /* 塵 */, 0xB3BE /* 尘 */,
0x8971 /* 塹 */, 0xC7B5 /* 堑 */,
0x8974 /* 塼 */, 0xD7A9 /* 砖 */,
0x897C /* 墊 */, 0xB5E6 /* 垫 */,
0x8984 /* 墑 */, 0xC9CA /* 墒 */,
0x898B /* 墜 */, 0xD7B9 /* 坠 */,
0x898C /* 墝 */, 0xEDCD /* 硗 */,
0x8999 /* 墮 */, 0xB6E9 /* 堕 */,
0x899B /* 墰 */, 0xCCB3 /* 坛 */,
0x899E /* 墳 */, 0xB7D8 /* 坟 */,
0x89A1 /* 墶 */, 0x8899 /* 垯 */,
0x89A6 /* 墻 */, 0xC7BD /* 墙 */,
0x89A8 /* 墾 */, 0xBFD1 /* 垦 */,
0x89AF /* 壇 */, 0xCCB3 /* 坛 */,
0x89B3 /* 壋 */, 0x889B /* 垱 */,
0x89B6 /* 壎 */, 0xDBF7 /* 埙 */,
0x89BA /* 壓 */, 0xD1B9 /* 压 */,
0x89BE /* 壘 */, 0xC0DD /* 垒 */,
0x89BF /* 壙 */, 0xDBDB /* 圹 */,
0x89C0 /* 壚 */, 0xDBE4 /* 垆 */,
0x89C2 /* 壜 */, 0xCCB3 /* 坛 */,
0x89C4 /* 壞 */, 0xBBB5 /* 坏 */,
0x89C5 /* 壟 */, 0xC2A2 /* 垄 */,
0x89C6 /* 壠 */, 0xC2A2 /* 垄 */,
0x89C8 /* 壢 */, 0xDBDE /* 坜 */,
0x89CE /* 壩 */, 0xB0D3 /* 坝 */,
0x89CF /* 壪 */, 0x8947 /* 塆 */,
0x89D1 /* 壯 */, 0xD7B3 /* 壮 */,
0x89D8 /* 壺 */, 0xBAF8 /* 壶 */,
0x89DA /* 壼 */, 0x89D7 /* 壸 */,
0x89DB /* 壽 */, 0xCAD9 /* 寿 */,
0x89DE /* 夀 */, 0xCAD9 /* 寿 */,
0x89F2 /* 夠 */, 0xB9BB /* 够 */,
0x89F4 /* 夢 */, 0xC3CE /* 梦 */,
0x8A41 /* 夾 */, 0xBCD0 /* 夹 */,
0x8A4A /* 奐 */, 0xDBBC /* 奂 */,
0x8A57 /* 奧 */, 0xB0C2 /* 奥 */,
0x8A59 /* 奩 */, 0xDEC6 /* 奁 */,
0x8A5A /* 奪 */, 0xB6E1 /* 夺 */,
0x8A5C /* 奬 */, 0xBDB1 /* 奖 */,
0x8A5E /* 奮 */, 0xB7DC /* 奋 */,
0x8A79 /* 妝 */, 0xD7B1 /* 妆 */,
0x8A85 /* 妳 */, 0xC4E3 /* 你 */,
0x8A8B /* 妺 */, 0xC4A9 /* 末 */,
0x8A99 /* 姍 */, 0xE6A9 /* 姗 */,
0x8AA6 /* 姦 */, 0xBCE9 /* 奸 */,
0x8AA9 /* 姪 */, 0xD6B6 /* 侄 */,
0x8AB7 /* 姺 */, 0xCFB3 /* 铣 */,
0x8ACA /* 娛 */, 0xD3E9 /* 娱 */,
0x8AD5 /* 娬 */, 0xE5FC /* 妩 */,
0x8AE4 /* 婁 */, 0xC2A6 /* 娄 */,
0x8B44 /* 婦 */, 0xB8BE /* 妇 */,
0x8B48 /* 婬 */, 0xD2F9 /* 淫 */,
0x8B49 /* 婭 */, 0xE6AB /* 娅 */,
0x8B7A /* 媧 */, 0xE6B4 /* 娲 */,
0x8B81 /* 媮 */, 0xCDB5 /* 偷 */,
0x8B82 /* 媯 */, 0xE6A3 /* 妫 */,
0x8B8B /* 媼 */, 0xE6C1 /* 媪 */,
0x8B8C /* 媽 */, 0xC2E8 /* 妈 */,
0x8B96 /* 嫋 */, 0xF4C1 /* 袅 */,
0x8B9E /* 嫗 */, 0xE5FD /* 妪 */,
0x8BB3 /* 嫵 */, 0xE5FC /* 妩 */,
0x8BB8 /* 嫺 */, 0xE6B5 /* 娴 */,
0x8BB9 /* 嫻 */, 0xE6B5 /* 娴 */,
0x8BBD /* 嫿 */, 0x8B4F /* 婳 */,
0x8BBE /* 嬀 */, 0xE6A3 /* 妫 */,
0x8BC6 /* 嬈 */, 0xE6AC /* 娆 */,
0x8BC8 /* 嬋 */, 0xE6BF /* 婵 */,
0x8BC9 /* 嬌 */, 0xBDBF /* 娇 */,
0x8BD4 /* 嬙 */, 0xE6CD /* 嫱 */,
0x8BD8 /* 嬝 */, 0xF4C1 /* 袅 */,
0x8BDC /* 嬡 */, 0xE6C8 /* 嫒 */,
0x8BDF /* 嬤 */, 0xE6D6 /* 嬷 */,
0x8BE5 /* 嬪 */, 0xE6C9 /* 嫔 */,
0x8BE8 /* 嬭 */, 0xC4CC /* 奶 */,
0x8BEB /* 嬰 */, 0xD3A4 /* 婴 */,
0x8BF0 /* 嬸 */, 0xC9F4 /* 婶 */,
0x8BF6 /* 嬾 */, 0xC0C1 /* 懒 */,
0x8BFA /* 孃 */, 0xC4EF /* 娘 */,
0x8C44 /* 孌 */, 0xE6AE /* 娈 */,
0x8C4F /* 孫 */, 0xCBEF /* 孙 */,
0x8C57 /* 學 */, 0xD1A7 /* 学 */,
0x8C5C /* 孿 */, 0xC2CF /* 孪 */,
0x8C6D /* 宮 */, 0xB9AC /* 宫 */,
0x8C8B /* 寢 */, 0xC7DE /* 寝 */,
0x8C8D /* 實 */, 0xCAB5 /* 实 */,
0x8C8E /* 寧 */, 0xC4FE /* 宁 */,
0x8C8F /* 審 */, 0xC9F3 /* 审 */,
0x8C91 /* 寫 */, 0xD0B4 /* 写 */,
0x8C92 /* 寬 */, 0xBFED /* 宽 */,
0x8C99 /* 寵 */, 0xB3E8 /* 宠 */,
0x8C9A /* 寶 */, 0xB1A6 /* 宝 */,
0x8CA1 /* 尅 */, 0xBFCB /* 克 */,
0x8CA2 /* 將 */, 0xBDAB /* 将 */,
0x8CA3 /* 專 */, 0xD7A8 /* 专 */,
0x8CA4 /* 尋 */, 0xD1B0 /* 寻 */,
0x8CA6 /* 對 */, 0xB6D4 /* 对 */,
0x8CA7 /* 導 */, 0xB5BC /* 导 */,
0x8CBC /* 尲 */, 0xDECF /* 尴 */,
0x8CC0 /* 尷 */, 0xDECF /* 尴 */,
0x8CC3 /* 屆 */, 0xBDEC /* 届 */,
0x8CC6 /* 屍 */, 0xCAAC /* 尸 */,
0x8CC8 /* 屓 */, 0x8CC1 /* 屃 */,
0x8CCF /* 屜 */, 0xCCEB /* 屉 */,
0x8CD2 /* 屢 */, 0xC2C5 /* 屡 */,
0x8CD3 /* 層 */, 0xB2E3 /* 层 */,
0x8CD5 /* 屨 */, 0xE5F0 /* 屦 */,
0x8CD9 /* 屬 */, 0xCAF4 /* 属 */,
0x8CDA /* 屭 */, 0x8CC1 /* 屃 */,
0x8CF9 /* 岡 */, 0xB8D4 /* 冈 */,
0x8D51 /* 峇 */, 0xBFC6 /* 科 */,
0x8D73 /* 峴 */, 0xE1AD /* 岘 */,
0x8D75 /* 島 */, 0xB5BA /* 岛 */,
0x8D7B /* 峽 */, 0xCFBF /* 峡 */,
0x8D88 /* 崍 */, 0xE1C1 /* 崃 */,
0x8D8A /* 崐 */, 0xC0A5 /* 昆 */,
0x8D8B /* 崑 */, 0xC0A5 /* 昆 */,
0x8D8F /* 崗 */, 0xB8DA /* 岗 */,
0x8D91 /* 崙 */, 0xC2D8 /* 仑 */,
0x8D96 /* 崠 */, 0xE1B4 /* 岽 */,
0x8D98 /* 崢 */, 0xE1BF /* 峥 */,
0x8D9E /* 崬 */, 0xE1B4 /* 岽 */,
0x8DA3 /* 崳 */, 0xE1CE /* 嵛 */,
0x8DB9 /* 嵐 */, 0xE1B0 /* 岚 */,
0x8DC0 /* 嵗 */, 0xCBEA /* 岁 */,
0x8DE2 /* 嶁 */, 0xE1D0 /* 嵝 */,
0x8DE4 /* 嶄 */, 0xD5B8 /* 崭 */,
0x8DE7 /* 嶇 */, 0xE1AB /* 岖 */,
0x8DF4 /* 嶔 */, 0x8DC2 /* 嵚 */,
0x8DF7 /* 嶗 */, 0xE1C0 /* 崂 */,
0x8DFE /* 嶠 */, 0xE1BD /* 峤 */,
0x8E41 /* 嶢 */, 0x8D69 /* 峣 */,
0x8E46 /* 嶧 */, 0xE1BB /* 峄 */,
0x8E47 /* 嶨 */, 0x8D4E /* 峃 */,
0x8E4D /* 嶮 */, 0x8D81 /* 崄 */,
0x8E53 /* 嶴 */, 0xE1AE /* 岙 */,
0x8E56 /* 嶸 */, 0xE1C9 /* 嵘 */,
0x8E58 /* 嶺 */, 0xC1EB /* 岭 */,
0x8E5A /* 嶼 */, 0xD3EC /* 屿 */,
0x8E5B /* 嶽 */, 0xD4C0 /* 岳 */,
0x8E68 /* 巋 */, 0xBFF9 /* 岿 */,
0x8E6E /* 巒 */, 0xC2CD /* 峦 */,
0x8E70 /* 巔 */, 0xE1DB /* 巅 */,
0x8E72 /* 巖 */, 0xD1D2 /* 岩 */,
0x8E80 /* 巰 */, 0xDBCF /* 巯 */,
0x8E84 /* 巹 */, 0xDAE1 /* 卺 */,
0x8E9B /* 帥 */, 0xCBA7 /* 帅 */,
0x8E9F /* 師 */, 0xCAA6 /* 师 */,
0x8EA4 /* 帳 */, 0xD5CA /* 帐 */,
0x8EA7 /* 帶 */, 0xB4F8 /* 带 */,
0x8EAC /* 幀 */, 0xD6A1 /* 帧 */,
0x8EAE /* 幃 */, 0xE0F8 /* 帏 */,
0x8EBD /* 幗 */, 0xE0FE /* 帼 */,
0x8EBE /* 幘 */, 0xE0FD /* 帻 */,
0x8EC3 /* 幟 */, 0xD6C4 /* 帜 */,
0x8EC5 /* 幣 */, 0xB1D2 /* 币 */,
0x8ECD /* 幫 */, 0xB0EF /* 帮 */,
0x8ECE /* 幬 */, 0xE0FC /* 帱 */,
0x8ED3 /* 幱 */, 0xD25B /* 襕 */,
0x8ED4 /* 幵 */, 0xBFAA /* 开 */,
0x8ED6 /* 幹 */, 0xB8C9 /* 干 */,
0x8ED7 /* 幾 */, 0xBCB8 /* 几 */,
0x8EE3 /* 庛 */, 0xB4C3 /* 疵 */,
0x8EEC /* 庫 */, 0xBFE2 /* 库 */,
0x8EFA /* 廁 */, 0xB2DE /* 厕 */,
0x8EFB /* 廂 */, 0xCFE1 /* 厢 */,
0x8EFD /* 廄 */, 0xBEC7 /* 厩 */,
0x8F42 /* 廈 */, 0xCFC3 /* 厦 */,
0x8F46 /* 廎 */, 0x8EF6 /* 庼 */,
0x8F4A /* 廕 */, 0xD2F1 /* 荫 */,
0x8F4E /* 廚 */, 0xB3F8 /* 厨 */,
0x8F50 /* 廝 */, 0xD8CB /* 厮 */,
0x8F52 /* 廟 */, 0xC3ED /* 庙 */,
0x8F53 /* 廠 */, 0xB3A7 /* 厂 */,
0x8F54 /* 廡 */, 0xE2D0 /* 庑 */,
0x8F55 /* 廢 */, 0xB7CF /* 废 */,
0x8F56 /* 廣 */, 0xB9E3 /* 广 */,
0x8F5B /* 廩 */, 0xE2DE /* 廪 */,
0x8F5D /* 廬 */, 0xC2AE /* 庐 */,
0x8F64 /* 廳 */, 0xCCFC /* 厅 */,
0x8F68 /* 廻 */, 0xBBD8 /* 回 */,
0x8F69 /* 廼 */, 0xC4CB /* 乃 */,
0x8F73 /* 弒 */, 0xDFB1 /* 弑 */,
0x8F74 /* 弔 */, 0xB5F5 /* 吊 */,
0x8F86 /* 弳 */, 0xE5F2 /* 弪 */,
0x8F88 /* 張 */, 0xD5C5 /* 张 */,
0x8F8A /* 強 */, 0xC7BF /* 强 */,
0x8F95 /* 彆 */, 0xB1F0 /* 别 */,
0x8F97 /* 彈 */, 0xB5AF /* 弹 */,
0x8F99 /* 彊 */, 0xC7BF /* 强 */,
0x8F9B /* 彌 */, 0xC3D6 /* 弥 */,
0x8F9D /* 彎 */, 0xCDE4 /* 弯 */,
0x8FA1 /* 彙 */, 0xBBE3 /* 汇 */,
0x8FA4 /* 彜 */, 0xD2CD /* 彝 */,
0x8FA5 /* 彞 */, 0xD2CD /* 彝 */,
0x8FA7 /* 彠 */, 0x8FA6 /* 彟 */,
0x8FA9 /* 彥 */, 0xD1E5 /* 彦 */,
0x8FAC /* 彫 */, 0xB5F1 /* 雕 */,
0x8FB7 /* 彿 */, 0xB7F0 /* 佛 */,
0x8FBD /* 徑 */, 0xBEB6 /* 径 */,
0x8FC4 /* 從 */, 0xB4D3 /* 从 */,
0x8FC6 /* 徠 */, 0xE1E2 /* 徕 */,
0x8FCD /* 復 */, 0xB8B4 /* 复 */,
0x8FCF /* 徬 */, 0xB7C2 /* 仿 */,
0x8FD5 /* 徴 */, 0xD5F7 /* 征 */,
0x8FD8 /* 徹 */, 0xB3B9 /* 彻 */,
0x8FFA /* 忷 */, 0xD0DA /* 汹 */,
0x9061 /* 恆 */, 0xBAE3 /* 恒 */,
0x9072 /* 恟 */, 0xD0DA /* 汹 */,
0x9075 /* 恥 */, 0xB3DC /* 耻 */,
0x9082 /* 悅 */, 0xD4C3 /* 悦 */,
0x909D /* 悵 */, 0xE2EA /* 怅 */,
0x909E /* 悶 */, 0xC3C6 /* 闷 */,
0x90A2 /* 悽 */, 0xC6E0 /* 凄 */,
0x90AA /* 惇 */, 0xB6D8 /* 敦 */,
0x90BA /* 惡 */, 0xB6F1 /* 恶 */,
0x90C0 /* 惱 */, 0xC4D5 /* 恼 */,
0x90C1 /* 惲 */, 0xE3A2 /* 恽 */,
0x90C5 /* 惻 */, 0xE2FC /* 恻 */,
0x90DB /* 愛 */, 0xB0AE /* 爱 */,
0x90DC /* 愜 */, 0xE3AB /* 惬 */,
0x90E2 /* 愨 */, 0xEDA8 /* 悫 */,
0x90ED /* 愴 */, 0xE2EB /* 怆 */,
0x90F0 /* 愷 */, 0xE2FD /* 恺 */,
0x90F7 /* 愾 */, 0xE2E9 /* 忾 */,
0x90FC /* 慄 */, 0xC0F5 /* 栗 */,
0x9140 /* 慇 */, 0xD2F3 /* 殷 */,
0x9142 /* 態 */, 0xCCAC /* 态 */,
0x9143 /* 慍 */, 0xE3B3 /* 愠 */,
0x914B /* 慘 */, 0xB2D2 /* 惨 */,
0x914C /* 慙 */, 0xB2D1 /* 惭 */,
0x914D /* 慚 */, 0xB2D1 /* 惭 */,
0x9151 /* 慟 */, 0xE2FA /* 恸 */,
0x9154 /* 慣 */, 0xB9DF /* 惯 */,
0x9155 /* 慤 */, 0xEDA8 /* 悫 */,
0x9159 /* 慪 */, 0xE2E6 /* 怄 */,
0x915A /* 慫 */, 0xCBCB /* 怂 */,
0x915D /* 慮 */, 0xC2C7 /* 虑 */,
0x9161 /* 慳 */, 0xE3A5 /* 悭 */,
0x9162 /* 慴 */, 0xC9E5 /* 慑 */,
0x9163 /* 慶 */, 0xC7EC /* 庆 */,
0x9168 /* 慼 */, 0xC6DD /* 戚 */,
0x916A /* 慾 */, 0xD3FB /* 欲 */,
0x916E /* 憂 */, 0xD3C7 /* 忧 */,
0x9176 /* 憊 */, 0xB1B9 /* 惫 */,
0x917A /* 憐 */, 0xC1AF /* 怜 */,
0x917B /* 憑 */, 0xC6BE /* 凭 */,
0x917C /* 憒 */, 0xE3B4 /* 愦 */,
0x9180 /* 憖 */, 0x915C /* 慭 */,
0x9184 /* 憚 */, 0xB5AC /* 惮 */,
0x918D /* 憤 */, 0xB7DF /* 愤 */,
0x9191 /* 憫 */, 0xC3F5 /* 悯 */,
0x9193 /* 憮 */, 0xE2E4 /* 怃 */,
0x9197 /* 憲 */, 0xCFDC /* 宪 */,
0x919B /* 憶 */, 0xD2E4 /* 忆 */,
0x91A9 /* 懇 */, 0xBFD2 /* 恳 */,
0x91AA /* 應 */, 0xD3A6 /* 应 */,
0x91AB /* 懌 */, 0xE2F8 /* 怿 */,
0x91AC /* 懍 */, 0xE3C1 /* 懔 */,
0x91B1 /* 懕 */, 0xE2FB /* 恹 */,
0x91BA /* 懞 */, 0xC3C9 /* 蒙 */,
0x91BB /* 懟 */, 0xEDA1 /* 怼 */,
0x91BF /* 懣 */, 0xEDAF /* 懑 */,
0x91C3 /* 懨 */, 0xE2FB /* 恹 */,
0x91CD /* 懲 */, 0xB3CD /* 惩 */,
0x91D0 /* 懶 */, 0xC0C1 /* 懒 */,
0x91D1 /* 懷 */, 0xBBB3 /* 怀 */,
0x91D2 /* 懸 */, 0xD0FC /* 悬 */,
0x91D4 /* 懺 */, 0xE2E3 /* 忏 */,
0x91D6 /* 懼 */, 0xBEE5 /* 惧 */,
0x91D7 /* 懽 */, 0xBBB6 /* 欢 */,
0x91D8 /* 懾 */, 0xC9E5 /* 慑 */,
0x91D9 /* 戀 */, 0xC1B5 /* 恋 */,
0x91DF /* 戇 */, 0xEDB0 /* 戆 */,
0x91E2 /* 戔 */, 0xEAA7 /* 戋 */,
0x91EA /* 戧 */, 0xEAA8 /* 戗 */,
0x91EC /* 戩 */, 0xEAAF /* 戬 */,
0x91EF /* 戯 */, 0xCFB7 /* 戏 */,
0x91F0 /* 戰 */, 0xD5BD /* 战 */,
0x91F2 /* 戲 */, 0xCFB7 /* 戏 */,
0x91F4 /* 戶 */, 0xBBA7 /* 户 */,
0x9249 /* 扞 */, 0xBAB4 /* 捍 */,
0x924C /* 扡 */, 0xC7A4 /* 扦 */,
0x9251 /* 扱 */, 0xBCAB /* 极 */,
0x9281 /* 拋 */, 0xC5D7 /* 抛 */,
0x9283 /* 拑 */, 0xC7AF /* 钳 */,
0x929A /* 挌 */, 0xB8F1 /* 格 */,
0x92B6 /* 挾 */, 0xD0AE /* 挟 */,
0x92CE /* 捨 */, 0xC9E1 /* 舍 */,
0x92D0 /* 捫 */, 0xDED1 /* 扪 */,
0x92D4 /* 捲 */, 0xBEED /* 卷 */,
0x92DF /* 掃 */, 0xC9A8 /* 扫 */,
0x92E0 /* 掄 */, 0xC2D5 /* 抡 */,
0x92E9 /* 掗 */, 0x92A5 /* 挜 */,
0x92EA /* 掙 */, 0xD5F5 /* 挣 */,
0x92EC /* 掛 */, 0xB9D2 /* 挂 */,
0x92F1 /* 採 */, 0xB2C9 /* 采 */,
0x92FE /* 揀 */, 0xBCF0 /* 拣 */,
0x9350 /* 揚 */, 0xD1EF /* 扬 */,
0x9351 /* 換 */, 0xBBBB /* 换 */,
0x935D /* 揮 */, 0xBBD3 /* 挥 */,
0x9364 /* 揹 */, 0xB1B3 /* 背 */,
0x936B /* 搆 */, 0xB9B9 /* 构 */,
0x936C /* 搇 */, 0xDEEC /* 揿 */,
0x9370 /* 損 */, 0xCBF0 /* 损 */,
0x9375 /* 搖 */, 0xD2A1 /* 摇 */,
0x9376 /* 搗 */, 0xB5B7 /* 捣 */,
0x9380 /* 搥 */, 0xB4B7 /* 捶 */,
0x9386 /* 搯 */, 0xCCCD /* 掏 */,
0x938C /* 搶 */, 0xC7C0 /* 抢 */,
0x9392 /* 搾 */, 0xD5A5 /* 榨 */,
0x9393 /* 摀 */, 0xCEE6 /* 捂 */,
0x939D /* 摑 */, 0xDEE2 /* 掴 */,
0x93A5 /* 摜 */, 0xDEE8 /* 掼 */,
0x93A7 /* 摟 */, 0xC2A7 /* 搂 */,
0x93AB /* 摣 */, 0xDEEA /* 揸 */,
0x93B4 /* 摯 */, 0xD6BF /* 挚 */,
0x93B8 /* 摳 */, 0xBFD9 /* 抠 */,
0x93BB /* 摶 */, 0xDED2 /* 抟 */,
0x93BD /* 摻 */, 0xB2F4 /* 掺 */,
0x93C6 /* 撈 */, 0xC0CC /* 捞 */,
0x93CD /* 撏 */, 0x92A6 /* 挦 */,
0x93CE /* 撐 */, 0xB3C5 /* 撑 */,
0x93CF /* 撓 */, 0xC4D3 /* 挠 */,
0x93D3 /* 撚 */, 0xC4ED /* 捻 */,
0x93D7 /* 撟 */, 0xDED8 /* 挢 */,
0x93DA /* 撢 */, 0xB5A7 /* 掸 */,
0x93DB /* 撣 */, 0xB5A7 /* 掸 */,
0x93DC /* 撥 */, 0xB2A6 /* 拨 */,
0x93E1 /* 撫 */, 0xB8A7 /* 抚 */,
0x93E4 /* 撲 */, 0xC6CB /* 扑 */,
0x93E5 /* 撳 */, 0xDEEC /* 揿 */,
0x93E9 /* 撻 */, 0xCCA2 /* 挞 */,
0x93EB /* 撾 */, 0xCECE /* 挝 */,
0x93EC /* 撿 */, 0xBCF1 /* 捡 */,
0x93ED /* 擁 */, 0xD3B5 /* 拥 */,
0x93EF /* 擄 */, 0xC2B0 /* 掳 */,
0x93F1 /* 擇 */, 0xD4F1 /* 择 */,
0x93F4 /* 擊 */, 0xBBF7 /* 击 */,
0x93F5 /* 擋 */, 0xB5B2 /* 挡 */,
0x93FA /* 擔 */, 0xB5A3 /* 担 */,
0x93FB /* 擕 */, 0xD0AF /* 携 */,
0x93FE /* 據 */, 0xBEDD /* 据 */,
0x9444 /* 擠 */, 0xBCB7 /* 挤 */,
0x9445 /* 擡 */, 0xCCA7 /* 抬 */,
0x9446 /* 擣 */, 0xB5B7 /* 捣 */,
0x9448 /* 擧 */, 0xBED9 /* 举 */,
0x944D /* 擬 */, 0xC4E2 /* 拟 */,
0x9450 /* 擯 */, 0xB1F7 /* 摈 */,
0x9451 /* 擰 */, 0xC5A1 /* 拧 */,
0x9452 /* 擱 */, 0xB8E9 /* 搁 */,
0x9453 /* 擲 */, 0xD6C0 /* 掷 */,
0x9455 /* 擴 */, 0xC0A9 /* 扩 */,
0x9458 /* 擷 */, 0xDFA2 /* 撷 */,
0x945B /* 擺 */, 0xB0DA /* 摆 */,
0x945C /* 擻 */, 0xCBD3 /* 擞 */,
0x945D /* 擼 */, 0xDFA3 /* 撸 */,
0x945F /* 擾 */, 0xC8C5 /* 扰 */,
0x9464 /* 攄 */, 0xDEF3 /* 摅 */,
0x9466 /* 攆 */, 0xC4EC /* 撵 */,
0x946E /* 攏 */, 0xC2A3 /* 拢 */,
0x9472 /* 攔 */, 0xC0B9 /* 拦 */,
0x9474 /* 攖 */, 0xDEFC /* 撄 */,
0x9476 /* 攙 */, 0xB2F3 /* 搀 */,
0x9478 /* 攛 */, 0xDFA5 /* 撺 */,
0x9479 /* 攜 */, 0xD0AF /* 携 */,
0x947A /* 攝 */, 0xC9E3 /* 摄 */,
0x9480 /* 攢 */, 0xD4DC /* 攒 */,
0x9481 /* 攣 */, 0xC2CE /* 挛 */,
0x9482 /* 攤 */, 0xCCAF /* 摊 */,
0x9486 /* 攩 */, 0xB5B2 /* 挡 */,
0x9487 /* 攪 */, 0xBDC1 /* 搅 */,
0x9488 /* 攬 */, 0xC0BF /* 揽 */,
0x948E /* 攷 */, 0xBFBC /* 考 */,
0x949B /* 敍 */, 0xD0F0 /* 叙 */,
0x94A1 /* 敗 */, 0xB0DC /* 败 */,
0x94A2 /* 敘 */, 0xD0F0 /* 叙 */,
0x94AE /* 敭 */, 0xD1EF /* 扬 */,
0x94B3 /* 敵 */, 0xB5D0 /* 敌 */,
0x94B5 /* 數 */, 0xCAFD /* 数 */,
0x94B7 /* 敺 */, 0xC7FD /* 驱 */,
0x94BF /* 斂 */, 0xC1B2 /* 敛 */,
0x94C0 /* 斃 */, 0xB1D0 /* 毙 */,
0x94CC /* 斕 */, 0xECB5 /* 斓 */,
0x94D8 /* 斬 */, 0xD5B6 /* 斩 */,
0x94E0 /* 斷 */, 0xB6CF /* 断 */,
0x94E7 /* 旂 */, 0xC6EC /* 旗 */,
0x94F5 /* 旛 */, 0xE1A6 /* 幡 */,
0x9572 /* 時 */, 0xCAB1 /* 时 */,
0x9578 /* 晉 */, 0xBDFA /* 晋 */,
0x9583 /* 晝 */, 0xD6E7 /* 昼 */,
0x959E /* 暈 */, 0xD4CE /* 晕 */,
0x959F /* 暉 */, 0xEACD /* 晖 */,
0x95AA /* 暘 */, 0x9544 /* 旸 */,
0x95B3 /* 暢 */, 0xB3A9 /* 畅 */,
0x95BA /* 暫 */, 0xD4DD /* 暂 */,
0x95BF /* 暱 */, 0xEAC7 /* 昵 */,
0x95CF /* 曄 */, 0xEACA /* 晔 */,
0x95D1 /* 曆 */, 0xC0FA /* 历 */,
0x95D2 /* 曇 */, 0xEABC /* 昙 */,
0x95D4 /* 曉 */, 0xCFFE /* 晓 */,
0x95DA /* 曏 */, 0xCFF2 /* 向 */,
0x95E1 /* 曖 */, 0xEAD3 /* 暧 */,
0x95E7 /* 曠 */, 0xBFF5 /* 旷 */,
0x95E8 /* 曡 */, 0xB5FE /* 叠 */,
0x95EE /* 曨 */, 0x956F /* 昽 */,
0x95F1 /* 曬 */, 0xC9B9 /* 晒 */,
0x95F8 /* 書 */, 0xCAE9 /* 书 */,
0x95FE /* 會 */, 0xBBE1 /* 会 */,
0x9656 /* 朧 */, 0xEBCA /* 胧 */,
0x967C /* 東 */, 0xB6AB /* 东 */,
0x96A1 /* 枴 */, 0xB9D5 /* 拐 */,
0x96AC /* 柆 */, 0xC0AD /* 拉 */,
0x96C5 /* 柵 */, 0xD5A4 /* 栅 */,
0x96CA /* 柺 */, 0xB9D5 /* 拐 */,
0x974B /* 桲 */, 0xD8C3 /* 孛 */,
0x9755 /* 桿 */, 0xB8CB /* 杆 */,
0x9764 /* 梔 */, 0xE8D9 /* 栀 */,
0x9766 /* 梖 */, 0xB1B4 /* 贝 */,
0x9767 /* 梘 */, 0xE8C5 /* 枧 */,
0x976C /* 條 */, 0xCCF5 /* 条 */,
0x976E /* 梟 */, 0xE8C9 /* 枭 */,
0x9776 /* 梫 */, 0xB2CE /* 参 */,
0x9779 /* 梱 */, 0xC0A6 /* 捆 */,
0x9789 /* 棄 */, 0xC6FA /* 弃 */,
0x9796 /* 棖 */, 0xE8C7 /* 枨 */,
0x9797 /* 棗 */, 0xD4E6 /* 枣 */,
0x979D /* 棟 */, 0xB6B0 /* 栋 */,
0x97A3 /* 棧 */, 0xD5BB /* 栈 */,
0x97A8 /* 棬 */, 0xE8F0 /* 桊 */,
0x97AB /* 棲 */, 0xC6DC /* 栖 */,
0x97AE /* 棶 */, 0x9785 /* 梾 */,
0x97BF /* 椏 */, 0xE8E2 /* 桠 */,
0x97C0 /* 椑 */, 0xB1B0 /* 卑 */,
0x97E8 /* 楄 */, 0xD8D2 /* 匾 */,
0x97EE /* 楊 */, 0xD1EE /* 杨 */,
0x97F7 /* 楓 */, 0xB7E3 /* 枫 */,
0x9845 /* 楨 */, 0xE8E5 /* 桢 */,
0x9849 /* 業 */, 0xD2B5 /* 业 */,
0x984F /* 極 */, 0xBCAB /* 极 */,
0x985E /* 榐 */, 0xDEF8 /* 搌 */,
0x986F /* 榦 */, 0xB8C9 /* 干 */,
0x9871 /* 榪 */, 0xE8BF /* 杩 */,
0x9873 /* 榮 */, 0xC8D9 /* 荣 */,
0x9881 /* 榿 */, 0xE8E7 /* 桤 */,
0x9884 /* 槃 */, 0xC5CC /* 盘 */,
0x988B /* 構 */, 0xB9B9 /* 构 */,
0x988C /* 槍 */, 0xC7B9 /* 枪 */,
0x9890 /* 槓 */, 0xB8DC /* 杠 */,
0x989D /* 槤 */, 0xC1AC /* 连 */,
0x98A0 /* 槧 */, 0xE8FD /* 椠 */,
0x98A1 /* 槨 */, 0xE9A4 /* 椁 */,
0x98AA /* 槳 */, 0xBDB0 /* 桨 */,
0x98B3 /* 槼 */, 0xB9E6 /* 规 */,
0x98B6 /* 樁 */, 0xD7AE /* 桩 */,
0x98B7 /* 樂 */, 0xC0D6 /* 乐 */,
0x98BA /* 樅 */, 0xE8C8 /* 枞 */,
0x98C5 /* 樑 */, 0xC1BA /* 梁 */,
0x98C7 /* 樓 */, 0xC2A5 /* 楼 */,
0x98CB /* 標 */, 0xB1EA /* 标 */,
0x98D0 /* 樞 */, 0xCAE0 /* 枢 */,
0x98D3 /* 樣 */, 0xD1F9 /* 样 */,
0x98E2 /* 樷 */, 0xB4D4 /* 丛 */,
0x98E3 /* 樸 */, 0xC6D3 /* 朴 */,
0x98E4 /* 樹 */, 0xCAF7 /* 树 */,
0x98E5 /* 樺 */, 0xE8EB /* 桦 */,
0x98EF /* 橈 */, 0xE8E3 /* 桡 */,
0x98F2 /* 橋 */, 0xC7C5 /* 桥 */,
0x9943 /* 機 */, 0xBBFA /* 机 */,
0x9945 /* 橢 */, 0xCDD6 /* 椭 */,
0x994D /* 橫 */, 0xBAE1 /* 横 */,
0x9952 /* 橰 */, 0xE9C0 /* 槔 */,
0x995D /* 橾 */, 0xC5F6 /* 碰 */,
0x995F /* 檁 */, 0xE9DD /* 檩 */,
0x9966 /* 檉 */, 0xE8DF /* 柽 */,
0x996E /* 檔 */, 0xB5B5 /* 档 */,
0x9975 /* 檜 */, 0xE8ED /* 桧 */,
0x9977 /* 檞 */, 0xBDE2 /* 解 */,
0x9978 /* 檟 */, 0x9896 /* 槚 */,
0x997A /* 檢 */, 0xBCEC /* 检 */,
0x997B /* 檣 */, 0xE9C9 /* 樯 */,
0x9984 /* 檮 */, 0x9783 /* 梼 */,
0x9985 /* 檯 */, 0xCCA8 /* 台 */,
0x9989 /* 檳 */, 0xE9C4 /* 槟 */,
0x998D /* 檷 */, 0xECF2 /* 祢 */,
0x998E /* 檸 */, 0xC4FB /* 柠 */,
0x9991 /* 檻 */, 0xBCF7 /* 槛 */,
0x9994 /* 檾 */, 0xDCDC /* 苘 */,
0x9998 /* 櫂 */, 0xE8FE /* 棹 */,
0x9999 /* 櫃 */, 0xB9F1 /* 柜 */,
0x99A9 /* 櫓 */, 0xE9D6 /* 橹 */,
0x99B0 /* 櫚 */, 0xE9B5 /* 榈 */,
0x99B1 /* 櫛 */, 0xE8CE /* 栉 */,
0x99B3 /* 櫝 */, 0xE8FC /* 椟 */,
0x99B4 /* 櫞 */, 0xE9DA /* 橼 */,
0x99B5 /* 櫟 */, 0xE8DD /* 栎 */,
0x99BB /* 櫥 */, 0xB3F7 /* 橱 */,
0x99BD /* 櫧 */, 0xE9C6 /* 槠 */,
0x99BE /* 櫨 */, 0xE8D3 /* 栌 */,
0x99C0 /* 櫪 */, 0xE8C0 /* 枥 */,
0x99C1 /* 櫫 */, 0xE9CD /* 橥 */,
0x99C2 /* 櫬 */, 0xE9B4 /* 榇 */,
0x99C9 /* 櫳 */, 0xE8D0 /* 栊 */,
0x99CE /* 櫸 */, 0xE9B7 /* 榉 */,
0x99D0 /* 櫺 */, 0xE8F9 /* 棂 */,
0x99D1 /* 櫻 */, 0xD3A3 /* 樱 */,
0x99DA /* 欄 */, 0xC0B8 /* 栏 */,
0x99E0 /* 權 */, 0xC8A8 /* 权 */,
0x99E5 /* 欏 */, 0xE9A1 /* 椤 */,
0x99E7 /* 欑 */, 0xD4DC /* 攒 */,
0x99E8 /* 欒 */, 0xE8EF /* 栾 */,
0x99EC /* 欖 */, 0xE9AD /* 榄 */,
0x99F4 /* 欞 */, 0xE8F9 /* 棂 */,
0x9A4A /* 欽 */, 0xC7D5 /* 钦 */,
0x9A55 /* 歎 */, 0xCCBE /* 叹 */,
0x9A57 /* 歐 */, 0xC5B7 /* 欧 */,
0x9A5E /* 歗 */, 0xD0A5 /* 啸 */,
0x9A61 /* 歛 */, 0xC1B2 /* 敛 */,
0x9A65 /* 歟 */, 0xECA3 /* 欤 */,
0x9A67 /* 歡 */, 0xBBB6 /* 欢 */,
0x9A71 /* 歲 */, 0xCBEA /* 岁 */,
0x9A76 /* 歷 */, 0xC0FA /* 历 */,
0x9A77 /* 歸 */, 0xB9E9 /* 归 */,
0x9A7B /* 歿 */, 0xE9E2 /* 殁 */,
0x9A88 /* 殘 */, 0xB2D0 /* 残 */,
0x9A8C /* 殞 */, 0xE9E6 /* 殒 */,
0x9A91 /* 殤 */, 0xE9E4 /* 殇 */,
0x9A97 /* 殫 */, 0xE9E9 /* 殚 */,
0x9A99 /* 殭 */, 0xBDA9 /* 僵 */,
0x9A9A /* 殮 */, 0xE9E7 /* 殓 */,
0x9A9B /* 殯 */, 0xE9EB /* 殡 */,
0x9A9E /* 殲 */, 0xBCDF /* 歼 */,
0x9AA2 /* 殺 */, 0xC9B1 /* 杀 */,
0x9AA3 /* 殻 */, 0xBFC7 /* 壳 */,
0x9AA4 /* 殼 */, 0xBFC7 /* 壳 */,
0x9AA5 /* 殽 */, 0xEBC8 /* 肴 */,
0x9AA7 /* 毀 */, 0xBBD9 /* 毁 */,
0x9AAA /* 毆 */, 0xC5B9 /* 殴 */,
0x9AAD /* 毉 */, 0xD2BD /* 医 */,
0x9ABF /* 毧 */, 0xC8DE /* 绒 */,
0x9AC2 /* 毬 */, 0xC7F2 /* 球 */,
0x9AD0 /* 毿 */, 0xEBA7 /* 毵 */,
0x9AD3 /* 氂 */, 0xEAF3 /* 牦 */,
0x9AD6 /* 氈 */, 0xD5B1 /* 毡 */,
0x9AD8 /* 氊 */, 0xD5B1 /* 毡 */,
0x9ADA /* 氌 */, 0xEBAA /* 氇 */,
0x9AE2 /* 氣 */, 0xC6F8 /* 气 */,
0x9AE4 /* 氫 */, 0xC7E2 /* 氢 */,
0x9AE5 /* 氬 */, 0xEBB2 /* 氩 */,
0x9AE8 /* 氳 */, 0xEBB5 /* 氲 */,
0x9AEB /* 氹 */, 0xDBCA /* 凼 */,
0x9AEF /* 氾 */, 0xB7BA /* 泛 */,
0x9AF8 /* 汎 */, 0xB7BA /* 泛 */,
0x9B40 /* 汙 */, 0xCEDB /* 污 */,
0x9B41 /* 汚 */, 0xCEDB /* 污 */,
0x9B51 /* 決 */, 0xBEF6 /* 决 */,
0x9B5A /* 沍 */, 0xD9FC /* 冱 */,
0x9B5D /* 沒 */, 0xC3BB /* 没 */,
0x9B5F /* 沖 */, 0xB3E5 /* 冲 */,
0x9B72 /* 況 */, 0xBFF6 /* 况 */,
0x9BAA /* 洩 */, 0xD0B9 /* 泄 */,
0x9BB0 /* 洶 */, 0xD0DA /* 汹 */,
0x9BC9 /* 浬 */, 0xC0EF /* 里 */,
0x9BD1 /* 浹 */, 0xE4A4 /* 浃 */,
0x9BDC /* 涇 */, 0xE3FE /* 泾 */,
0x9BE3 /* 涖 */, 0xDDB0 /* 莅 */,
0x9BF6 /* 涼 */, 0xC1B9 /* 凉 */,
0x9C44 /* 淒 */, 0xC6E0 /* 凄 */,
0x9C49 /* 淚 */, 0xC0E1 /* 泪 */,
0x9C4F /* 淥 */, 0xE4CB /* 渌 */,
0x9C51 /* 淨 */, 0xBEBB /* 净 */,
0x9C52 /* 淩 */, 0xC1E8 /* 凌 */,
0x9C53 /* 淪 */, 0xC2D9 /* 沦 */,
0x9C59 /* 淵 */, 0xD4A8 /* 渊 */,
0x9C5A /* 淶 */, 0xE4B5 /* 涞 */,
0x9C5C /* 淺 */, 0xC7B3 /* 浅 */,
0x9C6F /* 渙 */, 0xBBC1 /* 涣 */,
0x9C70 /* 減 */, 0xBCF5 /* 减 */,
0x9C74 /* 渢 */, 0x9B68 /* 沨 */,
0x9C75 /* 渦 */, 0xCED0 /* 涡 */,
0x9C79 /* 測 */, 0xB2E2 /* 测 */,
0x9C86 /* 渾 */, 0xBBEB /* 浑 */,
0x9C90 /* 湊 */, 0xB4D5 /* 凑 */,
0x9C9D /* 湞 */, 0xE4A5 /* 浈 */,
0x9CA1 /* 湣 */, 0xEDAA /* 愍 */,
0x9CA5 /* 湧 */, 0x9CA5 /* 涌 */,
0x9CAB /* 湯 */, 0xCCC0 /* 汤 */,
0x9CB0 /* 湴 */, 0xBAE9 /* 洪 */,
0x9CBF /* 溈 */, 0xE3ED /* 沩 */,
0x9CCA /* 準 */, 0xD7BC /* 准 */,
0x9CCF /* 溝 */, 0xB9B5 /* 沟 */,
0x9CD8 /* 溫 */, 0xCEC2 /* 温 */,
0x9CDB /* 溮 */, 0x9BB8 /* 浉 */,
0x9CDD /* 溳 */, 0x9BE9 /* 涢 */,
0x9CE1 /* 溼 */, 0xCAAA /* 湿 */,
0x9CE6 /* 滄 */, 0xB2D7 /* 沧 */,
0x9CE7 /* 滅 */, 0xC3F0 /* 灭 */,
0x9CEC /* 滌 */, 0xB5D3 /* 涤 */,
0x9CEE /* 滎 */, 0xDCFE /* 荥 */,
0x9CF3 /* 滙 */, 0xBBE3 /* 汇 */,
0x9CFB /* 滬 */, 0xBBA6 /* 沪 */,
0x9CFE /* 滯 */, 0xD6CD /* 滞 */,
0x9D42 /* 滲 */, 0xC9F8 /* 渗 */,
0x9D46 /* 滷 */, 0xC2B1 /* 卤 */,
0x9D47 /* 滸 */, 0xE4B0 /* 浒 */,
0x9D49 /* 滻 */, 0x9BBA /* 浐 */,
0x9D4C /* 滾 */, 0xB9F6 /* 滚 */,
0x9D4D /* 滿 */, 0xC2FA /* 满 */,
0x9D4F /* 漁 */, 0xD3E6 /* 渔 */,
0x9D55 /* 漊 */, 0x9CBE /* 溇 */,
0x9D61 /* 漚 */, 0xC5BD /* 沤 */,
0x9D68 /* 漢 */, 0xBABA /* 汉 */,
0x9D69 /* 漣 */, 0xC1B0 /* 涟 */,
0x9D6E /* 漬 */, 0xD7D5 /* 渍 */,
0x9D71 /* 漲 */, 0xD5C7 /* 涨 */,
0x9D73 /* 漵 */, 0xE4D3 /* 溆 */,
0x9D75 /* 漸 */, 0xBDA5 /* 渐 */,
0x9D7B /* 漿 */, 0xBDAC /* 浆 */,
0x9D7D /* 潁 */, 0xF2A3 /* 颍 */,
0x9D8A /* 潑 */, 0xC6C3 /* 泼 */,
0x9D8D /* 潔 */, 0xBDE0 /* 洁 */,
0x9D91 /* 潙 */, 0xE3ED /* 沩 */,
0x9D93 /* 潛 */, 0xC7B1 /* 潜 */,
0x9D95 /* 潟 */, 0xF4AA /* 舄 */,
0x9D99 /* 潤 */, 0xC8F3 /* 润 */,
0x9DA1 /* 潯 */, 0xE4B1 /* 浔 */,
0x9DA2 /* 潰 */, 0xC0A3 /* 溃 */,
0x9DA7 /* 潷 */, 0xE4E4 /* 滗 */,
0x9DAC /* 潿 */, 0xE4B6 /* 涠 */,
0x9DAD /* 澀 */, 0xC9AC /* 涩 */,
0x9DAE /* 澁 */, 0xC9AC /* 涩 */,
0x9DAF /* 澂 */, 0xB3CE /* 澄 */,
0x9DB2 /* 澆 */, 0xBDBD /* 浇 */,
0x9DB3 /* 澇 */, 0xC0D4 /* 涝 */,
0x9DBE /* 澗 */, 0xBDA7 /* 涧 */,
0x9DC6 /* 澠 */, 0xE4C5 /* 渑 */,
0x9DC9 /* 澤 */, 0xD4F3 /* 泽 */,
0x9DCB /* 澦 */, 0x9CF9 /* 滪 */,
0x9DCD /* 澩 */, 0xEDB4 /* 泶 */,
0x9DD2 /* 澮 */, 0xE4AB /* 浍 */,
0x9DD5 /* 澱 */, 0xB5ED /* 淀 */,
0x9DE1 /* 濁 */, 0xD7C7 /* 浊 */,
0x9DE2 /* 濃 */, 0xC5A8 /* 浓 */,
0x9DF0 /* 濔 */, 0x9B6D /* 沵 */,
0x9DF1 /* 濕 */, 0xCAAA /* 湿 */,
0x9DF4 /* 濘 */, 0xC5A2 /* 泞 */,
0x9DF7 /* 濛 */, 0xC3C9 /* 蒙 */,
0x9DF8 /* 濜 */, 0x9BBB /* 浕 */,
0x9DFA /* 濟 */, 0xBCC3 /* 济 */,
0x9DFD /* 濤 */, 0xCCCE /* 涛 */,
0x9E45 /* 濫 */, 0xC0C4 /* 滥 */,
0x9E46 /* 濬 */, 0xBFA3 /* 浚 */,
0x9E48 /* 濰 */, 0xCEAB /* 潍 */,
0x9E49 /* 濱 */, 0xB1F5 /* 滨 */,
0x9E4E /* 濶 */, 0xC0AB /* 阔 */,
0x9E52 /* 濺 */, 0xBDA6 /* 溅 */,
0x9E54 /* 濼 */, 0xE3F8 /* 泺 */,
0x9E56 /* 濾 */, 0xC2CB /* 滤 */,
0x9E5D /* 瀅 */, 0xE4DE /* 滢 */,
0x9E5E /* 瀆 */, 0xE4C2 /* 渎 */,
0x9E61 /* 瀉 */, 0xD0BA /* 泻 */,
0x9E63 /* 瀋 */, 0xE4C9 /* 渖 */,
0x9E67 /* 瀏 */, 0xE4AF /* 浏 */,
0x9E6C /* 瀕 */, 0xB1F4 /* 濒 */,
0x9E6F /* 瀘 */, 0xE3F2 /* 泸 */,
0x9E72 /* 瀝 */, 0xC1A4 /* 沥 */,
0x9E74 /* 瀟 */, 0xE4EC /* 潇 */,
0x9E75 /* 瀠 */, 0xE4EB /* 潆 */,
0x9E7A /* 瀦 */, 0xE4F3 /* 潴 */,
0x9E7B /* 瀧 */, 0xE3F1 /* 泷 */,
0x9E7C /* 瀨 */, 0xE4FE /* 濑 */,
0x9E85 /* 瀰 */, 0xC3D6 /* 弥 */,
0x9E87 /* 瀲 */, 0xE4F2 /* 潋 */,
0x9E91 /* 瀾 */, 0xC0BD /* 澜 */,
0x9E96 /* 灃 */, 0xE3E3 /* 沣 */,
0x9E97 /* 灄 */, 0xE4DC /* 滠 */,
0x9EA2 /* 灑 */, 0xC8F7 /* 洒 */,
0x9EA6 /* 灕 */, 0xC0EC /* 漓 */,
0x9EA9 /* 灘 */, 0xCCB2 /* 滩 */,
0x9EAE /* 灝 */, 0xE5B0 /* 灏 */,
0x9EB3 /* 灣 */, 0xCDE5 /* 湾 */,
0x9EB4 /* 灤 */, 0xC2D0 /* 滦 */,
0x9EB7 /* 灧 */, 0xE4D9 /* 滟 */,
0x9EB9 /* 灩 */, 0xE4D9 /* 滟 */,
0x9EC4 /* 災 */, 0xD4D6 /* 灾 */,
0x9EDD /* 炤 */, 0xD5D5 /* 照 */,
0x9EE9 /* 為 */, 0xCEAA /* 为 */,
0x9EF5 /* 烏 */, 0xCEDA /* 乌 */,
0x9F4E /* 烴 */, 0xCCFE /* 烃 */,
0x9F6F /* 無 */, 0xCEDE /* 无 */,
0x9F73 /* 焥 */, 0xCDE9 /* 烷 */,
0x9F8F /* 煆 */, 0xECD1 /* 煅 */,
0x9F90 /* 煇 */, 0xBBD4 /* 辉 */,
0x9F92 /* 煉 */, 0xC1B6 /* 炼 */,
0x9F98 /* 煒 */, 0xECBF /* 炜 */,
0x9F9C /* 煖 */, 0xC5AF /* 暖 */,
0x9F9F /* 煙 */, 0xD1CC /* 烟 */,
0x9FA6 /* 煢 */, 0xDCE4 /* 茕 */,
0x9FA8 /* 煥 */, 0xBBC0 /* 焕 */,
0x9FA9 /* 煩 */, 0xB7B3 /* 烦 */,
0x9FAC /* 煬 */, 0xECBE /* 炀 */,
0x9FC9 /* 熒 */, 0xD3AB /* 荧 */,
0x9FCD /* 熗 */, 0xECC1 /* 炝 */,
0x9FE1 /* 熱 */, 0xC8C8 /* 热 */,
0x9FE2 /* 熲 */, 0xEF47 /* 颎 */,
0x9FEB /* 熾 */, 0xB3E3 /* 炽 */,
0x9FEE /* 燁 */, 0xECC7 /* 烨 */,
0x9FF0 /* 燄 */, 0xD1E6 /* 焰 */,
0x9FF4 /* 燈 */, 0xB5C6 /* 灯 */,
0x9FF5 /* 燉 */, 0xECC0 /* 炖 */,
0x9FFB /* 燐 */, 0xC1D7 /* 磷 */,
0x9FFD /* 燒 */, 0xC9D5 /* 烧 */,
0xA043 /* 燙 */, 0xCCCC /* 烫 */,
0xA046 /* 燜 */, 0xECCB /* 焖 */,
0xA049 /* 營 */, 0xD3AA /* 营 */,
0xA04E /* 燦 */, 0xB2D3 /* 灿 */,
0xA053 /* 燬 */, 0xBBD9 /* 毁 */,
0xA054 /* 燭 */, 0xD6F2 /* 烛 */,
0xA05A /* 燴 */, 0xBBE2 /* 烩 */,
0xA060 /* 燻 */, 0xD1AC /* 熏 */,
0xA061 /* 燼 */, 0xBDFD /* 烬 */,
0xA063 /* 燾 */, 0xECE2 /* 焘 */,
0xA064 /* 燿 */, 0xD2AB /* 耀 */,
0xA071 /* 爍 */, 0xCBB8 /* 烁 */,
0xA074 /* 爐 */, 0xC2AF /* 炉 */,
0xA07B /* 爗 */, 0xECC7 /* 烨 */,
0xA080 /* 爛 */, 0xC0C3 /* 烂 */,
0xA08E /* 爭 */, 0xD5F9 /* 争 */,
0xA091 /* 爲 */, 0xCEAA /* 为 */,
0xA094 /* 爺 */, 0xD2AF /* 爷 */,
0xA096 /* 爾 */, 0xB6FB /* 尔 */,
0xA097 /* 牀 */, 0xB4B2 /* 床 */,
0xA09D /* 牆 */, 0xC7BD /* 墙 */,
0xA0A0 /* 牋 */, 0xBCE3 /* 笺 */,
0xA0A3 /* 牐 */, 0xD5A2 /* 闸 */,
0xA0A9 /* 牘 */, 0xEBB9 /* 牍 */,
0xA0AD /* 牠 */, 0xCBFC /* 它 */,
0xA0B9 /* 牴 */, 0xB5D6 /* 抵 */,
0xA0BF /* 牽 */, 0xC7A3 /* 牵 */,
0xA0CE /* 犖 */, 0xDCFD /* 荦 */,
0xA0D3 /* 犛 */, 0xEAF3 /* 牦 */,
0xA0D9 /* 犢 */, 0xB6BF /* 犊 */,
0xA0DE /* 犧 */, 0xCEFE /* 牺 */,
0xA0EE /* 狀 */, 0xD7B4 /* 状 */,
0xA0FD /* 狚 */, 0xB5A9 /* 旦 */,
0xAA4D /* 狹 */, 0xCFC1 /* 狭 */,
0xAA4E /* 狽 */, 0xB1B7 /* 狈 */,
0xAA62 /* 猙 */, 0xD5F8 /* 狰 */,
0xAA71 /* 猶 */, 0xD3CC /* 犹 */,
0xAA73 /* 猻 */, 0xE1F8 /* 狲 */,
0xAA77 /* 獁 */, 0xE1EF /* 犸 */,
0xAA79 /* 獃 */, 0xB4F4 /* 呆 */,
0xAA7A /* 獄 */, 0xD3FC /* 狱 */,
0xAA7B /* 獅 */, 0xCAA8 /* 狮 */,
0xAA84 /* 獎 */, 0xBDB1 /* 奖 */,
0xAA9A /* 獨 */, 0xB6C0 /* 独 */,
0xAA9C /* 獪 */, 0xE1F6 /* 狯 */,
0xAA9D /* 獫 */, 0xE1FD /* 猃 */,
0xAA9E /* 獮 */, 0xAA41 /* 狝 */,
0xAA9F /* 獰 */, 0xC4FC /* 狞 */,
0xAB40 /* 獲 */, 0xBBF1 /* 获 */,
0xAB43 /* 獵 */, 0xC1D4 /* 猎 */,
0xAB45 /* 獷 */, 0xE1EE /* 犷 */,
0xAB46 /* 獸 */, 0xCADE /* 兽 */,
0xAB48 /* 獺 */, 0xCCA1 /* 獭 */,
0xAB49 /* 獻 */, 0xCFD7 /* 献 */,
0xAB4A /* 獼 */, 0xE2A8 /* 猕 */,
0xAB4D /* 玀 */, 0xE2A4 /* 猡 */,
0xAB52 /* 玆 */, 0xD7C8 /* 兹 */,
0xAB6B /* 玨 */, 0xE7E5 /* 珏 */,
0xAB95 /* 珪 */, 0xB9E7 /* 圭 */,
0xAB98 /* 珮 */, 0xC5E5 /* 佩 */,
0xAC46 /* 現 */, 0xCFD6 /* 现 */,
0xAC50 /* 琍 */, 0xC1A7 /* 璃 */,
0xAC67 /* 琯 */, 0xB9DC /* 管 */,
0xAC6D /* 琺 */, 0xB7A9 /* 珐 */,
0xAC71 /* 琿 */, 0xE7F5 /* 珲 */,
0xAC7A /* 瑉 */, 0xE7EB /* 珉 */,
0xAC7B /* 瑊 */, 0xD5E8 /* 砧 */,
0xAC7C /* 瑋 */, 0xE7E2 /* 玮 */,
0xAC84 /* 瑒 */, 0xAB60 /* 玚 */,
0xAC8D /* 瑣 */, 0xCBF6 /* 琐 */,
0xAC8E /* 瑤 */, 0xD1FE /* 瑶 */,
0xAC93 /* 瑩 */, 0xD3A8 /* 莹 */,
0xAC94 /* 瑪 */, 0xC2EA /* 玛 */,
0xAC98 /* 瑯 */, 0xC0C5 /* 琅 */,
0xAC9A /* 瑲 */, 0xAB6F /* 玱 */,
0xAD49 /* 璉 */, 0xE7F6 /* 琏 */,
0xAD5C /* 璡 */, 0xAC51 /* 琎 */,
0xAD5E /* 璣 */, 0xE7E1 /* 玑 */,
0xAD61 /* 璦 */, 0xE8A8 /* 瑷 */,
0xAD63 /* 璫 */, 0xAB9A /* 珰 */,
0xAD68 /* 環 */, 0xBBB7 /* 环 */,
0xAD6D /* 璵 */, 0xAB5F /* 玙 */,
0xAD74 /* 璽 */, 0xE7F4 /* 玺 */,
0xAD76 /* 璿 */, 0xE8AF /* 璇 */,
0xAD82 /* 瓊 */, 0xC7ED /* 琼 */,
0xAD87 /* 瓏 */, 0xE7E7 /* 珑 */,
0xAD8B /* 瓔 */, 0xE8AC /* 璎 */,
0xAD91 /* 瓚 */, 0xE8B6 /* 瓒 */,
0xAE54 /* 甌 */, 0xEAB1 /* 瓯 */,
0xAE55 /* 甎 */, 0xD7A9 /* 砖 */,
0xAE59 /* 甕 */, 0xCECD /* 瓮 */,
0xAE5A /* 甖 */, 0xF3BF /* 罂 */,
0xAE61 /* 產 */, 0xB2FA /* 产 */,
0xAE62 /* 産 */, 0xB2FA /* 产 */,
0xAE64 /* 甦 */, 0xCBD5 /* 苏 */,
0xAE80 /* 畝 */, 0xC4B6 /* 亩 */,
0xAE85 /* 畢 */, 0xB1CF /* 毕 */,
0xAE8B /* 畫 */, 0xBBAD /* 画 */,
0xAE8C /* 畬 */, 0xEEB4 /* 畲 */,
0xAE90 /* 異 */, 0xD2EC /* 异 */,
0xAE91 /* 畱 */, 0xC1F4 /* 留 */,
0xAE94 /* 當 */, 0xB5B1 /* 当 */,
0xAEA0 /* 疇 */, 0xB3EB /* 畴 */,
0xAF42 /* 疊 */, 0xB5FE /* 叠 */,
0xAF64 /* 痙 */, 0xBEB7 /* 痉 */,
0xAF69 /* 痠 */, 0xCBE1 /* 酸 */,
0xAF71 /* 痲 */, 0xC2E9 /* 麻 */,
0xAF72 /* 痳 */, 0xC2E9 /* 麻 */,
0xAF77 /* 痺 */, 0xB1D4 /* 痹 */,
0xAF7A /* 痾 */, 0xF0E2 /* 疴 */,
0xAF7B /* 瘂 */, 0xF0E9 /* 痖 */,
0xAF81 /* 瘉 */, 0xD3FA /* 愈 */,
0xAF82 /* 瘋 */, 0xB7E8 /* 疯 */,
0xAF83 /* 瘍 */, 0xD1F1 /* 疡 */,
0xAF88 /* 瘓 */, 0xBBBE /* 痪 */,
0xAF8E /* 瘞 */, 0xF0F9 /* 瘗 */,
0xAF8F /* 瘡 */, 0xB4AF /* 疮 */,
0xAF91 /* 瘧 */, 0xC5B1 /* 疟 */,
0xAF94 /* 瘮 */, 0xAF7D /* 瘆 */,
0xAF9B /* 瘺 */, 0xF0FC /* 瘘 */,
0xAF9C /* 瘻 */, 0xF0FC /* 瘘 */,
0xAF9F /* 療 */, 0xC1C6 /* 疗 */,
0xB041 /* 癆 */, 0xF0EC /* 痨 */,
0xB042 /* 癇 */, 0xF0EF /* 痫 */,
0xB044 /* 癉 */, 0xF0F7 /* 瘅 */,
0xB04B /* 癒 */, 0xD3FA /* 愈 */,
0xB04F /* 癘 */, 0xF0DD /* 疠 */,
0xB054 /* 癟 */, 0xB1F1 /* 瘪 */,
0xB056 /* 癡 */, 0xB3D5 /* 痴 */,
0xB057 /* 癢 */, 0xD1F7 /* 痒 */,
0xB058 /* 癤 */, 0xF0DC /* 疖 */,
0xB059 /* 癥 */, 0xD6A2 /* 症 */,
0xB05B /* 癧 */, 0xF0DF /* 疬 */,
0xB05D /* 癩 */, 0xF1AE /* 癞 */,
0xB05F /* 癬 */, 0xD1A2 /* 癣 */,
0xB060 /* 癭 */, 0xF1A8 /* 瘿 */,
0xB061 /* 癮 */, 0xF1AB /* 瘾 */,
0xB062 /* 癰 */, 0xD3B8 /* 痈 */,
0xB063 /* 癱 */, 0xCCB1 /* 瘫 */,
0xB064 /* 癲 */, 0xF1B2 /* 癫 */,
0xB06C /* 發 */, 0xB7A2 /* 发 */,
0xB07D /* 皚 */, 0xB0A8 /* 皑 */,
0xB092 /* 皰 */, 0xF0E5 /* 疱 */,
0xB097 /* 皸 */, 0xF1E4 /* 皲 */,
0xB099 /* 皺 */, 0xD6E5 /* 皱 */,
0xB0A0 /* 盃 */, 0xB1AD /* 杯 */,
0xB149 /* 盜 */, 0xB5C1 /* 盗 */,
0xB14B /* 盞 */, 0xD5B5 /* 盏 */,
0xB14D /* 盡 */, 0xBEA1 /* 尽 */,
0xB14F /* 監 */, 0xBCE0 /* 监 */,
0xB150 /* 盤 */, 0xC5CC /* 盘 */,
0xB152 /* 盧 */, 0xC2AC /* 卢 */,
0xB155 /* 盪 */, 0xB5B4 /* 荡 */,
0xB169 /* 眎 */, 0xCAD3 /* 视 */,
0xB178 /* 眡 */, 0xCAD3 /* 视 */,
0xB17B /* 眥 */, 0xEDF6 /* 眦 */,
0xB18A /* 眾 */, 0xD6DA /* 众 */,
0xB197 /* 睏 */, 0xC0A7 /* 困 */,
0xB1A0 /* 睜 */, 0xD5F6 /* 睁 */,
0xB241 /* 睞 */, 0xEDF9 /* 睐 */,
0xB247 /* 睪 */, 0xD8BA /* 睾 */,
0xB25B /* 瞇 */, 0xC3D0 /* 眯 */,
0xB267 /* 瞘 */, 0xEDEE /* 眍 */,
0xB26D /* 瞞 */, 0xC2F7 /* 瞒 */,
0xB274 /* 瞭 */, 0xC1CB /* 了 */,
0xB280 /* 瞼 */, 0xEDFA /* 睑 */,
0xB289 /* 矇 */, 0xC3C9 /* 蒙 */,
0xB294 /* 矓 */, 0xB180 /* 眬 */,
0xB29A /* 矚 */, 0xD6F5 /* 瞩 */,
0xB343 /* 矯 */, 0xBDC3 /* 矫 */,
0xB368 /* 砲 */, 0xC5DA /* 炮 */,
0xB36A /* 砵 */, 0xB2A7 /* 钵 */,
0xB370 /* 硃 */, 0xD6EC /* 朱 */,
0xB381 /* 硜 */, 0xB36E /* 硁 */,
0xB388 /* 硤 */, 0xEDCC /* 硖 */,
0xB38C /* 硨 */, 0xEDBA /* 砗 */,
0xB38E /* 硯 */, 0xD1E2 /* 砚 */,
0xB395 /* 硶 */, 0xEDD7 /* 碜 */,
0xB454 /* 碩 */, 0xCBB6 /* 硕 */,
0xB458 /* 碭 */, 0xEDB8 /* 砀 */,
0xB45E /* 碸 */, 0xEDBF /* 砜 */,
0xB45F /* 確 */, 0xC8B7 /* 确 */,
0xB461 /* 碼 */, 0xC2EB /* 码 */,
0xB46F /* 磑 */, 0xB37D /* 硙 */,
0xB475 /* 磚 */, 0xD7A9 /* 砖 */,
0xB47E /* 磣 */, 0xEDD7 /* 碜 */,
0xB483 /* 磧 */, 0xEDD3 /* 碛 */,
0xB489 /* 磯 */, 0xEDB6 /* 矶 */,
0xB493 /* 磽 */, 0xEDCD /* 硗 */,
0xB499 /* 礄 */, 0xB37E /* 硚 */,
0xB541 /* 礎 */, 0xB4A1 /* 础 */,
0xB54B /* 礙 */, 0xB0AD /* 碍 */,
0xB552 /* 礡 */, 0xEDE7 /* 礴 */,
0xB556 /* 礦 */, 0xBFF3 /* 矿 */,
0xB55A /* 礪 */, 0xEDC2 /* 砺 */,
0xB55B /* 礫 */, 0xC0F9 /* 砾 */,
0xB55C /* 礬 */, 0xB7AF /* 矾 */,
0xB55E /* 礮 */, 0xC5DA /* 炮 */,
0xB561 /* 礱 */, 0xEDC3 /* 砻 */,
0xB56B /* 祂 */, 0xCBFB /* 他 */,
0xB576 /* 祐 */, 0xD3D3 /* 佑 */,
0xB57A /* 祕 */, 0xC3D8 /* 秘 */,
0xB590 /* 祼 */, 0xC2E3 /* 裸 */,
0xB593 /* 祿 */, 0xC2BB /* 禄 */,
0xB59C /* 禍 */, 0xBBF6 /* 祸 */,
0xB59D /* 禎 */, 0xECF5 /* 祯 */,
0xB642 /* 禕 */, 0xB574 /* 祎 */,
0xB652 /* 禦 */, 0xD3F9 /* 御 */,
0xB655 /* 禪 */, 0xECF8 /* 禅 */,
0xB659 /* 禮 */, 0xC0F1 /* 礼 */,
0xB65B /* 禰 */, 0xECF2 /* 祢 */,
0xB65C /* 禱 */, 0xB5BB /* 祷 */,
0xB664 /* 禿 */, 0xCDBA /* 秃 */,
0xB669 /* 秈 */, 0xF4CC /* 籼 */,
0xB690 /* 稅 */, 0xCBB0 /* 税 */,
0xB692 /* 稈 */, 0xB8D1 /* 秆 */,
0xB6A0 /* 稜 */, 0xC0E2 /* 棱 */,
0xB741 /* 稟 */, 0xD9F7 /* 禀 */,
0xB748 /* 稨 */, 0xB1E2 /* 扁 */,
0xB74D /* 稭 */, 0xBDD5 /* 秸 */,
0xB74E /* 種 */, 0xD6D6 /* 种 */,
0xB751 /* 稱 */, 0xB3C6 /* 称 */,
0xB759 /* 穀 */, 0xB9C8 /* 谷 */,
0xB764 /* 穌 */, 0xF6D5 /* 稣 */,
0xB765 /* 積 */, 0xBBFD /* 积 */,
0xB766 /* 穎 */, 0xD3B1 /* 颖 */,
0xB776 /* 穠 */, 0xB68C /* 秾 */,
0xB777 /* 穡 */, 0xF0A3 /* 穑 */,
0xB778 /* 穢 */, 0xBBE0 /* 秽 */,
0xB77E /* 穨 */, 0xCDC7 /* 颓 */,
0xB780 /* 穩 */, 0xCEC8 /* 稳 */,
0xB782 /* 穫 */, 0xBBF1 /* 获 */,
0xB784 /* 穭 */, 0xEFF9 /* 稆 */,
0xB843 /* 窩 */, 0xCED1 /* 窝 */,
0xB844 /* 窪 */, 0xCDDD /* 洼 */,
0xB846 /* 窮 */, 0xC7EE /* 穷 */,
0xB847 /* 窯 */, 0xD2A4 /* 窑 */,
0xB848 /* 窰 */, 0xD2A4 /* 窑 */,
0xB84D /* 窶 */, 0xF1C0 /* 窭 */,
0xB851 /* 窺 */, 0xBFFA /* 窥 */,
0xB85A /* 竄 */, 0xB4DC /* 窜 */,
0xB85B /* 竅 */, 0xC7CF /* 窍 */,
0xB85D /* 竇 */, 0xF1BC /* 窦 */,
0xB85E /* 竈 */, 0xD4EE /* 灶 */,
0xB860 /* 竊 */, 0xC7D4 /* 窃 */,
0xB877 /* 竪 */, 0xCAFA /* 竖 */,
0xB882 /* 競 */, 0xBEBA /* 竞 */,
0xB950 /* 筆 */, 0xB1CA /* 笔 */,
0xB953 /* 筍 */, 0xCBF1 /* 笋 */,
0xB961 /* 筧 */, 0xF3C8 /* 笕 */,
0xB96B /* 筴 */, 0xB2DF /* 策 */,
0xB977 /* 箇 */, 0xB8F6 /* 个 */,
0xB97B /* 箋 */, 0xBCE3 /* 笺 */,
0xB97E /* 箏 */, 0xF3DD /* 筝 */,
0xB98A /* 箠 */, 0xE9A2 /* 棰 */,
0xB99D /* 節 */, 0xBDDA /* 节 */,
0xB9A0 /* 範 */, 0xB7B6 /* 范 */,
0xBA42 /* 築 */, 0xD6FE /* 筑 */,
0xBA44 /* 篋 */, 0xF3E6 /* 箧 */,
0xBA4F /* 篛 */, 0xF3E8 /* 箬 */,
0xBA53 /* 篠 */, 0xF3E3 /* 筱 */,
0xBA56 /* 篤 */, 0xF3C6 /* 笃 */,
0xBA59 /* 篩 */, 0xC9B8 /* 筛 */,
0xBA60 /* 篳 */, 0xF3D9 /* 筚 */,
0xBA6A /* 簀 */, 0xF3E5 /* 箦 */,
0xBA74 /* 簍 */, 0xC2A8 /* 篓 */,
0xBA77 /* 簑 */, 0xCBF2 /* 蓑 */,
0xBA84 /* 簞 */, 0xF3EC /* 箪 */,
0xBA86 /* 簡 */, 0xBCF2 /* 简 */,
0xBA88 /* 簣 */, 0xF3F1 /* 篑 */,
0xBA8D /* 簫 */, 0xF3EF /* 箫 */,
0xBA99 /* 簷 */, 0xE9DC /* 檐 */,
0xBA9A /* 簹 */, 0xB959 /* 筜 */,
0xBA9E /* 簽 */, 0xC7A9 /* 签 */,
0xBA9F /* 簾 */, 0xC1B1 /* 帘 */,
0xBB40 /* 籃 */, 0xC0BA /* 篮 */,
0xBB49 /* 籌 */, 0xB3EF /* 筹 */,
0xBB4C /* 籐 */, 0xCCD9 /* 藤 */,
0xBB55 /* 籙 */, 0xB982 /* 箓 */,
0xBB56 /* 籚 */, 0xC2AB /* 芦 */,
0xBB58 /* 籜 */, 0xF3EA /* 箨 */,
0xBB5B /* 籟 */, 0xF4A5 /* 籁 */,
0xBB5C /* 籠 */, 0xC1FD /* 笼 */,
0xBB5E /* 籢 */, 0xDEC6 /* 奁 */,
0xBB60 /* 籤 */, 0xC7A9 /* 签 */,
0xBB61 /* 籥 */, 0xD4BF /* 钥 */,
0xBB65 /* 籩 */, 0xF3D6 /* 笾 */,
0xBB66 /* 籪 */, 0xF3FD /* 簖 */,
0xBB68 /* 籬 */, 0xC0E9 /* 篱 */,
0xBB6A /* 籮 */, 0xC2E1 /* 箩 */,
0xBB6E /* 籲 */, 0xD3F5 /* 吁 */,
0xBB92 /* 粧 */, 0xD7B1 /* 妆 */,
0xBB96 /* 粬 */, 0xC7FA /* 曲 */,
0xBB9B /* 粵 */, 0xD4C1 /* 粤 */,
0xBC52 /* 糝 */, 0xF4D6 /* 糁 */,
0xBC53 /* 糞 */, 0xB7E0 /* 粪 */,
0xBC55 /* 糢 */, 0xC4A3 /* 模 */,
0xBC5A /* 糧 */, 0xC1B8 /* 粮 */,
0xBC61 /* 糰 */, 0xCDC5 /* 团 */,
0xBC63 /* 糲 */, 0xF4CF /* 粝 */,
0xBC65 /* 糴 */, 0xD9E1 /* 籴 */,
0xBC67 /* 糶 */, 0xF4D0 /* 粜 */,
0xBC69 /* 糹 */, 0xE6F9 /* 纟 */,
0xBC6D /* 糾 */, 0xBEC0 /* 纠 */,
0xBC6F /* 紀 */, 0xBCCD /* 纪 */,
0xBC71 /* 紂 */, 0xE6FB /* 纣 */,
0xBC73 /* 約 */, 0xD4BC /* 约 */,
0xBC74 /* 紅 */, 0xBAEC /* 红 */,
0xBC75 /* 紆 */, 0xE6FA /* 纡 */,
0xBC76 /* 紇 */, 0xE6FC /* 纥 */,
0xBC77 /* 紈 */, 0xE6FD /* 纨 */,
0xBC78 /* 紉 */, 0xC8D2 /* 纫 */,
0xBC79 /* 紋 */, 0xCEC6 /* 纹 */,
0xBC7B /* 納 */, 0xC4C9 /* 纳 */,
0xBC7E /* 紐 */, 0xC5A6 /* 纽 */,
0xBC82 /* 紓 */, 0xE7A3 /* 纾 */,
0xBC83 /* 純 */, 0xB4BF /* 纯 */,
0xBC84 /* 紕 */, 0xE7A2 /* 纰 */,
0xBC85 /* 紖 */, 0xC083 /* 纼 */,
0xBC86 /* 紗 */, 0xC9B4 /* 纱 */,
0xBC87 /* 紘 */, 0xC080 /* 纮 */,
0xBC88 /* 紙 */, 0xD6BD /* 纸 */,
0xBC89 /* 級 */, 0xBCB6 /* 级 */,
0xBC8A /* 紛 */, 0xB7D7 /* 纷 */,
0xBC8B /* 紜 */, 0xE7A1 /* 纭 */,
0xBC8C /* 紝 */, 0xC081 /* 纴 */,
0xBC8F /* 紡 */, 0xB7C4 /* 纺 */,
0xBC92 /* 紥 */, 0xD4FA /* 扎 */,
0xBC99 /* 紮 */, 0xD4FA /* 扎 */,
0xBC9A /* 細 */, 0xCFB8 /* 细 */,
0xBC9B /* 紱 */, 0xE7A6 /* 绂 */,
0xBC9C /* 紲 */, 0xE7A5 /* 绁 */,
0xBC9D /* 紳 */, 0xC9F0 /* 绅 */,
0xBC9F /* 紵 */, 0xC082 /* 纻 */,
0xBD42 /* 紹 */, 0xC9DC /* 绍 */,
0xBD43 /* 紺 */, 0xE7A4 /* 绀 */,
0xBD45 /* 紼 */, 0xE7A8 /* 绋 */,
0xBD48 /* 紿 */, 0xE7AA /* 绐 */,
0xBD49 /* 絀 */, 0xE7A9 /* 绌 */,
0xBD4B /* 終 */, 0xD6D5 /* 终 */,
0xBD4C /* 絃 */, 0xCFD2 /* 弦 */,
0xBD4D /* 組 */, 0xD7E9 /* 组 */,
0xBD4F /* 絆 */, 0xB0ED /* 绊 */,
0xBD56 /* 絍 */, 0xC081 /* 纴 */,
0xBD57 /* 絎 */, 0xE7AC /* 绗 */,
0xBD58 /* 絏 */, 0xE7A5 /* 绁 */,
0xBD59 /* 結 */, 0xBDE1 /* 结 */,
0xBD5E /* 絕 */, 0xBEF8 /* 绝 */,
0xBD64 /* 絛 */, 0xCCD0 /* 绦 */,
0xBD66 /* 絝 */, 0xE7AB /* 绔 */,
0xBD67 /* 絞 */, 0xBDCA /* 绞 */,
0xBD6A /* 絡 */, 0xC2E7 /* 络 */,
0xBD6B /* 絢 */, 0xD1A4 /* 绚 */,
0xBD6F /* 給 */, 0xB8F8 /* 给 */,
0xBD71 /* 絨 */, 0xC8DE /* 绒 */,
0xBD78 /* 絰 */, 0xC084 /* 绖 */,
0xBD79 /* 統 */, 0xCDB3 /* 统 */,
0xBD7A /* 絲 */, 0xCBBF /* 丝 */,
0xBD7B /* 絳 */, 0xE7AD /* 绛 */,
0xBD7E /* 絶 */, 0xBEF8 /* 绝 */,
0xBD81 /* 絹 */, 0xBEEE /* 绢 */,
0xBD89 /* 綁 */, 0xB0F3 /* 绑 */,
0xBD8B /* 綃 */, 0xE7AF /* 绡 */,
0xBD8E /* 綆 */, 0xE7AE /* 绠 */,
0xBD90 /* 綈 */, 0xE7B0 /* 绨 */,
0xBD91 /* 綉 */, 0xD0E5 /* 绣 */,
0xBD94 /* 綌 */, 0xC085 /* 绤 */,
0xBD97 /* 綏 */, 0xCBE7 /* 绥 */,
0xBD99 /* 綑 */, 0xC0A6 /* 捆 */,
0xBD9B /* 經 */, 0xBEAD /* 经 */,
0xBE43 /* 綜 */, 0xD7DB /* 综 */,
0xBE45 /* 綞 */, 0xE7B6 /* 缍 */,
0xBE47 /* 綠 */, 0xC2CC /* 绿 */,
0xBE49 /* 綢 */, 0xB3F1 /* 绸 */,
0xBE4A /* 綣 */, 0xE7B9 /* 绻 */,
0xBE51 /* 綫 */, 0xCFDF /* 线 */,
0xBE52 /* 綬 */, 0xE7B7 /* 绶 */,
0xBE53 /* 維 */, 0xCEAC /* 维 */,
0xBE54 /* 綯 */, 0xC087 /* 绹 */,
0xBE55 /* 綰 */, 0xE7BA /* 绾 */,
0xBE56 /* 綱 */, 0xB8D9 /* 纲 */,
0xBE57 /* 網 */, 0xCDF8 /* 网 */,
0xBE58 /* 綳 */, 0xB1C1 /* 绷 */,
0xBE59 /* 綴 */, 0xD7BA /* 缀 */,
0xBE5A /* 綵 */, 0xB2CA /* 彩 */,
0xBE5D /* 綸 */, 0xC2DA /* 纶 */,
0xBE5E /* 綹 */, 0xE7B8 /* 绺 */,
0xBE5F /* 綺 */, 0xE7B2 /* 绮 */,
0xBE60 /* 綻 */, 0xD5C0 /* 绽 */,
0xBE62 /* 綽 */, 0xB4C2 /* 绰 */,
0xBE63 /* 綾 */, 0xE7B1 /* 绫 */,
0xBE64 /* 綿 */, 0xC3E0 /* 绵 */,
0xBE69 /* 緄 */, 0xE7B5 /* 绲 */,
0xBE6C /* 緇 */, 0xE7BB /* 缁 */,
0xBE6F /* 緊 */, 0xBDF4 /* 紧 */,
0xBE70 /* 緋 */, 0xE7B3 /* 绯 */,
0xBE72 /* 緍 */, 0xE7C5 /* 缗 */,
0xBE76 /* 緑 */, 0xC2CC /* 绿 */,
0xBE77 /* 緒 */, 0xD0F7 /* 绪 */,
0xBE78 /* 緓 */, 0xC086 /* 绬 */,
0xBE79 /* 緔 */, 0xE7B4 /* 绱 */,
0xBE7C /* 緗 */, 0xE7BD /* 缃 */,
0xBE7D /* 緘 */, 0xBCEA /* 缄 */,
0xBE7E /* 緙 */, 0xE7BC /* 缂 */,
0xBE80 /* 線 */, 0xCFDF /* 线 */,
0xBE82 /* 緜 */, 0xC3E0 /* 绵 */,
0xBE83 /* 緝 */, 0xBCA9 /* 缉 */,
0xBE84 /* 緞 */, 0xB6D0 /* 缎 */,
0xBE86 /* 締 */, 0xB5DE /* 缔 */,
0xBE87 /* 緡 */, 0xE7C5 /* 缗 */,
0xBE89 /* 緣 */, 0xD4B5 /* 缘 */,
0xBE8A /* 緤 */, 0xE7A5 /* 绁 */,
0xBE8C /* 緦 */, 0xE7C1 /* 缌 */,
0xBE8E /* 編 */, 0xB1E0 /* 编 */,
0xBE8F /* 緩 */, 0xBBBA /* 缓 */,
0xBE92 /* 緬 */, 0xC3E5 /* 缅 */,
0xBE95 /* 緯 */, 0xCEB3 /* 纬 */,
0xBE97 /* 緱 */, 0xE7C3 /* 缑 */,
0xBE98 /* 緲 */, 0xE7BF /* 缈 */,
0xBE9A /* 練 */, 0xC1B7 /* 练 */,
0xBE9C /* 緶 */, 0xE7C2 /* 缏 */,
0xBE9F /* 緹 */, 0xE7BE /* 缇 */,
0xBF40 /* 緻 */, 0xD6C2 /* 致 */,
0xBF41 /* 緼 */, 0xC088 /* 缊 */,
0xBF47 /* 縂 */, 0xD7DC /* 总 */,
0xBF4D /* 縈 */, 0xDDD3 /* 萦 */,
0xBF4E /* 縉 */, 0xE7C6 /* 缙 */,
0xBF4F /* 縊 */, 0xE7CB /* 缢 */,
0xBF50 /* 縋 */, 0xE7C4 /* 缒 */,
0xBF55 /* 縐 */, 0xE7A7 /* 绉 */,
0xBF56 /* 縑 */, 0xE7CC /* 缣 */,
0xBF5A /* 縕 */, 0xC088 /* 缊 */,
0xBF5C /* 縗 */, 0xC08A /* 缞 */,
0xBF5F /* 縚 */, 0xCCD0 /* 绦 */,
0xBF60 /* 縛 */, 0xB8BF /* 缚 */,
0xBF62 /* 縝 */, 0xE7C7 /* 缜 */,
0xBF63 /* 縞 */, 0xE7C9 /* 缟 */,
0xBF64 /* 縟 */, 0xE7C8 /* 缛 */,
0xBF68 /* 縣 */, 0xCFD8 /* 县 */,
0xBF6C /* 縧 */, 0xCCD0 /* 绦 */,
0xBF70 /* 縫 */, 0xB7EC /* 缝 */,
0xBF72 /* 縭 */, 0xE7CA /* 缡 */,
0xBF73 /* 縮 */, 0xCBF5 /* 缩 */,
0xBF74 /* 縯 */, 0xD1DD /* 演 */,
0xBF76 /* 縱 */, 0xD7DD /* 纵 */,
0xBF77 /* 縲 */, 0xE7D0 /* 缧 */,
0xBF79 /* 縴 */, 0xCFCB /* 纤 */,
0xBF7A /* 縵 */, 0xE7CF /* 缦 */,
0xBF7B /* 縶 */, 0xF4EA /* 絷 */,
0xBF7C /* 縷 */, 0xC2C6 /* 缕 */,
0xBF7E /* 縹 */, 0xE7CE /* 缥 */,
0xBF82 /* 總 */, 0xD7DC /* 总 */,
0xBF83 /* 績 */, 0xBCA8 /* 绩 */,
0xBF87 /* 繃 */, 0xB1C1 /* 绷 */,
0xBF89 /* 繅 */, 0xE7D2 /* 缫 */,
0xBF8A /* 繆 */, 0xE7D1 /* 缪 */,
0xBF8B /* 繈 */, 0xF1DF /* 襁 */,
0xBF93 /* 繐 */, 0xBBDD /* 惠 */,
0xBF95 /* 繒 */, 0xE7D5 /* 缯 */,
0xBF97 /* 織 */, 0xD6AF /* 织 */,
0xBF98 /* 繕 */, 0xC9C9 /* 缮 */,
0xBF99 /* 繖 */, 0xC9A1 /* 伞 */,
0xBF9C /* 繙 */, 0xB7AD /* 翻 */,
0xBF9D /* 繚 */, 0xE7D4 /* 缭 */,
0xC040 /* 繞 */, 0xC8C6 /* 绕 */,
0xC043 /* 繡 */, 0xD0E5 /* 绣 */,
0xC044 /* 繢 */, 0xE7C0 /* 缋 */,
0xC048 /* 繦 */, 0xF1DF /* 襁 */,
0xC04B /* 繩 */, 0xC9FE /* 绳 */,
0xC04C /* 繪 */, 0xBBE6 /* 绘 */,
0xC04D /* 繫 */, 0xCFB5 /* 系 */,
0xC04F /* 繭 */, 0xBCEB /* 茧 */,
0xC050 /* 繮 */, 0xE7D6 /* 缰 */,
0xC051 /* 繯 */, 0xE7D9 /* 缳 */,
0xC052 /* 繰 */, 0xE7D8 /* 缲 */,
0xC055 /* 繳 */, 0xBDC9 /* 缴 */,
0xC05B /* 繹 */, 0xD2EF /* 绎 */,
0xC05E /* 繼 */, 0xBCCC /* 继 */,
0xC05F /* 繽 */, 0xE7CD /* 缤 */,
0xC060 /* 繾 */, 0xE7D7 /* 缱 */,
0xC068 /* 纇 */, 0xEF4B /* 颣 */,
0xC069 /* 纈 */, 0xE7D3 /* 缬 */,
0xC06B /* 纊 */, 0xE6FE /* 纩 */,
0xC06D /* 續 */, 0xD0F8 /* 续 */,
0xC06E /* 纍 */, 0xC0DB /* 累 */,
0xC070 /* 纏 */, 0xB2F8 /* 缠 */,
0xC074 /* 纓 */, 0xD3A7 /* 缨 */,
0xC077 /* 纖 */, 0xCFCB /* 纤 */,
0xC079 /* 纘 */, 0xE7DA /* 缵 */,
0xC07C /* 纜 */, 0xC0C2 /* 缆 */,
0xC08F /* 缽 */, 0xB2A7 /* 钵 */,
0xC097 /* 罈 */, 0xCCB3 /* 坛 */,
0xC09A /* 罋 */, 0xCECD /* 瓮 */,
0xC09B /* 罌 */, 0xF3BF /* 罂 */,
0xC09D /* 罎 */, 0xCCB3 /* 坛 */,
0xC09E /* 罏 */, 0xDBE4 /* 垆 */,
0xC150 /* 罰 */, 0xB7A3 /* 罚 */,
0xC152 /* 罵 */, 0xC2EE /* 骂 */,
0xC154 /* 罷 */, 0xB0D5 /* 罢 */,
0xC155 /* 罸 */, 0xB7A3 /* 罚 */,
0xC15F /* 羅 */, 0xC2DE /* 罗 */,
0xC160 /* 羆 */, 0xEEBC /* 罴 */,
0xC162 /* 羈 */, 0xEEBF /* 羁 */,
0xC164 /* 羋 */, 0xD8C2 /* 芈 */,
0xC173 /* 羢 */, 0xC8DE /* 绒 */,
0xC175 /* 羥 */, 0xF4C7 /* 羟 */,
0xC177 /* 羨 */, 0xCFDB /* 羡 */,
0xC178 /* 義 */, 0xD2E5 /* 义 */,
0xC183 /* 羶 */, 0xEBFE /* 膻 */,
0xC195 /* 習 */, 0xCFB0 /* 习 */,
0xC245 /* 翬 */, 0xC19A /* 翚 */,
0xC24E /* 翹 */, 0xC7CC /* 翘 */,
0xC24F /* 翺 */, 0xB0BF /* 翱 */,
0xC250 /* 翽 */, 0xC199 /* 翙 */,
0xC25A /* 耑 */, 0xB6CB /* 端 */,
0xC261 /* 耡 */, 0xB3FA /* 锄 */,
0xC265 /* 耬 */, 0xF1EF /* 耧 */,
0xC267 /* 耮 */, 0xF1EC /* 耢 */,
0xC27D /* 聖 */, 0xCAA5 /* 圣 */,
0xC284 /* 聞 */, 0xCEC5 /* 闻 */,
0xC293 /* 聯 */, 0xC1AA /* 联 */,
0xC294 /* 聰 */, 0xB4CF /* 聪 */,
0xC295 /* 聲 */, 0xC9F9 /* 声 */,
0xC296 /* 聳 */, 0xCBCA /* 耸 */,
0xC298 /* 聵 */, 0xF1F9 /* 聩 */,
0xC299 /* 聶 */, 0xC4F4 /* 聂 */,
0xC29A /* 職 */, 0xD6B0 /* 职 */,
0xC29C /* 聹 */, 0xF1F7 /* 聍 */,
0xC29F /* 聼 */, 0xCCFD /* 听 */,
0xC2A0 /* 聽 */, 0xCCFD /* 听 */,
0xC340 /* 聾 */, 0xC1FB /* 聋 */,
0xC343 /* 肅 */, 0xCBE0 /* 肃 */,
0xC35E /* 胇 */, 0xDBCF /* 巯 */,
0xC37B /* 脅 */, 0xD0B2 /* 胁 */,
0xC37C /* 脇 */, 0xD0B2 /* 胁 */,
0xC37D /* 脈 */, 0xC2F6 /* 脉 */,
0xC384 /* 脛 */, 0xEBD6 /* 胫 */,
0xC38B /* 脣 */, 0xB4BD /* 唇 */,
0xC391 /* 脩 */, 0xD0DE /* 修 */,
0xC393 /* 脫 */, 0xCDD1 /* 脱 */,
0xC39B /* 脹 */, 0xD5CD /* 胀 */,
0xC449 /* 腎 */, 0xC9F6 /* 肾 */,
0xC44C /* 腖 */, 0xEBCB /* 胨 */,
0xC454 /* 腡 */, 0xEBE1 /* 脶 */,
0xC458 /* 腦 */, 0xC4D4 /* 脑 */,
0xC45B /* 腫 */, 0xD6D7 /* 肿 */,
0xC45F /* 腳 */, 0xBDC5 /* 脚 */,
0xC463 /* 腸 */, 0xB3A6 /* 肠 */,
0xC464 /* 膁 */, 0xEBC9 /* 肷 */,
0xC465 /* 膃 */, 0xEBF0 /* 腽 */,
0xC468 /* 膆 */, 0xE0BC /* 嗉 */,
0xC473 /* 膕 */, 0xC44E /* 腘 */,
0xC477 /* 膚 */, 0xB7F4 /* 肤 */,
0xC47A /* 膠 */, 0xBDBA /* 胶 */,
0xC481 /* 膩 */, 0xC4E5 /* 腻 */,
0xC482 /* 膫 */, 0xC1CB /* 了 */,
0xC491 /* 膽 */, 0xB5A8 /* 胆 */,
0xC492 /* 膾 */, 0xEBDA /* 脍 */,
0xC493 /* 膿 */, 0xC5A7 /* 脓 */,
0xC498 /* 臉 */, 0xC1B3 /* 脸 */,
0xC49A /* 臍 */, 0xC6EA /* 脐 */,
0xC49C /* 臏 */, 0xEBF7 /* 膑 */,
0xC49F /* 臒 */, 0xF1B3 /* 癯 */,
0xC544 /* 臘 */, 0xC0B0 /* 腊 */,
0xC546 /* 臚 */, 0xEBCD /* 胪 */,
0xC54B /* 臟 */, 0xD4E0 /* 脏 */,
0xC54C /* 臠 */, 0xD9F5 /* 脔 */,
0xC54E /* 臢 */, 0xC548 /* 臜 */,
0xC550 /* 臥 */, 0xCED4 /* 卧 */,
0xC552 /* 臨 */, 0xC1D9 /* 临 */,
0xC556 /* 臯 */, 0xB8DE /* 皋 */,
0xC55F /* 臺 */, 0xCCA8 /* 台 */,
0xC563 /* 與 */, 0xD3EB /* 与 */,
0xC564 /* 興 */, 0xD0CB /* 兴 */,
0xC565 /* 舉 */, 0xBED9 /* 举 */,
0xC566 /* 舊 */, 0xBEC9 /* 旧 */,
0xC567 /* 舋 */, 0xD0C6 /* 衅 */,
0xC56D /* 舖 */, 0xC6CC /* 铺 */,
0xC56F /* 舘 */, 0xB9DD /* 馆 */,
0xC593 /* 艙 */, 0xB2D5 /* 舱 */,
0xC594 /* 艛 */, 0xC2A6 /* 娄 */,
0xC59A /* 艢 */, 0xE9C9 /* 樯 */,
0xC59B /* 艣 */, 0xE9D6 /* 橹 */,
0xC59C /* 艤 */, 0xF4AF /* 舣 */,
0xC59E /* 艦 */, 0xBDA2 /* 舰 */,
0xC640 /* 艪 */, 0xE9D6 /* 橹 */,
0xC641 /* 艫 */, 0xF4B5 /* 舻 */,
0xC644 /* 艱 */, 0xBCE8 /* 艰 */,
0xC647 /* 艷 */, 0xD1DE /* 艳 */,
0xC648 /* 艸 */, 0xDCB3 /* 艹 */,
0xC663 /* 芻 */, 0xDBBB /* 刍 */,
0xC672 /* 苧 */, 0xDCD1 /* 苎 */,
0xC69D /* 茲 */, 0xD7C8 /* 兹 */,
0xC747 /* 荊 */, 0xBEA3 /* 荆 */,
0xC757 /* 荳 */, 0xB6B9 /* 豆 */,
0xC766 /* 莊 */, 0xD7AF /* 庄 */,
0xC76F /* 莖 */, 0xBEA5 /* 茎 */,
0xC776 /* 莢 */, 0xBCD4 /* 荚 */,
0xC77B /* 莧 */, 0xDCC8 /* 苋 */,
0xC79E /* 菫 */, 0xDDC0 /* 堇 */,
0xC841 /* 華 */, 0xBBAA /* 华 */,
0xC843 /* 菴 */, 0xE2D6 /* 庵 */,
0xC84F /* 萇 */, 0xDCC9 /* 苌 */,
0xC852 /* 萊 */, 0xC0B3 /* 莱 */,
0xC866 /* 萬 */, 0xCDF2 /* 万 */,
0xC86E /* 萵 */, 0xDDAB /* 莴 */,
0xC871 /* 萹 */, 0xB1E2 /* 扁 */,
0xC87E /* 葉 */, 0xD2B6 /* 叶 */,
0xC887 /* 葒 */, 0xDDA6 /* 荭 */,
0xC890 /* 葠 */, 0xB2CE /* 参 */,
0xC892 /* 葤 */, 0xDDA7 /* 荮 */,
0xC894 /* 葦 */, 0xCEAD /* 苇 */,
0xC899 /* 葯 */, 0xD2A9 /* 药 */,
0xC89D /* 葷 */, 0xBBE7 /* 荤 */,
0xC94C /* 蒐 */, 0xCBD1 /* 搜 */,
0xC94F /* 蒓 */, 0xDDBB /* 莼 */,
0xC950 /* 蒔 */, 0xDDAA /* 莳 */,
0xC957 /* 蒞 */, 0xDDB0 /* 莅 */,
0xC96E /* 蒼 */, 0xB2D4 /* 苍 */,
0xC970 /* 蓀 */, 0xDDA5 /* 荪 */,
0xC974 /* 蓆 */, 0xCFAF /* 席 */,
0xC977 /* 蓋 */, 0xB8C7 /* 盖 */,
0xC986 /* 蓡 */, 0xB2CE /* 参 */,
0xC989 /* 蓧 */, 0xDDAF /* 莜 */,
0xC98F /* 蓮 */, 0xC1AB /* 莲 */,
0xC990 /* 蓯 */, 0xDCCA /* 苁 */,
0xC994 /* 蓴 */, 0xDDBB /* 莼 */,
0xC99C /* 蓽 */, 0xDCEA /* 荜 */,
0xCA43 /* 蔆 */, 0xC1E2 /* 菱 */,
0xCA4E /* 蔔 */, 0xB2B7 /* 卜 */,
0xCA56 /* 蔞 */, 0xDDE4 /* 蒌 */,
0xCA59 /* 蔣 */, 0xBDAF /* 蒋 */,
0xCA5B /* 蔥 */, 0xB4D0 /* 葱 */,
0xCA5C /* 蔦 */, 0xDCE0 /* 茑 */,
0xCA61 /* 蔭 */, 0xD2F1 /* 荫 */,
0xCA68 /* 蔴 */, 0xC2E9 /* 麻 */,
0xCA6E /* 蕁 */, 0xDDA1 /* 荨 */,
0xCA72 /* 蕆 */, 0xDDDB /* 蒇 */,
0xCA77 /* 蕎 */, 0xDCF1 /* 荞 */,
0xCA7B /* 蕒 */, 0xDDA4 /* 荬 */,
0xCA7C /* 蕓 */, 0xDCBF /* 芸 */,
0xCA7E /* 蕕 */, 0xDDB5 /* 莸 */,
0xCA81 /* 蕘 */, 0xDCE9 /* 荛 */,
0xCA89 /* 蕢 */, 0xDDDE /* 蒉 */,
0xCA8E /* 蕩 */, 0xB5B4 /* 荡 */,
0xCA8F /* 蕪 */, 0xCEDF /* 芜 */,
0xCA92 /* 蕭 */, 0xCFF4 /* 萧 */,
0xCA9A /* 蕷 */, 0xDDF7 /* 蓣 */,
0xCB43 /* 薈 */, 0xDCF6 /* 荟 */,
0xCB45 /* 薊 */, 0xBCBB /* 蓟 */,
0xCB47 /* 薌 */, 0xDCBC /* 芗 */,
0xCB4B /* 薑 */, 0xBDAA /* 姜 */,
0xCB4E /* 薔 */, 0xC7BE /* 蔷 */,
0xCB52 /* 薘 */, 0xC751 /* 荙 */,
0xCB53 /* 薙 */, 0xCCEA /* 剃 */,
0xCB57 /* 薟 */, 0xDDB2 /* 莶 */,
0xCB5D /* 薦 */, 0xBCF6 /* 荐 */,
0xCB5F /* 薩 */, 0xC8F8 /* 萨 */,
0xCB6A /* 薺 */, 0xDCF9 /* 荠 */,
0xCB7B /* 藍 */, 0xC0B6 /* 蓝 */,
0xCB7C /* 藎 */, 0xDDA3 /* 荩 */,
0xCB87 /* 藝 */, 0xD2D5 /* 艺 */,
0xCB8E /* 藥 */, 0xD2A9 /* 药 */,
0xCB92 /* 藪 */, 0xDEB4 /* 薮 */,
0xCB9C /* 藴 */, 0xD4CC /* 蕴 */,
0xCB9E /* 藶 */, 0xDCC2 /* 苈 */,
0xCBDB /* 僳 */, 0xC0FC /* 傈 */,
0xCC40 /* 藹 */, 0xB0AA /* 蔼 */,
0xCC41 /* 藺 */, 0xDDFE /* 蔺 */,
0xCC45 /* 蘀 */, 0xC85B /* 萚 */,
0xCC49 /* 蘄 */, 0xDEAD /* 蕲 */,
0xCC4A /* 蘆 */, 0xC2AB /* 芦 */,
0xCC4B /* 蘇 */, 0xCBD5 /* 苏 */,
0xCC4E /* 蘊 */, 0xD4CC /* 蕴 */,
0xCC4F /* 蘋 */, 0xC6BB /* 苹 */,
0xCC59 /* 蘗 */, 0xDEC1 /* 蘖 */,
0xCC5C /* 蘚 */, 0xDEBA /* 藓 */,
0xCC60 /* 蘞 */, 0xDDFC /* 蔹 */,
0xCC64 /* 蘢 */, 0xDCD7 /* 茏 */,
0xCC6D /* 蘭 */, 0xC0BC /* 兰 */,
0xCC79 /* 蘺 */, 0xDDF1 /* 蓠 */,
0xCC7D /* 蘿 */, 0xC2DC /* 萝 */,
0xCC8E /* 處 */, 0xB4A6 /* 处 */,
0xCC93 /* 虛 */, 0xD0E9 /* 虚 */,
0xCC94 /* 虜 */, 0xC2B2 /* 虏 */,
0xCC96 /* 號 */, 0xBAC5 /* 号 */,
0xCC9D /* 虧 */, 0xBFF7 /* 亏 */,
0xCD41 /* 虯 */, 0xF2B0 /* 虬 */,
0xCD90 /* 蛺 */, 0xF2CC /* 蛱 */,
0xCD91 /* 蛻 */, 0xCDC9 /* 蜕 */,
0xCD98 /* 蜆 */, 0xF2B9 /* 蚬 */,
0xCE67 /* 蝕 */, 0xCAB4 /* 蚀 */,
0xCE6F /* 蝟 */, 0xE2AC /* 猬 */,
0xCE72 /* 蝦 */, 0xCFBA /* 虾 */,
0xCE74 /* 蝨 */, 0xCAAD /* 虱 */,
0xCE81 /* 蝸 */, 0xCECF /* 蜗 */,
0xCE87 /* 螄 */, 0xF2CF /* 蛳 */,
0xCE95 /* 螘 */, 0xD2CF /* 蚁 */,
0xCE9B /* 螞 */, 0xC2EC /* 蚂 */,
0xCE9E /* 螢 */, 0xD3A9 /* 萤 */,
0xCF4E /* 螻 */, 0xF2F7 /* 蝼 */,
0xCF51 /* 螿 */, 0xCE85 /* 螀 */,
0xCF55 /* 蟄 */, 0xD5DD /* 蛰 */,
0xCF58 /* 蟈 */, 0xF2E5 /* 蝈 */,
0xCF5C /* 蟎 */, 0xF2FD /* 螨 */,
0xCF67 /* 蟝 */, 0xC7FE /* 渠 */,
0xCF6C /* 蟣 */, 0xF2B1 /* 虮 */,
0xCF73 /* 蟬 */, 0xB2F5 /* 蝉 */,
0xCF75 /* 蟯 */, 0xF2CD /* 蛲 */,
0xCF78 /* 蟲 */, 0xB3E6 /* 虫 */,
0xCF79 /* 蟳 */, 0xF6E0 /* 鲟 */,
0xCF7C /* 蟶 */, 0xF2C9 /* 蛏 */,
0xCF81 /* 蟻 */, 0xD2CF /* 蚁 */,
0xCF89 /* 蠅 */, 0xD3AC /* 蝇 */,
0xCF8A /* 蠆 */, 0xF2B2 /* 虿 */,
0xCF90 /* 蠍 */, 0xD0AB /* 蝎 */,
0xCF93 /* 蠐 */, 0xF2D3 /* 蛴 */,
0xCF94 /* 蠑 */, 0xF2EE /* 蝾 */,
0xCF96 /* 蠔 */, 0xF2BA /* 蚝 */,
0xCF9E /* 蠟 */, 0xC0AF /* 蜡 */,
0xCFA0 /* 蠣 */, 0xF2C3 /* 蛎 */,
0xD044 /* 蠨 */, 0xCF5D /* 蟏 */,
0xD04D /* 蠱 */, 0xB9C6 /* 蛊 */,
0xD051 /* 蠶 */, 0xB2CF /* 蚕 */,
0xD055 /* 蠻 */, 0xC2F9 /* 蛮 */,
0xD05B /* 衃 */, 0xB1AD /* 杯 */,
0xD05C /* 衆 */, 0xD6DA /* 众 */,
0xD060 /* 衊 */, 0xC3EF /* 蔑 */,
0xD066 /* 衒 */, 0xECC5 /* 炫 */,
0xD067 /* 術 */, 0xCAF5 /* 术 */,
0xD06B /* 衚 */, 0xBAFA /* 胡 */,
0xD06C /* 衛 */, 0xCEC0 /* 卫 */,
0xD06E /* 衝 */, 0xB3E5 /* 冲 */,
0xD06F /* 衞 */, 0xCEC0 /* 卫 */,
0xD07D /* 衹 */, 0xD6BB /* 只 */,
0xD096 /* 袞 */, 0xD9F2 /* 衮 */,
0xD0A0 /* 袪 */, 0xECEE /* 祛 */,
0xD155 /* 裊 */, 0xF4C1 /* 袅 */,
0xD157 /* 裌 */, 0xBCD0 /* 夹 */,
0xD159 /* 裏 */, 0xC0EF /* 里 */,
0xD161 /* 補 */, 0xB2B9 /* 补 */,
0xD162 /* 裝 */, 0xD7B0 /* 装 */,
0xD165 /* 裡 */, 0xC0EF /* 里 */,
0xD175 /* 製 */, 0xD6C6 /* 制 */,
0xD17D /* 複 */, 0xB8B4 /* 复 */,
0xD182 /* 褌 */, 0xD154 /* 裈 */,
0xD18B /* 褘 */, 0xD084 /* 袆 */,
0xD19D /* 褲 */, 0xBFE3 /* 裤 */,
0xD19E /* 褳 */, 0xF1CD /* 裢 */,
0xD240 /* 褸 */, 0xF1DA /* 褛 */,
0xD243 /* 褻 */, 0xD9F4 /* 亵 */,
0xD24C /* 襆 */, 0xE1A5 /* 幞 */,
0xD24D /* 襇 */, 0xF1D0 /* 裥 */,
0xD24F /* 襉 */, 0xF1D0 /* 裥 */,
0xD253 /* 襍 */, 0xD4D3 /* 杂 */,
0xD255 /* 襏 */, 0xD142 /* 袯 */,
0xD25C /* 襖 */, 0xB0C0 /* 袄 */,
0xD263 /* 襝 */, 0xF1CF /* 裣 */,
0xD264 /* 襠 */, 0xF1C9 /* 裆 */,
0xD268 /* 襤 */, 0xF1DC /* 褴 */,
0xD26D /* 襪 */, 0xCDE0 /* 袜 */,
0xD272 /* 襯 */, 0xB3C4 /* 衬 */,
0xD275 /* 襲 */, 0xCFAE /* 袭 */,
0xD277 /* 襴 */, 0xD25B /* 襕 */,
0xD287 /* 覈 */, 0xBACB /* 核 */,
0xD28A /* 見 */, 0xBCFB /* 见 */,
0xD28D /* 覎 */, 0xD35F /* 觃 */,
0xD28E /* 規 */, 0xB9E6 /* 规 */,
0xD292 /* 覓 */, 0xC3D9 /* 觅 */,
0xD293 /* 覔 */, 0xC3D9 /* 觅 */,
0xD295 /* 視 */, 0xCAD3 /* 视 */,
0xD297 /* 覘 */, 0xEAE8 /* 觇 */,
0xD29B /* 覜 */, 0xCCF7 /* 眺 */,
0xD2A0 /* 覡 */, 0xEAEA /* 觋 */,
0xD343 /* 覥 */, 0xD360 /* 觍 */,
0xD344 /* 覦 */, 0xEAEC /* 觎 */,
0xD348 /* 親 */, 0xC7D7 /* 亲 */,
0xD34A /* 覬 */, 0xEAE9 /* 觊 */,
0xD34D /* 覯 */, 0xEAED /* 觏 */,
0xD34E /* 覰 */, 0xEAEF /* 觑 */,
0xD350 /* 覲 */, 0xEAEE /* 觐 */,
0xD355 /* 覷 */, 0xEAEF /* 觑 */,
0xD358 /* 覺 */, 0xBEF5 /* 觉 */,
0xD359 /* 覻 */, 0xEAEF /* 觑 */,
0xD35B /* 覽 */, 0xC0C0 /* 览 */,
0xD35D /* 覿 */, 0xEAEB /* 觌 */,
0xD35E /* 觀 */, 0xB9DB /* 观 */,
0xD362 /* 觔 */, 0xBDEE /* 筋 */,
0xD368 /* 觝 */, 0xB5D6 /* 抵 */,
0xD378 /* 觴 */, 0xF5FC /* 觞 */,
0xD37A /* 觶 */, 0xF6A3 /* 觯 */,
0xD37C /* 觸 */, 0xB4A5 /* 触 */,
0xD385 /* 訁 */, 0xDAA5 /* 讠 */,
0xD386 /* 訂 */, 0xB6A9 /* 订 */,
0xD387 /* 訃 */, 0xB8BC /* 讣 */,
0xD38B /* 計 */, 0xBCC6 /* 计 */,
0xD38D /* 訊 */, 0xD1B6 /* 讯 */,
0xD38F /* 訌 */, 0xDAA7 /* 讧 */,
0xD391 /* 討 */, 0xCCD6 /* 讨 */,
0xD392 /* 訏 */, 0xD3F5 /* 吁 */,
0xD393 /* 訐 */, 0xDAA6 /* 讦 */,
0xD395 /* 訒 */, 0xD79A /* 讱 */,
0xD396 /* 訓 */, 0xD1B5 /* 训 */,
0xD398 /* 訕 */, 0xDAA8 /* 讪 */,
0xD399 /* 訖 */, 0xC6FD /* 讫 */,
0xD39A /* 託 */, 0xCDD0 /* 托 */,
0xD39B /* 記 */, 0xBCC7 /* 记 */,
0xD39E /* 訛 */, 0xB6EF /* 讹 */,
0xD3A0 /* 訝 */, 0xD1C8 /* 讶 */,
0xD441 /* 訟 */, 0xCBCF /* 讼 */,
0xD444 /* 訢 */, 0xD0C0 /* 欣 */,
0xD445 /* 訣 */, 0xBEF7 /* 诀 */,
0xD447 /* 訥 */, 0xDAAB /* 讷 */,
0xD448 /* 訦 */, 0xDAC8 /* 谌 */,
0xD44B /* 訩 */, 0xD79B /* 讻 */,
0xD44C /* 訪 */, 0xB7C3 /* 访 */,
0xD44F /* 設 */, 0xC9E8 /* 设 */,
0xD453 /* 許 */, 0xD0ED /* 许 */,
0xD456 /* 訴 */, 0xCBDF /* 诉 */,
0xD458 /* 訶 */, 0xDAAD /* 诃 */,
0xD45C /* 診 */, 0xD5EF /* 诊 */,
0xD45D /* 註 */, 0xD7A2 /* 注 */,
0xD45E /* 証 */, 0xD6A4 /* 证 */,
0xD462 /* 詁 */, 0xDAAC /* 诂 */,
0xD467 /* 詆 */, 0xDAAE /* 诋 */,
0xD46E /* 詎 */, 0xDAAA /* 讵 */,
0xD470 /* 詐 */, 0xD5A9 /* 诈 */,
0xD472 /* 詒 */, 0xDAB1 /* 诒 */,
0xD474 /* 詔 */, 0xDAAF /* 诏 */,
0xD475 /* 評 */, 0xC6C0 /* 评 */,
0xD476 /* 詖 */, 0xD79D /* 诐 */,
0xD477 /* 詗 */, 0xD79C /* 诇 */,
0xD478 /* 詘 */, 0xDAB0 /* 诎 */,
0xD47B /* 詛 */, 0xD7E7 /* 诅 */,
0xD47E /* 詞 */, 0xB4CA /* 词 */,
0xD481 /* 詠 */, 0xD3BD /* 咏 */,
0xD482 /* 詡 */, 0xDABC /* 诩 */,
0xD483 /* 詢 */, 0xD1AF /* 询 */,
0xD484 /* 詣 */, 0xD2E8 /* 诣 */,
0xD487 /* 試 */, 0xCAD4 /* 试 */,
0xD48A /* 詩 */, 0xCAAB /* 诗 */,
0xD48C /* 詫 */, 0xB2EF /* 诧 */,
0xD48D /* 詬 */, 0xDAB8 /* 诟 */,
0xD48E /* 詭 */, 0xB9EE /* 诡 */,
0xD48F /* 詮 */, 0xDAB9 /* 诠 */,
0xD491 /* 詰 */, 0xDAB5 /* 诘 */,
0xD492 /* 話 */, 0xBBB0 /* 话 */,
0xD493 /* 該 */, 0xB8C3 /* 该 */,
0xD494 /* 詳 */, 0xCFEA /* 详 */,
0xD496 /* 詵 */, 0xDAB7 /* 诜 */,
0xD49C /* 詼 */, 0xDAB6 /* 诙 */,
0xD49E /* 詾 */, 0xD79B /* 讻 */,
0xD49F /* 詿 */, 0xDAB4 /* 诖 */,
0xD543 /* 誄 */, 0xDAB3 /* 诔 */,
0xD544 /* 誅 */, 0xD6EF /* 诛 */,
0xD545 /* 誆 */, 0xDAB2 /* 诓 */,
0xD546 /* 誇 */, 0xBFE4 /* 夸 */,
0xD549 /* 誌 */, 0xD6BE /* 志 */,
0xD54A /* 認 */, 0xC8CF /* 认 */,
0xD54E /* 誑 */, 0xDABF /* 诳 */,
0xD54F /* 誒 */, 0xDAC0 /* 诶 */,
0xD551 /* 誕 */, 0xB5AE /* 诞 */,
0xD554 /* 誘 */, 0xD3D5 /* 诱 */,
0xD556 /* 誚 */, 0xDABD /* 诮 */,
0xD55A /* 語 */, 0xD3EF /* 语 */,
0xD55C /* 誠 */, 0xB3CF /* 诚 */,
0xD55D /* 誡 */, 0xBDEB /* 诫 */,
0xD55F /* 誣 */, 0xCEDC /* 诬 */,
0xD560 /* 誤 */, 0xCEF3 /* 误 */,
0xD561 /* 誥 */, 0xDABE /* 诰 */,
0xD562 /* 誦 */, 0xCBD0 /* 诵 */,
0xD564 /* 誨 */, 0xBBE5 /* 诲 */,
0xD566 /* 說 */, 0xCBB5 /* 说 */,
0xD568 /* 説 */, 0xCBB5 /* 说 */,
0xD56C /* 誰 */, 0xCBAD /* 谁 */,
0xD56E /* 課 */, 0xBFCE /* 课 */,
0xD572 /* 誶 */, 0xDAC7 /* 谇 */,
0xD575 /* 誹 */, 0xB7CC /* 诽 */,
0xD578 /* 誼 */, 0xD2EA /* 谊 */,
0xD57B /* 調 */, 0xB5F7 /* 调 */,
0xD57E /* 諂 */, 0xDAC6 /* 谄 */,
0xD581 /* 諄 */, 0xD7BB /* 谆 */,
0xD584 /* 談 */, 0xCCB8 /* 谈 */,
0xD586 /* 諉 */, 0xDAC3 /* 诿 */,
0xD588 /* 請 */, 0xC7EB /* 请 */,
0xD58A /* 諍 */, 0xDABA /* 诤 */,
0xD58C /* 諏 */, 0xDAC1 /* 诹 */,
0xD58E /* 諑 */, 0xDAC2 /* 诼 */,
0xD58F /* 諒 */, 0xC1C2 /* 谅 */,
0xD593 /* 論 */, 0xC2DB /* 论 */,
0xD594 /* 諗 */, 0xDAC5 /* 谂 */,
0xD598 /* 諛 */, 0xDAC4 /* 谀 */,
0xD599 /* 諜 */, 0xB5FD /* 谍 */,
0xD59A /* 諝 */, 0xD7A0 /* 谞 */,
0xD59B /* 諞 */, 0xDAD2 /* 谝 */,
0xD59D /* 諠 */, 0xD0FA /* 喧 */,
0xD59E /* 諡 */, 0xDAD6 /* 谥 */,
0xD59F /* 諢 */, 0xDABB /* 诨 */,
0xD640 /* 諤 */, 0xDACC /* 谔 */,
0xD642 /* 諦 */, 0xDAD0 /* 谛 */,
0xD643 /* 諧 */, 0xD0B3 /* 谐 */,
0xD647 /* 諫 */, 0xDAC9 /* 谏 */,
0xD649 /* 諭 */, 0xDACD /* 谕 */,
0xD64A /* 諮 */, 0xDAD1 /* 谘 */,
0xD64D /* 諱 */, 0xBBE4 /* 讳 */,
0xD64F /* 諳 */, 0xDACF /* 谙 */,
0xD652 /* 諶 */, 0xDAC8 /* 谌 */,
0xD653 /* 諷 */, 0xB7ED /* 讽 */,
0xD654 /* 諸 */, 0xD6EE /* 诸 */,
0xD656 /* 諺 */, 0xD1E8 /* 谚 */,
0xD658 /* 諼 */, 0xDACE /* 谖 */,
0xD65A /* 諾 */, 0xC5B5 /* 诺 */,
0xD65C /* 謀 */, 0xC4B1 /* 谋 */,
0xD65D /* 謁 */, 0xDACB /* 谒 */,
0xD65E /* 謂 */, 0xCEBD /* 谓 */,
0xD660 /* 謄 */, 0xCCDC /* 誊 */,
0xD661 /* 謅 */, 0xD6DF /* 诌 */,
0xD665 /* 謊 */, 0xBBD1 /* 谎 */,
0xD669 /* 謎 */, 0xC3D5 /* 谜 */,
0xD66B /* 謐 */, 0xDAD7 /* 谧 */,
0xD66F /* 謔 */, 0xDACA /* 谑 */,
0xD671 /* 謖 */, 0xDAD5 /* 谡 */,
0xD672 /* 謗 */, 0xB0F9 /* 谤 */,
0xD674 /* 謙 */, 0xC7AB /* 谦 */,
0xD675 /* 謚 */, 0xDAD6 /* 谥 */,
0xD676 /* 講 */, 0xBDB2 /* 讲 */,
0xD678 /* 謝 */, 0xD0BB /* 谢 */,
0xD67B /* 謠 */, 0xD2A5 /* 谣 */,
0xD67C /* 謡 */, 0xD2A5 /* 谣 */,
0xD683 /* 謨 */, 0xDAD3 /* 谟 */,
0xD686 /* 謫 */, 0xDAD8 /* 谪 */,
0xD687 /* 謬 */, 0xC3FD /* 谬 */,
0xD688 /* 謭 */, 0xDAD9 /* 谫 */,
0xD68E /* 謳 */, 0xDAA9 /* 讴 */,
0xD694 /* 謹 */, 0xBDF7 /* 谨 */,
0xD699 /* 謾 */, 0xC3A1 /* 谩 */,
0xD69C /* 譁 */, 0xBBA9 /* 哗 */,
0xD740 /* 譆 */, 0xCEFB /* 嘻 */,
0xD743 /* 證 */, 0xD6A4 /* 证 */,
0xD746 /* 譌 */, 0xB6EF /* 讹 */,
0xD748 /* 譎 */, 0xDADC /* 谲 */,
0xD749 /* 譏 */, 0xBCA5 /* 讥 */,
0xD74E /* 譔 */, 0xD7AB /* 撰 */,
0xD750 /* 譖 */, 0xDADA /* 谮 */,
0xD752 /* 識 */, 0xCAB6 /* 识 */,
0xD753 /* 譙 */, 0xDADB /* 谯 */,
0xD754 /* 譚 */, 0xCCB7 /* 谭 */,
0xD756 /* 譜 */, 0xC6D7 /* 谱 */,
0xD759 /* 譟 */, 0xD4EB /* 噪 */,
0xD764 /* 譫 */, 0xDADE /* 谵 */,
0xD765 /* 譭 */, 0xBBD9 /* 毁 */,
0xD767 /* 譯 */, 0xD2EB /* 译 */,
0xD768 /* 議 */, 0xD2E9 /* 议 */,
0xD76C /* 譴 */, 0xC7B4 /* 谴 */,
0xD76F /* 護 */, 0xBBA4 /* 护 */,
0xD770 /* 譸 */, 0xD79E /* 诪 */,
0xD775 /* 譽 */, 0xD3FE /* 誉 */,
0xD776 /* 譾 */, 0xDAD9 /* 谫 */,
0xD778 /* 讀 */, 0xB6C1 /* 读 */,
0xD779 /* 讁 */, 0xDAD8 /* 谪 */,
0xD77D /* 讅 */, 0xC9F3 /* 审 */,
0xD783 /* 變 */, 0xB1E4 /* 变 */,
0xD784 /* 讋 */, 0xD480 /* 詟 */,
0xD785 /* 讌 */, 0xD1E0 /* 燕 */,
0xD787 /* 讎 */, 0xF6C5 /* 雠 */,
0xD789 /* 讐 */, 0xF6C5 /* 雠 */,
0xD78B /* 讒 */, 0xB2F7 /* 谗 */,
0xD78C /* 讓 */, 0xC8C3 /* 让 */,
0xD78E /* 讕 */, 0xC0BE /* 谰 */,
0xD78F /* 讖 */, 0xDADF /* 谶 */,
0xD793 /* 讚 */, 0xD4DE /* 赞 */,
0xD794 /* 讛 */, 0xDFBD /* 呓 */,
0xD795 /* 讜 */, 0xDAD4 /* 谠 */,
0xD797 /* 讞 */, 0xDADD /* 谳 */,
0xD847 /* 谿 */, 0xCFAA /* 溪 */,
0xD84D /* 豈 */, 0xC6F1 /* 岂 */,
0xD84F /* 豋 */, 0xB5C7 /* 登 */,
0xD851 /* 豎 */, 0xCAFA /* 竖 */,
0xD853 /* 豐 */, 0xB7E1 /* 丰 */,
0xD857 /* 豔 */, 0xD1DE /* 艳 */,
0xD858 /* 豖 */, 0xD8A1 /* 亍 */,
0xD869 /* 豬 */, 0xD6ED /* 猪 */,
0xD872 /* 豶 */, 0xD86B /* 豮 */,
0xD882 /* 貍 */, 0xC0EA /* 狸 */,
0xD888 /* 貓 */, 0xC3A8 /* 猫 */,
0xD890 /* 貝 */, 0xB1B4 /* 贝 */,
0xD891 /* 貞 */, 0xD5EA /* 贞 */,
0xD892 /* 貟 */, 0xDA4F /* 贠 */,
0xD893 /* 負 */, 0xB8BA /* 负 */,
0xD894 /* 財 */, 0xB2C6 /* 财 */,
0xD895 /* 貢 */, 0xB9B1 /* 贡 */,
0xD89A /* 貧 */, 0xC6B6 /* 贫 */,
0xD89B /* 貨 */, 0xBBF5 /* 货 */,
0xD89C /* 販 */, 0xB7B7 /* 贩 */,
0xD89D /* 貪 */, 0xCCB0 /* 贪 */,
0xD89E /* 貫 */, 0xB9E1 /* 贯 */,
0xD89F /* 責 */, 0xD4F0 /* 责 */,
0xD941 /* 貯 */, 0xD6FC /* 贮 */,
0xD942 /* 貰 */, 0xEADB /* 贳 */,
0xD944 /* 貲 */, 0xEADF /* 赀 */,
0xD945 /* 貳 */, 0xB7A1 /* 贰 */,
0xD946 /* 貴 */, 0xB9F3 /* 贵 */,
0xD948 /* 貶 */, 0xB1E1 /* 贬 */,
0xD949 /* 買 */, 0xC2F2 /* 买 */,
0xD94A /* 貸 */, 0xB4FB /* 贷 */,
0xD94C /* 貺 */, 0xEADC /* 贶 */,
0xD94D /* 費 */, 0xB7D1 /* 费 */,
0xD94E /* 貼 */, 0xCCF9 /* 贴 */,
0xD94F /* 貽 */, 0xEADD /* 贻 */,
0xD951 /* 貿 */, 0xC3B3 /* 贸 */,
0xD952 /* 賀 */, 0xBAD8 /* 贺 */,
0xD953 /* 賁 */, 0xEADA /* 贲 */,
0xD954 /* 賂 */, 0xC2B8 /* 赂 */,
0xD955 /* 賃 */, 0xC1DE /* 赁 */,
0xD956 /* 賄 */, 0xBBDF /* 贿 */,
0xD957 /* 賅 */, 0xEAE0 /* 赅 */,
0xD959 /* 資 */, 0xD7CA /* 资 */,
0xD95A /* 賈 */, 0xBCD6 /* 贾 */,
0xD95B /* 賉 */, 0xD0F4 /* 恤 */,
0xD95C /* 賊 */, 0xD4F4 /* 贼 */,
0xD95F /* 賍 */, 0xD4DF /* 赃 */,
0xD963 /* 賑 */, 0xEAE2 /* 赈 */,
0xD964 /* 賒 */, 0xC9DE /* 赊 */,
0xD965 /* 賓 */, 0xB1F6 /* 宾 */,
0xD966 /* 賔 */, 0xB1F6 /* 宾 */,
0xD967 /* 賕 */, 0xEAE4 /* 赇 */,
0xD96B /* 賙 */, 0xDA51 /* 赒 */,
0xD96C /* 賚 */, 0xEAE3 /* 赉 */,
0xD96D /* 賛 */, 0xD4DE /* 赞 */,
0xD96E /* 賜 */, 0xB4CD /* 赐 */,
0xD970 /* 賞 */, 0xC9CD /* 赏 */,
0xD972 /* 賠 */, 0xC5E2 /* 赔 */,
0xD973 /* 賡 */, 0xE2D9 /* 赓 */,
0xD974 /* 賢 */, 0xCFCD /* 贤 */,
0xD975 /* 賣 */, 0xC2F4 /* 卖 */,
0xD976 /* 賤 */, 0xBCFA /* 贱 */,
0xD978 /* 賦 */, 0xB8B3 /* 赋 */,
0xD979 /* 賧 */, 0xEAE6 /* 赕 */,
0xD97C /* 質 */, 0xD6CA /* 质 */,
0xD97D /* 賫 */, 0xEAE5 /* 赍 */,
0xD97E /* 賬 */, 0xD5CB /* 账 */,
0xD980 /* 賭 */, 0xB6C4 /* 赌 */,
0xD981 /* 賮 */, 0xEAE1 /* 赆 */,
0xD987 /* 賴 */, 0xC0B5 /* 赖 */,
0xD988 /* 賵 */, 0xDA52 /* 赗 */,
0xD98B /* 賸 */, 0xCAA3 /* 剩 */,
0xD98D /* 賺 */, 0xD7AC /* 赚 */,
0xD98E /* 賻 */, 0xEAE7 /* 赙 */,
0xD98F /* 購 */, 0xB9BA /* 购 */,
0xD990 /* 賽 */, 0xC8FC /* 赛 */,
0xD991 /* 賾 */, 0xD8D3 /* 赜 */,
0xD997 /* 贄 */, 0xEADE /* 贽 */,
0xD998 /* 贅 */, 0xD7B8 /* 赘 */,
0xD99A /* 贇 */, 0xDA53 /* 赟 */,
0xD99B /* 贈 */, 0xD4F9 /* 赠 */,
0xD99D /* 贊 */, 0xD4DE /* 赞 */,
0xD99E /* 贋 */, 0xD8CD /* 赝 */,
0xD9A0 /* 贍 */, 0xC9C4 /* 赡 */,
0xD9E0 /* 汆 */, 0xD9DB /* 氽 */,
0xDA41 /* 贏 */, 0xD3AE /* 赢 */,
0xDA42 /* 贐 */, 0xEAE1 /* 赆 */,
0xDA45 /* 贓 */, 0xD4DF /* 赃 */,
0xDA46 /* 贔 */, 0xDA50 /* 赑 */,
0xDA48 /* 贖 */, 0xCAEA /* 赎 */,
0xDA49 /* 贗 */, 0xD8CD /* 赝 */,
0xDA4D /* 贛 */, 0xB8D3 /* 赣 */,
0xDA4E /* 贜 */, 0xD4DF /* 赃 */,
0xDA58 /* 赬 */, 0xDA57 /* 赪 */,
0xDA73 /* 趕 */, 0xB8CF /* 赶 */,
0xDA77 /* 趙 */, 0xD5D4 /* 赵 */,
0xDA85 /* 趨 */, 0xC7F7 /* 趋 */,
0xDA8E /* 趲 */, 0xF4F5 /* 趱 */,
0xDB45 /* 跡 */, 0xBCA3 /* 迹 */,
0xDB52 /* 跼 */, 0xBED6 /* 局 */,
0xDB60 /* 踐 */, 0xBCF9 /* 践 */,
0xDB6D /* 踡 */, 0xF2E9 /* 蜷 */,
0xDB75 /* 踰 */, 0xD3E2 /* 逾 */,
0xDB78 /* 踴 */, 0xD3BB /* 踊 */,
0xDB84 /* 蹌 */, 0xF5C4 /* 跄 */,
0xDB8B /* 蹕 */, 0xF5CF /* 跸 */,
0xDB94 /* 蹟 */, 0xBCA3 /* 迹 */,
0xDB95 /* 蹠 */, 0xF5C5 /* 跖 */,
0xDB98 /* 蹣 */, 0xF5E7 /* 蹒 */,
0xDB99 /* 蹤 */, 0xD7D9 /* 踪 */,
0xDB9B /* 蹧 */, 0xD4E3 /* 糟 */,
0xDC45 /* 蹺 */, 0xF5CE /* 跷 */,
0xDC4A /* 躂 */, 0xDB51 /* 跶 */,
0xDC4F /* 躉 */, 0xF5BB /* 趸 */,
0xDC50 /* 躊 */, 0xB3EC /* 踌 */,
0xDC51 /* 躋 */, 0xF5D2 /* 跻 */,
0xDC53 /* 躍 */, 0xD4BE /* 跃 */,
0xDC55 /* 躑 */, 0xF5DC /* 踯 */,
0xDC56 /* 躒 */, 0xF5C8 /* 跞 */,
0xDC57 /* 躓 */, 0xF5D9 /* 踬 */,
0xDC58 /* 躕 */, 0xF5E9 /* 蹰 */,
0xDC5D /* 躚 */, 0xF5D1 /* 跹 */,
0xDC62 /* 躡 */, 0xF5E6 /* 蹑 */,
0xDC66 /* 躥 */, 0xB4DA /* 蹿 */,
0xDC67 /* 躦 */, 0xF5F2 /* 躜 */,
0xDC6B /* 躪 */, 0xF5EF /* 躏 */,
0xDC6E /* 躰 */, 0xCCE5 /* 体 */,
0xDC7C /* 軀 */, 0xC7FB /* 躯 */,
0xDC80 /* 軃 */, 0x818F /* 亸 */,
0xDC87 /* 車 */, 0xB3B5 /* 车 */,
0xDC88 /* 軋 */, 0xD4FE /* 轧 */,
0xDC89 /* 軌 */, 0xB9EC /* 轨 */,
0xDC8A /* 軍 */, 0xBEFC /* 军 */,
0xDC8D /* 軑 */, 0xDE61 /* 轪 */,
0xDC8E /* 軒 */, 0xD0F9 /* 轩 */,
0xDC90 /* 軔 */, 0xE9ED /* 轫 */,
0xDC97 /* 軛 */, 0xE9EE /* 轭 */,
0xDC9B /* 軟 */, 0xC8ED /* 软 */,
0xDCA0 /* 軤 */, 0xE9F5 /* 轷 */,
0xDD46 /* 軫 */, 0xE9F4 /* 轸 */,
0xDD4D /* 軲 */, 0xE9EF /* 轱 */,
0xDD53 /* 軸 */, 0xD6E1 /* 轴 */,
0xDD54 /* 軹 */, 0xE9F2 /* 轵 */,
0xDD55 /* 軺 */, 0xE9F7 /* 轺 */,
0xDD56 /* 軻 */, 0xE9F0 /* 轲 */,
0xDD57 /* 軼 */, 0xE9F3 /* 轶 */,
0xDD59 /* 軾 */, 0xE9F8 /* 轼 */,
0xDD5E /* 較 */, 0xBDCF /* 较 */,
0xDD60 /* 輅 */, 0xE9FB /* 辂 */,
0xDD62 /* 輇 */, 0xE9FA /* 辁 */,
0xDD63 /* 輈 */, 0xDE62 /* 辀 */,
0xDD64 /* 載 */, 0xD4D8 /* 载 */,
0xDD65 /* 輊 */, 0xE9F9 /* 轾 */,
0xDD6D /* 輒 */, 0xE9FC /* 辄 */,
0xDD6E /* 輓 */, 0xCDEC /* 挽 */,
0xDD6F /* 輔 */, 0xB8A8 /* 辅 */,
0xDD70 /* 輕 */, 0xC7E1 /* 轻 */,
0xDD76 /* 輛 */, 0xC1BE /* 辆 */,
0xDD77 /* 輜 */, 0xEAA2 /* 辎 */,
0xDD78 /* 輝 */, 0xBBD4 /* 辉 */,
0xDD79 /* 輞 */, 0xE9FE /* 辋 */,
0xDD7A /* 輟 */, 0xEAA1 /* 辍 */,
0xDD81 /* 輥 */, 0xB9F5 /* 辊 */,
0xDD82 /* 輦 */, 0xE9FD /* 辇 */,
0xDD85 /* 輩 */, 0xB1B2 /* 辈 */,
0xDD86 /* 輪 */, 0xC2D6 /* 轮 */,
0xDD88 /* 輬 */, 0xDE63 /* 辌 */,
0xDD89 /* 輭 */, 0xC8ED /* 软 */,
0xDD8B /* 輯 */, 0xBCAD /* 辑 */,
0xDD8F /* 輳 */, 0xEAA3 /* 辏 */,
0xDD94 /* 輸 */, 0xCAE4 /* 输 */,
0xDD97 /* 輻 */, 0xB7F8 /* 辐 */,
0xDD98 /* 輼 */, 0xDE64 /* 辒 */,
0xDD9A /* 輾 */, 0xD5B7 /* 辗 */,
0xDD9B /* 輿 */, 0xD3DF /* 舆 */,
0xDD9C /* 轀 */, 0xDE64 /* 辒 */,
0xDD9E /* 轂 */, 0xECB1 /* 毂 */,
0xDDA0 /* 轄 */, 0xCFBD /* 辖 */,
0xDDCE /* 菸 */, 0xD1CC /* 烟 */,
0xDE40 /* 轅 */, 0xD4AF /* 辕 */,
0xDE41 /* 轆 */, 0xEAA4 /* 辘 */,
0xDE44 /* 轉 */, 0xD7AA /* 转 */,
0xDE48 /* 轍 */, 0xD5DE /* 辙 */,
0xDE49 /* 轎 */, 0xBDCE /* 轿 */,
0xDE4F /* 轔 */, 0xEAA5 /* 辚 */,
0xDE5A /* 轟 */, 0xBAE4 /* 轰 */,
0xDE5C /* 轡 */, 0xE0CE /* 辔 */,
0xDE5D /* 轢 */, 0xE9F6 /* 轹 */,
0xDE5F /* 轤 */, 0xE9F1 /* 轳 */,
0xDE69 /* 辤 */, 0xB4C7 /* 辞 */,
0xDE6B /* 辦 */, 0xB0EC /* 办 */,
0xDE6F /* 辭 */, 0xB4C7 /* 辞 */,
0xDE70 /* 辮 */, 0xB1E8 /* 辫 */,
0xDE71 /* 辯 */, 0xB1E7 /* 辩 */,
0xDE72 /* 農 */, 0xC5A9 /* 农 */,
0xDE73 /* 辳 */, 0xC5A9 /* 农 */,
0xDE7E /* 迆 */, 0xE5C6 /* 迤 */,
0xDE92 /* 迴 */, 0xBBD8 /* 回 */,
0xDE95 /* 迺 */, 0xC4CB /* 乃 */,
0xDE9F /* 逕 */, 0xBEB6 /* 径 */,
0xDF40 /* 這 */, 0xD5E2 /* 这 */,
0xDF42 /* 連 */, 0xC1AC /* 连 */,
0xDF4C /* 週 */, 0xD6DC /* 周 */,
0xDF4D /* 進 */, 0xBDF8 /* 进 */,
0xDF5B /* 遊 */, 0xD3CE /* 游 */,
0xDF5C /* 運 */, 0xD4CB /* 运 */,
0xDF5E /* 過 */, 0xB9FD /* 过 */,
0xDF5F /* 達 */, 0xB4EF /* 达 */,
0xDF60 /* 違 */, 0xCEA5 /* 违 */,
0xDF62 /* 遙 */, 0xD2A3 /* 遥 */,
0xDF64 /* 遜 */, 0xD1B7 /* 逊 */,
0xDF65 /* 遝 */, 0xEDB3 /* 沓 */,
0xDF66 /* 遞 */, 0xB5DD /* 递 */,
0xDF68 /* 遠 */, 0xD4B6 /* 远 */,
0xDF6D /* 適 */, 0xCACA /* 适 */,
0xDF74 /* 遲 */, 0xB3D9 /* 迟 */,
0xDF77 /* 遷 */, 0xC7A8 /* 迁 */,
0xDF78 /* 選 */, 0xD1A1 /* 选 */,
0xDF7A /* 遺 */, 0xD2C5 /* 遗 */,
0xDF7C /* 遼 */, 0xC1C9 /* 辽 */,
0xDF7E /* 邁 */, 0xC2F5 /* 迈 */,
0xDF80 /* 還 */, 0xBBB9 /* 还 */,
0xDF83 /* 邇 */, 0xE5C7 /* 迩 */,
0xDF85 /* 邊 */, 0xB1DF /* 边 */,
0xDF89 /* 邏 */, 0xC2DF /* 逻 */,
0xDF8A /* 邐 */, 0xE5CE /* 逦 */,
0xDFA1 /* 摺 */, 0xD5DB /* 折 */,
0xDFB8 /* 吒 */, 0xDFE5 /* 咤 */,
0xE041 /* 郃 */, 0xBACF /* 合 */,
0xE050 /* 郟 */, 0xDBA3 /* 郏 */,
0xE053 /* 郤 */, 0xDBA7 /* 郄 */,
0xE05D /* 郵 */, 0xD3CA /* 邮 */,
0xE069 /* 鄆 */, 0xDBA9 /* 郓 */,
0xE06C /* 鄉 */, 0xCFE7 /* 乡 */,
0xE075 /* 鄒 */, 0xD7DE /* 邹 */,
0xE077 /* 鄔 */, 0xDAF9 /* 邬 */,
0xE078 /* 鄕 */, 0xCFE7 /* 乡 */,
0xE079 /* 鄖 */, 0xD4C7 /* 郧 */,
0xE07B /* 鄘 */, 0xDCAD /* 墉 */,
0xE087 /* 鄧 */, 0xB5CB /* 邓 */,
0xE08D /* 鄭 */, 0xD6A3 /* 郑 */,
0xE08F /* 鄰 */, 0xC1DA /* 邻 */,
0xE090 /* 鄲 */, 0xB5A6 /* 郸 */,
0xE092 /* 鄴 */, 0xDAFE /* 邺 */,
0xE094 /* 鄶 */, 0xDBA6 /* 郐 */,
0xE097 /* 鄺 */, 0xDAF7 /* 邝 */,
0xE142 /* 酈 */, 0xDBAA /* 郦 */,
0xE147 /* 酖 */, 0xF0B2 /* 鸩 */,
0xE14F /* 酧 */, 0xB3EA /* 酬 */,
0xE15A /* 醃 */, 0xEBE7 /* 腌 */,
0xE15C /* 醆 */, 0xD5B5 /* 盏 */,
0xE164 /* 醖 */, 0xD4CD /* 酝 */,
0xE168 /* 醜 */, 0xB3F3 /* 丑 */,
0xE16A /* 醞 */, 0xD4CD /* 酝 */,
0xE174 /* 醫 */, 0xD2BD /* 医 */,
0xE175 /* 醬 */, 0xBDB4 /* 酱 */,
0xE177 /* 醱 */, 0xE14E /* 酦 */,
0xE17E /* 醻 */, 0xB3EA /* 酬 */,
0xE180 /* 醼 */, 0xD1E0 /* 燕 */,
0xE184 /* 釀 */, 0xC4F0 /* 酿 */,
0xE185 /* 釁 */, 0xD0C6 /* 衅 */,
0xE187 /* 釃 */, 0xF5A7 /* 酾 */,
0xE189 /* 釅 */, 0xF5A6 /* 酽 */,
0xE18A /* 釆 */, 0xB2C9 /* 采 */,
0xE18C /* 釋 */, 0xCACD /* 释 */,
0xE18D /* 釐 */, 0xC0E5 /* 厘 */,
0xE18E /* 釒 */, 0xEEC4 /* 钅 */,
0xE18F /* 釓 */, 0xEEC5 /* 钆 */,
0xE190 /* 釔 */, 0xEEC6 /* 钇 */,
0xE191 /* 釕 */, 0xEEC9 /* 钌 */,
0xE193 /* 釗 */, 0xEEC8 /* 钊 */,
0xE194 /* 釘 */, 0xB6A4 /* 钉 */,
0xE195 /* 釙 */, 0xEEC7 /* 钋 */,
0xE198 /* 針 */, 0xD5EB /* 针 */,
0xE19E /* 釣 */, 0xB5F6 /* 钓 */,
0xE19F /* 釤 */, 0xEECC /* 钐 */,
0xE1E1 /* 後 */, 0xBAF3 /* 后 */,
0xE1E7 /* 徵 */, 0xD5F7 /* 征 */,
0xE240 /* 釦 */, 0xBFDB /* 扣 */,
0xE241 /* 釧 */, 0xEECB /* 钏 */,
0xE243 /* 釩 */, 0xB7B0 /* 钒 */,
0xE246 /* 釬 */, 0xBAB8 /* 焊 */,
0xE24F /* 釵 */, 0xEECE /* 钗 */,
0xE251 /* 釷 */, 0xEECA /* 钍 */,
0xE253 /* 釹 */, 0xEECF /* 钕 */,
0xE254 /* 釺 */, 0xC7A5 /* 钎 */,
0xE25A /* 鈀 */, 0xEED9 /* 钯 */,
0xE25B /* 鈁 */, 0xEED5 /* 钫 */,
0xE25D /* 鈃 */, 0xE897 /* 钘 */,
0xE25E /* 鈄 */, 0xEED7 /* 钭 */,
0xE25F /* 鈅 */, 0xD4BF /* 钥 */,
0xE262 /* 鈈 */, 0xEED0 /* 钚 */,
0xE263 /* 鈉 */, 0xC4C6 /* 钠 */,
0xE267 /* 鈍 */, 0xB6DB /* 钝 */,
0xE268 /* 鈎 */, 0xB9B3 /* 钩 */,
0xE26A /* 鈐 */, 0xEED4 /* 钤 */,
0xE26B /* 鈑 */, 0xEED3 /* 钣 */,
0xE26C /* 鈒 */, 0xE895 /* 钑 */,
0xE26E /* 鈔 */, 0xB3AE /* 钞 */,
0xE26F /* 鈕 */, 0xC5A5 /* 钮 */,
0xE278 /* 鈞 */, 0xBEFB /* 钧 */,
0xE27B /* 鈡 */, 0xD6D3 /* 钟 */,
0xE27D /* 鈣 */, 0xB8C6 /* 钙 */,
0xE280 /* 鈥 */, 0xEED8 /* 钬 */,
0xE281 /* 鈦 */, 0xEED1 /* 钛 */,
0xE282 /* 鈧 */, 0xEED6 /* 钪 */,
0xE289 /* 鈮 */, 0xEEEA /* 铌 */,
0xE28B /* 鈰 */, 0xEEE6 /* 铈 */,
0xE28E /* 鈳 */, 0xEEDD /* 钶 */,
0xE28F /* 鈴 */, 0xC1E5 /* 铃 */,
0xE292 /* 鈷 */, 0xEEDC /* 钴 */,
0xE293 /* 鈸 */, 0xEEE0 /* 钹 */,
0xE294 /* 鈹 */, 0xEEEB /* 铍 */,
0xE295 /* 鈺 */, 0xEEDA /* 钰 */,
0xE298 /* 鈽 */, 0xEEDF /* 钸 */,
0xE299 /* 鈾 */, 0xD3CB /* 铀 */,
0xE29A /* 鈿 */, 0xEEE4 /* 钿 */,
0xE29B /* 鉀 */, 0xBCD8 /* 钾 */,
0xE29F /* 鉄 */, 0xCCFA /* 铁 */,
0xE2A0 /* 鉅 */, 0xEED2 /* 钜 */,
0xE2B7 /* 夥 */, 0xBBEF /* 伙 */,
0xE340 /* 鉆 */, 0xD7EA /* 钻 */,
0xE342 /* 鉈 */, 0xEEE8 /* 铊 */,
0xE343 /* 鉉 */, 0xEEE7 /* 铉 */,
0xE345 /* 鉋 */, 0xC5D9 /* 刨 */,
0xE347 /* 鉍 */, 0xEEE9 /* 铋 */,
0xE34B /* 鉑 */, 0xB2AC /* 铂 */,
0xE34F /* 鉕 */, 0xEEDE /* 钷 */,
0xE351 /* 鉗 */, 0xC7AF /* 钳 */,
0xE354 /* 鉚 */, 0xC3AD /* 铆 */,
0xE355 /* 鉛 */, 0xC7A6 /* 铅 */,
0xE358 /* 鉞 */, 0xEEE1 /* 钺 */,
0xE35C /* 鉢 */, 0xB2A7 /* 钵 */,
0xE35E /* 鉤 */, 0xB9B3 /* 钩 */,
0xE360 /* 鉦 */, 0xEEDB /* 钲 */,
0xE366 /* 鉬 */, 0xEEE2 /* 钼 */,
0xE367 /* 鉭 */, 0xEEE3 /* 钽 */,
0xE36F /* 鉶 */, 0xE899 /* 铏 */,
0xE371 /* 鉸 */, 0xBDC2 /* 铰 */,
0xE373 /* 鉺 */, 0xEEEF /* 铒 */,
0xE374 /* 鉻 */, 0xB8F5 /* 铬 */,
0xE378 /* 鉿 */, 0xEEFE /* 铪 */,
0xE379 /* 銀 */, 0xD2F8 /* 银 */,
0xE37C /* 銃 */, 0xEFA5 /* 铳 */,
0xE37E /* 銅 */, 0xCDAD /* 铜 */,
0xE387 /* 銍 */, 0xE89C /* 铚 */,
0xE38A /* 銑 */, 0xCFB3 /* 铣 */,
0xE38C /* 銓 */, 0xEEFD /* 铨 */,
0xE38E /* 銕 */, 0xCCFA /* 铁 */,
0xE38F /* 銖 */, 0xEEF9 /* 铢 */,
0xE391 /* 銘 */, 0xC3FA /* 铭 */,
0xE393 /* 銚 */, 0xEFA2 /* 铫 */,
0xE394 /* 銛 */, 0xE89D /* 铦 */,
0xE395 /* 銜 */, 0xCFCE /* 衔 */,
0xE399 /* 銠 */, 0xEEEE /* 铑 */,
0xE39C /* 銣 */, 0xEFA8 /* 铷 */,
0xE39E /* 銥 */, 0xD2BF /* 铱 */,
0xE39F /* 銦 */, 0xEEF7 /* 铟 */,
0xE3DD /* 爿 */, 0xE3DC /* 丬 */,
0xE440 /* 銨 */, 0xEFA7 /* 铵 */,
0xE441 /* 銩 */, 0xEEFB /* 铥 */,
0xE442 /* 銪 */, 0xEEF0 /* 铕 */,
0xE443 /* 銫 */, 0xEFA4 /* 铯 */,
0xE444 /* 銬 */, 0xEEED /* 铐 */,
0xE448 /* 銱 */, 0xEEF6 /* 铞 */,
0xE449 /* 銲 */, 0xBAB8 /* 焊 */,
0xE44A /* 銳 */, 0xC8F1 /* 锐 */,
0xE44E /* 銷 */, 0xCFFA /* 销 */,
0xE450 /* 銹 */, 0xD0E2 /* 锈 */,
0xE452 /* 銻 */, 0xCCE0 /* 锑 */,
0xE453 /* 銼 */, 0xEFB1 /* 锉 */,
0xE458 /* 鋁 */, 0xC2C1 /* 铝 */,
0xE45A /* 鋃 */, 0xEFB6 /* 锒 */,
0xE45C /* 鋅 */, 0xD0BF /* 锌 */,
0xE45E /* 鋇 */, 0xB1B5 /* 钡 */,
0xE462 /* 鋌 */, 0xEEFA /* 铤 */,
0xE465 /* 鋏 */, 0xEEF2 /* 铗 */,
0xE468 /* 鋒 */, 0xB7E6 /* 锋 */,
0xE46F /* 鋙 */, 0xE89E /* 铻 */,
0xE472 /* 鋜 */, 0xEFED /* 镯 */,
0xE473 /* 鋝 */, 0xEFB2 /* 锊 */,
0xE475 /* 鋟 */, 0xEFB7 /* 锓 */,
0xE479 /* 鋣 */, 0xEEF4 /* 铘 */,
0xE47A /* 鋤 */, 0xB3FA /* 锄 */,
0xE47B /* 鋥 */, 0xEFAD /* 锃 */,
0xE47C /* 鋦 */, 0xEFB8 /* 锔 */,
0xE47E /* 鋨 */, 0xEFB0 /* 锇 */,
0xE480 /* 鋩 */, 0xE89A /* 铓 */,
0xE481 /* 鋪 */, 0xC6CC /* 铺 */,
0xE484 /* 鋭 */, 0xC8F1 /* 锐 */,
0xE485 /* 鋮 */, 0xEEF1 /* 铖 */,
0xE486 /* 鋯 */, 0xEFAF /* 锆 */,
0xE487 /* 鋰 */, 0xEFAE /* 锂 */,
0xE488 /* 鋱 */, 0xEFAB /* 铽 */,
0xE48D /* 鋶 */, 0xEFB3 /* 锍 */,
0xE48F /* 鋸 */, 0xBEE2 /* 锯 */,
0xE492 /* 鋻 */, 0xBCF8 /* 鉴 */,
0xE493 /* 鋼 */, 0xB8D6 /* 钢 */,
0xE498 /* 錁 */, 0xEFBE /* 锞 */,
0xE49B /* 錄 */, 0xC2BC /* 录 */,
0xE49D /* 錆 */, 0xEFBA /* 锖 */,
0xE49E /* 錇 */, 0xEFC2 /* 锫 */,
0xE49F /* 錈 */, 0xEFC3 /* 锩 */,
0xE545 /* 錏 */, 0xE89B /* 铔 */,
0xE546 /* 錐 */, 0xD7B6 /* 锥 */,
0xE548 /* 錒 */, 0xEFB9 /* 锕 */,
0xE54B /* 錕 */, 0xEFBF /* 锟 */,
0xE54E /* 錘 */, 0xB4B8 /* 锤 */,
0xE54F /* 錙 */, 0xEFC5 /* 锱 */,
0xE550 /* 錚 */, 0xEFA3 /* 铮 */,
0xE551 /* 錛 */, 0xEFBC /* 锛 */,
0xE555 /* 錟 */, 0xEFC4 /* 锬 */,
0xE556 /* 錠 */, 0xB6A7 /* 锭 */,
0xE557 /* 錡 */, 0xE89F /* 锜 */,
0xE558 /* 錢 */, 0xC7AE /* 钱 */,
0xE55C /* 錦 */, 0xBDF5 /* 锦 */,
0xE55E /* 錨 */, 0xC3AA /* 锚 */,
0xE55F /* 錩 */, 0xE8A0 /* 锠 */,
0xE561 /* 錫 */, 0xCEFD /* 锡 */,
0xE564 /* 錮 */, 0xEFC0 /* 锢 */,
0xE565 /* 錯 */, 0xB4ED /* 错 */,
0xE568 /* 録 */, 0xC2BC /* 录 */,
0xE569 /* 錳 */, 0xC3CC /* 锰 */,
0xE56C /* 錶 */, 0xB1ED /* 表 */,
0xE56E /* 錸 */, 0xEFAA /* 铼 */,
0xE575 /* 鍀 */, 0xEFBD /* 锝 */,
0xE576 /* 鍁 */, 0xCFC7 /* 锨 */,
0xE578 /* 鍃 */, 0xEFC1 /* 锪 */,
0xE57B /* 鍆 */, 0xEECD /* 钔 */,
0xE57C /* 鍇 */, 0xEFC7 /* 锴 */,
0xE57D /* 鍈 */, 0xE941 /* 锳 */,
0xE580 /* 鍊 */, 0xC1B6 /* 炼 */,
0xE581 /* 鍋 */, 0xB9F8 /* 锅 */,
0xE583 /* 鍍 */, 0xB6C6 /* 镀 */,
0xE58A /* 鍔 */, 0xEFC9 /* 锷 */,
0xE58E /* 鍘 */, 0xD5A1 /* 铡 */,
0xE591 /* 鍛 */, 0xB6CD /* 锻 */,
0xE596 /* 鍠 */, 0xE942 /* 锽 */,
0xE59A /* 鍤 */, 0xEFCA /* 锸 */,
0xE59B /* 鍥 */, 0xEFC6 /* 锲 */,
0xE59F /* 鍩 */, 0xEFBB /* 锘 */,
0xE5A0 /* 鍫 */, 0xC7C2 /* 锹 */,
0xE5B8 /* 甯 */, 0xC4FE /* 宁 */,
0xE640 /* 鍬 */, 0xC7C2 /* 锹 */,
0xE644 /* 鍰 */, 0xEFCC /* 锾 */,
0xE649 /* 鍵 */, 0xBCFC /* 键 */,
0xE64A /* 鍶 */, 0xEFC8 /* 锶 */,
0xE64E /* 鍺 */, 0xD5E0 /* 锗 */,
0xE650 /* 鍼 */, 0xD5EB /* 针 */,
0xE652 /* 鍾 */, 0xD6D3 /* 钟 */,
0xE656 /* 鎂 */, 0xC3BE /* 镁 */,
0xE658 /* 鎄 */, 0xEFCD /* 锿 */,
0xE65B /* 鎇 */, 0xEFD1 /* 镅 */,
0xE65E /* 鎊 */, 0xB0F7 /* 镑 */,
0xE65F /* 鎋 */, 0xCFBD /* 辖 */,
0xE660 /* 鎌 */, 0xC1AD /* 镰 */,
0xE667 /* 鎔 */, 0xE946 /* 镕 */,
0xE669 /* 鎖 */, 0xCBF8 /* 锁 */,
0xE66A /* 鎗 */, 0xC7B9 /* 枪 */,
0xE66B /* 鎘 */, 0xEFD3 /* 镉 */,
0xE66D /* 鎚 */, 0xB4B8 /* 锤 */,
0xE66E /* 鎛 */, 0xE944 /* 镈 */,
0xE674 /* 鎡 */, 0xE943 /* 镃 */,
0xE675 /* 鎢 */, 0xCED9 /* 钨 */,
0xE676 /* 鎣 */, 0xDDF6 /* 蓥 */,
0xE679 /* 鎦 */, 0xEFD6 /* 镏 */,
0xE67A /* 鎧 */, 0xEEF8 /* 铠 */,
0xE67C /* 鎩 */, 0xEFA1 /* 铩 */,
0xE67D /* 鎪 */, 0xEFCB /* 锼 */,
0xE680 /* 鎬 */, 0xB8E4 /* 镐 */,
0xE682 /* 鎮 */, 0xD5F2 /* 镇 */,
0xE684 /* 鎰 */, 0xEFD7 /* 镒 */,
0xE686 /* 鎲 */, 0xE945 /* 镋 */,
0xE687 /* 鎳 */, 0xC4F8 /* 镍 */,
0xE689 /* 鎵 */, 0xEFD8 /* 镓 */,
0xE68C /* 鎸 */, 0xEFD4 /* 镌 */,
0xE693 /* 鎿 */, 0xEFD5 /* 镎 */,
0xE697 /* 鏃 */, 0xEFDF /* 镞 */,
0xE69B /* 鏇 */, 0xD0FD /* 旋 */,
0xE69C /* 鏈 */, 0xC1B4 /* 链 */,
0xE69F /* 鏌 */, 0xEFD2 /* 镆 */,
0xE6A0 /* 鏍 */, 0xEFDD /* 镙 */,
0xE742 /* 鏐 */, 0xE948 /* 镠 */,
0xE743 /* 鏑 */, 0xEFE1 /* 镝 */,
0xE748 /* 鏗 */, 0xEFAC /* 铿 */,
0xE749 /* 鏘 */, 0xEFCF /* 锵 */,
0xE74B /* 鏚 */, 0xC6DD /* 戚 */,
0xE74D /* 鏜 */, 0xEFDB /* 镗 */,
0xE74E /* 鏝 */, 0xEFDC /* 镘 */,
0xE74F /* 鏞 */, 0xEFDE /* 镛 */,
0xE750 /* 鏟 */, 0xB2F9 /* 铲 */,
0xE752 /* 鏡 */, 0xBEB5 /* 镜 */,
0xE753 /* 鏢 */, 0xEFDA /* 镖 */,
0xE755 /* 鏤 */, 0xEFCE /* 镂 */,
0xE759 /* 鏨 */, 0xF6C9 /* 錾 */,
0xE761 /* 鏰 */, 0xE947 /* 镚 */,
0xE766 /* 鏵 */, 0xEEFC /* 铧 */,
0xE768 /* 鏷 */, 0xEFE4 /* 镤 */,
0xE76A /* 鏹 */, 0xEFEA /* 镪 */,
0xE76E /* 鏽 */, 0xD0E2 /* 锈 */,
0xE774 /* 鐃 */, 0xEEF3 /* 铙 */,
0xE77C /* 鐋 */, 0xEFA6 /* 铴 */,
0xE782 /* 鐐 */, 0xC1CD /* 镣 */,
0xE784 /* 鐒 */, 0xEFA9 /* 铹 */,
0xE785 /* 鐓 */, 0xEFE6 /* 镦 */,
0xE786 /* 鐔 */, 0xEFE2 /* 镡 */,
0xE78A /* 鐘 */, 0xD6D3 /* 钟 */,
0xE78B /* 鐙 */, 0xEFEB /* 镫 */,
0xE78F /* 鐝 */, 0xEFE3 /* 镢 */,
0xE792 /* 鐠 */, 0xEFE8 /* 镨 */,
0xE798 /* 鐦 */, 0xEFB4 /* 锎 */,
0xE799 /* 鐧 */, 0xEFB5 /* 锏 */,
0xE79A /* 鐨 */, 0xEFD0 /* 镄 */,
0xE79D /* 鐫 */, 0xEFD4 /* 镌 */,
0xE7A0 /* 鐮 */, 0xC1AD /* 镰 */,
0xE843 /* 鐲 */, 0xEFED /* 镯 */,
0xE844 /* 鐳 */, 0xC0D8 /* 镭 */,
0xE846 /* 鐵 */, 0xCCFA /* 铁 */,
0xE847 /* 鐶 */, 0xE949 /* 镮 */,
0xE849 /* 鐸 */, 0xEEEC /* 铎 */,
0xE84B /* 鐺 */, 0xEEF5 /* 铛 */,
0xE84F /* 鐿 */, 0xEFEE /* 镱 */,
0xE854 /* 鑄 */, 0xD6FD /* 铸 */,
0xE85A /* 鑊 */, 0xEFEC /* 镬 */,
0xE85C /* 鑌 */, 0xEFD9 /* 镔 */,
0xE861 /* 鑑 */, 0xBCF8 /* 鉴 */,
0xE862 /* 鑒 */, 0xBCF8 /* 鉴 */,
0xE864 /* 鑔 */, 0xEFEF /* 镲 */,
0xE865 /* 鑕 */, 0xE940 /* 锧 */,
0xE86B /* 鑛 */, 0xBFF3 /* 矿 */,
0xE86E /* 鑞 */, 0xE94A /* 镴 */,
0xE870 /* 鑠 */, 0xEEE5 /* 铄 */,
0xE873 /* 鑣 */, 0xEFF0 /* 镳 */,
0xE874 /* 鑤 */, 0xC5D9 /* 刨 */,
0xE875 /* 鑥 */, 0xEFE5 /* 镥 */,
0xE87A /* 鑪 */, 0xC2AF /* 炉 */,
0xE87C /* 鑭 */, 0xEFE7 /* 镧 */,
0xE880 /* 鑰 */, 0xD4BF /* 钥 */,
0xE881 /* 鑱 */, 0xE94B /* 镵 */,
0xE882 /* 鑲 */, 0xCFE2 /* 镶 */,
0xE887 /* 鑷 */, 0xC4F7 /* 镊 */,
0xE889 /* 鑹 */, 0xEFE9 /* 镩 */,
0xE88C /* 鑼 */, 0xC2E0 /* 锣 */,
0xE88D /* 鑽 */, 0xD7EA /* 钻 */,
0xE88E /* 鑾 */, 0xF6C7 /* 銮 */,
0xE88F /* 鑿 */, 0xD4E4 /* 凿 */,
0xE891 /* 钁 */, 0xEFE3 /* 镢 */,
0xE892 /* 钂 */, 0xE945 /* 镋 */,
0xE94C /* 長 */, 0xB3A4 /* 长 */,
0xE954 /* 門 */, 0xC3C5 /* 门 */,
0xE956 /* 閂 */, 0xE3C5 /* 闩 */,
0xE957 /* 閃 */, 0xC9C1 /* 闪 */,
0xE95A /* 閆 */, 0xE3C6 /* 闫 */,
0xE95C /* 閈 */, 0xEA5C /* 闬 */,
0xE95D /* 閉 */, 0xB1D5 /* 闭 */,
0xE95F /* 開 */, 0xBFAA /* 开 */,
0xE960 /* 閌 */, 0xE3CA /* 闶 */,
0xE962 /* 閎 */, 0xE3C8 /* 闳 */,
0xE963 /* 閏 */, 0xC8F2 /* 闰 */,
0xE965 /* 閑 */, 0xCFD0 /* 闲 */,
0xE966 /* 閒 */, 0xCFD0 /* 闲 */,
0xE967 /* 間 */, 0xBCE4 /* 间 */,
0xE968 /* 閔 */, 0xE3C9 /* 闵 */,
0xE96C /* 閘 */, 0xD5A2 /* 闸 */,
0xE96D /* 閙 */, 0xC4D6 /* 闹 */,
0xE975 /* 閡 */, 0xBAD2 /* 阂 */,
0xE976 /* 関 */, 0xB9D8 /* 关 */,
0xE977 /* 閣 */, 0xB8F3 /* 阁 */,
0xE978 /* 閤 */, 0xBACF /* 合 */,
0xE979 /* 閥 */, 0xB7A7 /* 阀 */,
0xE97C /* 閨 */, 0xB9EB /* 闺 */,
0xE97D /* 閩 */, 0xC3F6 /* 闽 */,
0xE980 /* 閫 */, 0xE3CD /* 阃 */,
0xE981 /* 閬 */, 0xE3CF /* 阆 */,
0xE982 /* 閭 */, 0xE3CC /* 闾 */,
0xE985 /* 閰 */, 0xD1D6 /* 阎 */,
0xE986 /* 閱 */, 0xD4C4 /* 阅 */,
0xE987 /* 閲 */, 0xD4C4 /* 阅 */,
0xE98B /* 閶 */, 0xE3D1 /* 阊 */,
0xE98E /* 閹 */, 0xD1CB /* 阉 */,
0xE990 /* 閻 */, 0xD1D6 /* 阎 */,
0xE991 /* 閼 */, 0xE3D5 /* 阏 */,
0xE992 /* 閽 */, 0xE3D4 /* 阍 */,
0xE993 /* 閾 */, 0xE3D0 /* 阈 */,
0xE994 /* 閿 */, 0xE3D3 /* 阌 */,
0xE998 /* 闃 */, 0xE3D6 /* 阒 */,
0xE99B /* 闆 */, 0xB0E5 /* 板 */,
0xE99D /* 闈 */, 0xE3C7 /* 闱 */,
0xE99F /* 闊 */, 0xC0AB /* 阔 */,
0xE9A0 /* 闋 */, 0xE3D7 /* 阕 */,
0xEA40 /* 闌 */, 0xC0BB /* 阑 */,
0xEA41 /* 闍 */, 0xEA5E /* 阇 */,
0xEA44 /* 闐 */, 0xE3D9 /* 阗 */,
0xEA46 /* 闒 */, 0xEA60 /* 阘 */,
0xEA47 /* 闓 */, 0xEA5D /* 闿 */,
0xEA48 /* 闔 */, 0xE3D8 /* 阖 */,
0xEA49 /* 闕 */, 0xE3DA /* 阙 */,
0xEA4A /* 闖 */, 0xB4B3 /* 闯 */,
0xEA4E /* 闚 */, 0xBFFA /* 窥 */,
0xEA50 /* 關 */, 0xB9D8 /* 关 */,
0xEA52 /* 闞 */, 0xE3DB /* 阚 */,
0xEA54 /* 闠 */, 0xEA5F /* 阓 */,
0xEA55 /* 闡 */, 0xB2FB /* 阐 */,
0xEA56 /* 闢 */, 0xB1D9 /* 辟 */,
0xEA58 /* 闤 */, 0xEA61 /* 阛 */,
0xEA59 /* 闥 */, 0xE3CB /* 闼 */,
0xEA6C /* 阬 */, 0xBFD3 /* 坑 */,
0xEA6E /* 阯 */, 0xD6B7 /* 址 */,
0xEA80 /* 陘 */, 0xDAEA /* 陉 */,
0xEA84 /* 陝 */, 0xC9C2 /* 陕 */,
0xEA85 /* 陞 */, 0xC9FD /* 升 */,
0xEA87 /* 陣 */, 0xD5F3 /* 阵 */,
0xEA8E /* 陰 */, 0xD2F5 /* 阴 */,
0xEA90 /* 陳 */, 0xB3C2 /* 陈 */,
0xEA91 /* 陸 */, 0xC2BD /* 陆 */,
0xEA96 /* 陽 */, 0xD1F4 /* 阳 */,
0xEA9B /* 隂 */, 0xD2F5 /* 阴 */,
0xEA9D /* 隄 */, 0xB5CC /* 堤 */,
0xEA9F /* 隉 */, 0xDAED /* 陧 */,
0xEAA0 /* 隊 */, 0xB6D3 /* 队 */,
0xEB41 /* 階 */, 0xBDD7 /* 阶 */,
0xEB45 /* 隕 */, 0xD4C9 /* 陨 */,
0xEB46 /* 隖 */, 0xCEEB /* 坞 */,
0xEB48 /* 際 */, 0xBCCA /* 际 */,
0xEB4F /* 隣 */, 0xC1DA /* 邻 */,
0xEB53 /* 隨 */, 0xCBE6 /* 随 */,
0xEB55 /* 險 */, 0xCFD5 /* 险 */,
0xEB5B /* 隱 */, 0xD2FE /* 隐 */,
0xEB5D /* 隴 */, 0xC2A4 /* 陇 */,
0xEB5F /* 隷 */, 0xC1A5 /* 隶 */,
0xEB60 /* 隸 */, 0xC1A5 /* 隶 */,
0xEB62 /* 隻 */, 0xD6BB /* 只 */,
0xEB68 /* 雋 */, 0xF6C1 /* 隽 */,
0xEB6D /* 雖 */, 0xCBE4 /* 虽 */,
0xEB70 /* 雙 */, 0xCBAB /* 双 */,
0xEB72 /* 雛 */, 0xB3FB /* 雏 */,
0xEB73 /* 雜 */, 0xD4D3 /* 杂 */,
0xEB75 /* 雞 */, 0xBCA6 /* 鸡 */,
0xEB78 /* 離 */, 0xC0EB /* 离 */,
0xEB79 /* 難 */, 0xC4D1 /* 难 */,
0xEB85 /* 雲 */, 0xD4C6 /* 云 */,
0xEB8A /* 電 */, 0xB5E7 /* 电 */,
0xEB95 /* 霑 */, 0xD5B4 /* 沾 */,
0xEB9D /* 霛 */, 0xC1E9 /* 灵 */,
0xEC43 /* 霤 */, 0xC1EF /* 溜 */,
0xEC46 /* 霧 */, 0xCEED /* 雾 */,
0xEC56 /* 霽 */, 0xF6AB /* 霁 */,
0xEC5A /* 靂 */, 0xF6A8 /* 雳 */,
0xEC5C /* 靄 */, 0xF6B0 /* 霭 */,
0xEC5E /* 靆 */, 0x85A6 /* 叇 */,
0xEC60 /* 靈 */, 0xC1E9 /* 灵 */,
0xEC61 /* 靉 */, 0x85A5 /* 叆 */,
0xEC6E /* 靚 */, 0xF6A6 /* 靓 */,
0xEC6F /* 靜 */, 0xBEB2 /* 静 */,
0xEC72 /* 靣 */, 0xC3E6 /* 面 */,
0xEC74 /* 靦 */, 0xEBEF /* 腼 */,
0xEC76 /* 靨 */, 0xD8CC /* 靥 */,
0xEC7A /* 靭 */, 0xC8CD /* 韧 */,
0xEC8A /* 鞀 */, 0xD8BB /* 鼗 */,
0xEC92 /* 鞉 */, 0xD8BB /* 鼗 */,
0xEC96 /* 鞏 */, 0xB9AE /* 巩 */,
0xECB6 /* 於 */, 0xD3DA /* 于 */,
0xED46 /* 鞦 */, 0xC7EF /* 秋 */,
0xED58 /* 鞽 */, 0xF7B3 /* 鞒 */,
0xED5C /* 韁 */, 0xE7D6 /* 缰 */,
0xED5E /* 韃 */, 0xF7B2 /* 鞑 */,
0xED61 /* 韆 */, 0xC7A7 /* 千 */,
0xED64 /* 韉 */, 0xF7B5 /* 鞯 */,
0xED66 /* 韋 */, 0xCEA4 /* 韦 */,
0xED67 /* 韌 */, 0xC8CD /* 韧 */,
0xED68 /* 韍 */, 0xED82 /* 韨 */,
0xED6E /* 韓 */, 0xBAAB /* 韩 */,
0xED74 /* 韙 */, 0xE8B8 /* 韪 */,
0xED77 /* 韜 */, 0xE8BA /* 韬 */,
0xED78 /* 韝 */, 0xF7B9 /* 鞴 */,
0xED79 /* 韞 */, 0xE8B9 /* 韫 */,
0xED80 /* 韤 */, 0xCDE0 /* 袜 */,
0xED8D /* 韻 */, 0xD4CF /* 韵 */,
0xED91 /* 響 */, 0xCFEC /* 响 */,
0xED93 /* 頁 */, 0xD2B3 /* 页 */,
0xED94 /* 頂 */, 0xB6A5 /* 顶 */,
0xED95 /* 頃 */, 0xC7EA /* 顷 */,
0xED97 /* 項 */, 0xCFEE /* 项 */,
0xED98 /* 順 */, 0xCBB3 /* 顺 */,
0xED99 /* 頇 */, 0xF1FC /* 顸 */,
0xED9A /* 須 */, 0xD0EB /* 须 */,
0xED9C /* 頊 */, 0xE7EF /* 顼 */,
0xED9E /* 頌 */, 0xCBCC /* 颂 */,
0xEDA0 /* 頎 */, 0xF1FD /* 颀 */,
0xEE40 /* 頏 */, 0xF1FE /* 颃 */,
0xEE41 /* 預 */, 0xD4A4 /* 预 */,
0xEE42 /* 頑 */, 0xCDE7 /* 顽 */,
0xEE43 /* 頒 */, 0xB0E4 /* 颁 */,
0xEE44 /* 頓 */, 0xB6D9 /* 顿 */,
0xEE48 /* 頗 */, 0xC6C4 /* 颇 */,
0xEE49 /* 領 */, 0xC1EC /* 领 */,
0xEE4D /* 頜 */, 0xF2A2 /* 颌 */,
0xEE52 /* 頡 */, 0xF2A1 /* 颉 */,
0xEE55 /* 頤 */, 0xD2C3 /* 颐 */,
0xEE57 /* 頦 */, 0xF2A4 /* 颏 */,
0xEE5C /* 頫 */, 0xB8A9 /* 俯 */,
0xEE5E /* 頭 */, 0xCDB7 /* 头 */,
0xEE5F /* 頮 */, 0xEF48 /* 颒 */,
0xEE61 /* 頰 */, 0xBCD5 /* 颊 */,
0xEE63 /* 頲 */, 0xEF46 /* 颋 */,
0xEE65 /* 頴 */, 0xEF49 /* 颕 */,
0xEE68 /* 頷 */, 0xF2A5 /* 颔 */,
0xEE69 /* 頸 */, 0xBEB1 /* 颈 */,
0xEE6A /* 頹 */, 0xCDC7 /* 颓 */,
0xEE6C /* 頻 */, 0xC6B5 /* 频 */,
0xEE6E /* 頽 */, 0xCDC7 /* 颓 */,
0xEE77 /* 顆 */, 0xBFC5 /* 颗 */,
0xEE7D /* 題 */, 0xCCE2 /* 题 */,
0xEE7E /* 額 */, 0xB6EE /* 额 */,
0xEE80 /* 顎 */, 0xF2A6 /* 颚 */,
0xEE81 /* 顏 */, 0xD1D5 /* 颜 */,
0xEE84 /* 顒 */, 0xEF4A /* 颙 */,
0xEE85 /* 顓 */, 0xF2A7 /* 颛 */,
0xEE86 /* 顔 */, 0xD1D5 /* 颜 */,
0xEE8A /* 願 */, 0xD4B8 /* 愿 */,
0xEE8B /* 顙 */, 0xF2AA /* 颡 */,
0xEE8D /* 顛 */, 0xB5DF /* 颠 */,
0xEE90 /* 類 */, 0xC0E0 /* 类 */,
0xEE94 /* 顢 */, 0xF2A9 /* 颟 */,
0xEE97 /* 顥 */, 0xF2AB /* 颢 */,
0xEE99 /* 顧 */, 0xB9CB /* 顾 */,
0xEE9D /* 顫 */, 0xB2FC /* 颤 */,
0xEE9E /* 顬 */, 0xF2AC /* 颥 */,
0xEF40 /* 顯 */, 0xCFD4 /* 显 */,
0xEF41 /* 顰 */, 0xF2AD /* 颦 */,
0xEF42 /* 顱 */, 0xC2AD /* 颅 */,
0xEF44 /* 顳 */, 0xF2A8 /* 颞 */,
0xEF45 /* 顴 */, 0xC8A7 /* 颧 */,
0xEF4C /* 風 */, 0xB7E7 /* 风 */,
0xEF51 /* 颭 */, 0xEF73 /* 飐 */,
0xEF52 /* 颮 */, 0xECA9 /* 飑 */,
0xEF53 /* 颯 */, 0xECAA /* 飒 */,
0xEF55 /* 颱 */, 0xCCA8 /* 台 */,
0xEF57 /* 颳 */, 0xB9CE /* 刮 */,
0xEF5A /* 颶 */, 0xECAB /* 飓 */,
0xEF5C /* 颸 */, 0xEF74 /* 飔 */,
0xEF5E /* 颺 */, 0xD1EF /* 扬 */,
0xEF5F /* 颻 */, 0xEF75 /* 飖 */,
0xEF60 /* 颼 */, 0xECAC /* 飕 */,
0xEF64 /* 飀 */, 0xEF76 /* 飗 */,
0xEF67 /* 飃 */, 0xC6AE /* 飘 */,
0xEF68 /* 飄 */, 0xC6AE /* 飘 */,
0xEF6A /* 飆 */, 0xECAD /* 飙 */,
0xEF6B /* 飇 */, 0xECAD /* 飙 */,
0xEF6C /* 飈 */, 0xECAE /* 飚 */,
0xEF77 /* 飛 */, 0xB7C9 /* 飞 */,
0xEF7A /* 飠 */, 0xE2BB /* 饣 */,
0xEF7C /* 飢 */, 0xBCA2 /* 饥 */,
0xEF7D /* 飣 */, 0xF097 /* 饤 */,
0xEF80 /* 飥 */, 0xF098 /* 饦 */,
0xEF82 /* 飩 */, 0xE2BD /* 饨 */,
0xEF83 /* 飪 */, 0xE2BF /* 饪 */,
0xEF84 /* 飫 */, 0xE2C0 /* 饫 */,
0xEF86 /* 飭 */, 0xE2C1 /* 饬 */,
0xEF88 /* 飯 */, 0xB7B9 /* 饭 */,
0xEF8B /* 飲 */, 0xD2FB /* 饮 */,
0xEF8D /* 飴 */, 0xE2C2 /* 饴 */,
0xEF95 /* 飼 */, 0xCBC7 /* 饲 */,
0xEF96 /* 飽 */, 0xB1A5 /* 饱 */,
0xEF97 /* 飾 */, 0xCACE /* 饰 */,
0xEF98 /* 飿 */, 0xF099 /* 饳 */,
0xEF9C /* 餃 */, 0xBDC8 /* 饺 */,
0xEF9D /* 餄 */, 0xF09A /* 饸 */,
0xEF9E /* 餅 */, 0xB1FD /* 饼 */,
0xEFE0 /* 镟 */, 0xEDDB /* 碹 */,
0xF041 /* 餉 */, 0xE2C3 /* 饷 */,
0xF042 /* 養 */, 0xD1F8 /* 养 */,
0xF044 /* 餌 */, 0xB6FC /* 饵 */,
0xF045 /* 餎 */, 0xF09B /* 饹 */,
0xF046 /* 餏 */, 0xF09C /* 饻 */,
0xF047 /* 餑 */, 0xE2C4 /* 饽 */,
0xF048 /* 餒 */, 0xC4D9 /* 馁 */,
0xF049 /* 餓 */, 0xB6F6 /* 饿 */,
0xF04A /* 餔 */, 0xB2B8 /* 哺 */,
0xF04B /* 餕 */, 0xF09E /* 馂 */,
0xF04C /* 餖 */, 0xF09D /* 饾 */,
0xF04E /* 餘 */, 0xD3E0 /* 余 */,
0xF050 /* 餚 */, 0xEBC8 /* 肴 */,
0xF051 /* 餛 */, 0xE2C6 /* 馄 */,
0xF052 /* 餜 */, 0xF09F /* 馃 */,
0xF054 /* 餞 */, 0xBDA4 /* 饯 */,
0xF057 /* 餡 */, 0xCFDA /* 馅 */,
0xF05E /* 館 */, 0xB9DD /* 馆 */,
0xF062 /* 餬 */, 0xBAFD /* 糊 */,
0xF066 /* 餱 */, 0xF4D7 /* 糇 */,
0xF068 /* 餳 */, 0xE2BC /* 饧 */,
0xF06A /* 餵 */, 0xCEB9 /* 喂 */,
0xF06B /* 餶 */, 0xF0A0 /* 馉 */,
0xF06C /* 餷 */, 0xE2C7 /* 馇 */,
0xF06F /* 餺 */, 0xF141 /* 馎 */,
0xF071 /* 餼 */, 0xE2BE /* 饩 */,
0xF072 /* 餽 */, 0xC0A1 /* 馈 */,
0xF073 /* 餾 */, 0xC1F3 /* 馏 */,
0xF074 /* 餿 */, 0xE2C8 /* 馊 */,
0xF076 /* 饁 */, 0xF140 /* 馌 */,
0xF078 /* 饃 */, 0xE2C9 /* 馍 */,
0xF07A /* 饅 */, 0xC2F8 /* 馒 */,
0xF07D /* 饈 */, 0xE2CA /* 馐 */,
0xF07E /* 饉 */, 0xE2CB /* 馑 */,
0xF080 /* 饊 */, 0xE2CC /* 馓 */,
0xF081 /* 饋 */, 0xC0A1 /* 馈 */,
0xF082 /* 饌 */, 0xE2CD /* 馔 */,
0xF087 /* 饑 */, 0xBCA2 /* 饥 */,
0xF088 /* 饒 */, 0xC8C4 /* 饶 */,
0xF08B /* 饗 */, 0xF7CF /* 飨 */,
0xF090 /* 饜 */, 0xF7D0 /* 餍 */,
0xF091 /* 饝 */, 0xE2C9 /* 馍 */,
0xF092 /* 饞 */, 0xB2F6 /* 馋 */,
0xF096 /* 饢 */, 0xE2CE /* 馕 */,
0xF152 /* 馬 */, 0xC2ED /* 马 */,
0xF153 /* 馭 */, 0xD4A6 /* 驭 */,
0xF154 /* 馮 */, 0xB7EB /* 冯 */,
0xF157 /* 馱 */, 0xCDD4 /* 驮 */,
0xF159 /* 馳 */, 0xB3DB /* 驰 */,
0xF15A /* 馴 */, 0xD1B1 /* 驯 */,
0xF15F /* 馹 */, 0xF352 /* 驲 */,
0xF167 /* 駁 */, 0xB2B5 /* 驳 */,
0xF176 /* 駐 */, 0xD7A4 /* 驻 */,
0xF177 /* 駑 */, 0xE6E5 /* 驽 */,
0xF178 /* 駒 */, 0xBED4 /* 驹 */,
0xF17A /* 駔 */, 0xE6E0 /* 驵 */,
0xF17B /* 駕 */, 0xBCDD /* 驾 */,
0xF17E /* 駘 */, 0xE6E6 /* 骀 */,
0xF180 /* 駙 */, 0xE6E2 /* 驸 */,
0xF182 /* 駛 */, 0xCABB /* 驶 */,
0xF184 /* 駝 */, 0xCDD5 /* 驼 */,
0xF186 /* 駟 */, 0xE6E1 /* 驷 */,
0xF188 /* 駡 */, 0xC2EE /* 骂 */,
0xF189 /* 駢 */, 0xE6E9 /* 骈 */,
0xF194 /* 駭 */, 0xBAA7 /* 骇 */,
0xF195 /* 駮 */, 0xB2B5 /* 驳 */,
0xF197 /* 駰 */, 0xF353 /* 骃 */,
0xF198 /* 駱 */, 0xC2E6 /* 骆 */,
0xF19F /* 駸 */, 0xF356 /* 骎 */,
0xF1CA /* 袷 */, 0x8A41 /* 夾 */,
0xF245 /* 駿 */, 0xBFA5 /* 骏 */,
0xF247 /* 騁 */, 0xB3D2 /* 骋 */,
0xF248 /* 騂 */, 0xF355 /* 骍 */,
0xF24B /* 騅 */, 0xE6ED /* 骓 */,
0xF252 /* 騌 */, 0xF357 /* 骔 */,
0xF253 /* 騍 */, 0xE6EC /* 骒 */,
0xF254 /* 騎 */, 0xC6EF /* 骑 */,
0xF255 /* 騏 */, 0xE6EB /* 骐 */,
0xF256 /* 騐 */, 0xD1E9 /* 验 */,
0xF25C /* 騖 */, 0xE6F0 /* 骛 */,
0xF25D /* 騗 */, 0xC6AD /* 骗 */,
0xF25F /* 騙 */, 0xC6AD /* 骗 */,
0xF269 /* 騣 */, 0xD7D7 /* 鬃 */,
0xF26A /* 騤 */, 0xF359 /* 骙 */,
0xF271 /* 騫 */, 0xE5B9 /* 骞 */,
0xF273 /* 騭 */, 0xE6EF /* 骘 */,
0xF274 /* 騮 */, 0xE6F2 /* 骝 */,
0xF276 /* 騰 */, 0xCCDA /* 腾 */,
0xF27C /* 騶 */, 0xE6E3 /* 驺 */,
0xF27D /* 騷 */, 0xC9A7 /* 骚 */,
0xF27E /* 騸 */, 0xE6F3 /* 骟 */,
0xF285 /* 騾 */, 0xC2E2 /* 骡 */,
0xF287 /* 驀 */, 0xDDEB /* 蓦 */,
0xF288 /* 驁 */, 0xE6F1 /* 骜 */,
0xF289 /* 驂 */, 0xE6EE /* 骖 */,
0xF28A /* 驃 */, 0xE6F4 /* 骠 */,
0xF28B /* 驄 */, 0xE6F5 /* 骢 */,
0xF28C /* 驅 */, 0xC7FD /* 驱 */,
0xF291 /* 驊 */, 0xE6E8 /* 骅 */,
0xF293 /* 驌 */, 0xF358 /* 骕 */,
0xF294 /* 驍 */, 0xE6E7 /* 骁 */,
0xF296 /* 驏 */, 0xE6F6 /* 骣 */,
0xF29C /* 驕 */, 0xBDBE /* 骄 */,
0xF29E /* 驗 */, 0xD1E9 /* 验 */,
0xF29F /* 驘 */, 0xC2E2 /* 骡 */,
0xF340 /* 驚 */, 0xBEAA /* 惊 */,
0xF341 /* 驛 */, 0xE6E4 /* 驿 */,
0xF345 /* 驟 */, 0xD6E8 /* 骤 */,
0xF348 /* 驢 */, 0xC2BF /* 驴 */,
0xF34A /* 驤 */, 0xE6F8 /* 骧 */,
0xF34B /* 驥 */, 0xE6F7 /* 骥 */,
0xF34C /* 驦 */, 0xF35A /* 骦 */,
0xF350 /* 驪 */, 0xE6EA /* 骊 */,
0xF351 /* 驫 */, 0xF354 /* 骉 */,
0xF361 /* 骯 */, 0xB0B9 /* 肮 */,
0xF369 /* 骾 */, 0xF6E1 /* 鲠 */,
0xF374 /* 髏 */, 0xF7C3 /* 髅 */,
0xF376 /* 髒 */, 0xD4E0 /* 脏 */,
0xF377 /* 體 */, 0xCCE5 /* 体 */,
0xF378 /* 髕 */, 0xF7C6 /* 髌 */,
0xF379 /* 髖 */, 0xF7C5 /* 髋 */,
0xF389 /* 髩 */, 0xF7DE /* 鬓 */,
0xF38C /* 髮 */, 0xB7A2 /* 发 */,
0xF39C /* 鬁 */, 0xF0DF /* 疬 */,
0xF3A0 /* 鬆 */, 0xCBC9 /* 松 */,
0xF445 /* 鬍 */, 0xBAFA /* 胡 */,
0xF450 /* 鬚 */, 0xD0EB /* 须 */,
0xF457 /* 鬢 */, 0xF7DE /* 鬓 */,
0xF459 /* 鬥 */, 0xB6B7 /* 斗 */,
0xF45A /* 鬦 */, 0xB6B7 /* 斗 */,
0xF45B /* 鬧 */, 0xC4D6 /* 闹 */,
0xF45C /* 鬨 */, 0xBAE5 /* 哄 */,
0xF45D /* 鬩 */, 0xE3D2 /* 阋 */,
0xF461 /* 鬭 */, 0xB6B7 /* 斗 */,
0xF462 /* 鬮 */, 0xE3CE /* 阄 */,
0xF464 /* 鬱 */, 0xD3F4 /* 郁 */,
0xF475 /* 魎 */, 0xF7CB /* 魉 */,
0xF47C /* 魘 */, 0xF7CA /* 魇 */,
0xF47E /* 魚 */, 0xD3E3 /* 鱼 */,
0xF480 /* 魛 */, 0xF781 /* 鱽 */,
0xF487 /* 魢 */, 0xF782 /* 鱾 */,
0xF48C /* 魧 */, 0xD0D0 /* 行 */,
0xF48D /* 魨 */, 0xF783 /* 鲀 */,
0xF494 /* 魯 */, 0xC2B3 /* 鲁 */,
0xF499 /* 魴 */, 0xF6D0 /* 鲂 */,
0xF49C /* 魷 */, 0xF6CF /* 鱿 */,
0xF49F /* 魺 */, 0xF785 /* 鲄 */,
0xF4E9 /* 糸 */, 0xE6F9 /* 纟 */,
0xF4F0 /* 麴 */, 0xC7FA /* 曲 */,
0xF545 /* 鮁 */, 0xF6D1 /* 鲅 */,
0xF547 /* 鮃 */, 0xF6D2 /* 鲆 */,
0xF54E /* 鮊 */, 0xF788 /* 鲌 */,
0xF54F /* 鮋 */, 0xF786 /* 鲉 */,
0xF550 /* 鮌 */, 0xF6E7 /* 鲧 */,
0xF551 /* 鮍 */, 0xF789 /* 鲏 */,
0xF552 /* 鮎 */, 0xF6D3 /* 鲇 */,
0xF554 /* 鮐 */, 0xF6D8 /* 鲐 */,
0xF555 /* 鮑 */, 0xB1AB /* 鲍 */,
0xF556 /* 鮒 */, 0xF6D6 /* 鲋 */,
0xF557 /* 鮓 */, 0xF787 /* 鲊 */,
0xF55E /* 鮚 */, 0xF6DA /* 鲒 */,
0xF560 /* 鮜 */, 0xF78D /* 鲘 */,
0xF562 /* 鮞 */, 0xF6DC /* 鲕 */,
0xF56A /* 鮦 */, 0xF78B /* 鲖 */,
0xF56E /* 鮪 */, 0xF6DB /* 鲔 */,
0xF56F /* 鮫 */, 0xF6DE /* 鲛 */,
0xF571 /* 鮭 */, 0xF6D9 /* 鲑 */,
0xF572 /* 鮮 */, 0xCFCA /* 鲜 */,
0xF577 /* 鮳 */, 0xF78A /* 鲓 */,
0xF57A /* 鮶 */, 0xF790 /* 鲪 */,
0xF57B /* 鮷 */, 0xF796 /* 鳀 */,
0xF57E /* 鮺 */, 0xF78F /* 鲝 */,
0xF585 /* 鯀 */, 0xF6E7 /* 鲧 */,
0xF586 /* 鯁 */, 0xF6E1 /* 鲠 */,
0xF58C /* 鯇 */, 0xF6E9 /* 鲩 */,
0xF58E /* 鯉 */, 0xC0F0 /* 鲤 */,
0xF58F /* 鯊 */, 0xF6E8 /* 鲨 */,
0xF597 /* 鯒 */, 0xF791 /* 鲬 */,
0xF599 /* 鯔 */, 0xF6F6 /* 鲻 */,
gitextract_7iywx800/
├── .github/
│ └── workflows/
│ └── release-build.yml
├── Makefile
├── README.md
├── files/
│ ├── mentohust.conf
│ └── mentohust.init
└── src/
├── Makefile
├── dlfunc.c
├── dlfunc.h
├── md5.c
├── md5.h
├── mentohust.c
├── mycheck.c
├── mycheck.h
├── myconfig.c
├── myconfig.h
├── myfunc.c
├── myfunc.h
├── myini.c
├── myini.h
├── mystate.c
├── mystate.h
├── strnormalize.c
├── strnormalize.h
└── types.h
SYMBOL INDEX (118 symbols across 13 files)
FILE: src/dlfunc.c
type bpf_program (line 19) | struct bpf_program
type bpf_program (line 20) | struct bpf_program
type bpf_program (line 22) | struct bpf_program
function load_libpcap (line 30) | int load_libpcap(void) {
function free_libpcap (line 65) | void free_libpcap(void) {
type NotifyNotification (line 78) | typedef void NotifyNotification, GtkWidget, GError;
type gchar (line 79) | typedef char gchar;
type gint (line 80) | typedef int gint, gboolean;
function load_libnotify (line 90) | int load_libnotify(void) {
function free_libnotify (line 128) | void free_libnotify(void) {
function set_timeout (line 143) | void set_timeout(int timeout) {
function show_notify (line 147) | void show_notify(const char *summary, char *body) {
FILE: src/dlfunc.h
type bpf_u_int32 (line 18) | typedef unsigned int bpf_u_int32;
type pcap_t (line 19) | typedef void pcap_t;
type pcap_if_t (line 20) | typedef struct pcap_if {
type bpf_program (line 27) | struct bpf_program {
type pcap_pkthdr (line 31) | struct pcap_pkthdr {
type pcap_pkthdr (line 36) | struct pcap_pkthdr
type bpf_program (line 42) | struct bpf_program
type bpf_program (line 43) | struct bpf_program
type bpf_program (line 45) | struct bpf_program
type bpf_program (line 55) | struct bpf_program
type bpf_program (line 56) | struct bpf_program
type bpf_program (line 58) | struct bpf_program
FILE: src/md5.c
function MD5Init (line 92) | void MD5Init (MD5_CTX * context)
function MD5Update (line 108) | void MD5Update (MD5_CTX *context, UCHAR *input, UINT4 inputLen)
function MD5Final (line 145) | void MD5Final (UCHAR digest[16], MD5_CTX *context)
function MD5Transform (line 172) | static void MD5Transform (UINT4 state[4],UCHAR block[64])
function Encode (line 264) | static void Encode (UCHAR *output, UINT4 *input, UINT4 len)
function Decode (line 279) | static void Decode (UINT4 *output, UCHAR *input, UINT4 len)
function UCHAR (line 289) | UCHAR* ComputeHash(UCHAR* src, UINT4 len)
FILE: src/md5.h
type MD5_CTX (line 30) | typedef struct
FILE: src/mentohust.c
type pcap_pkthdr (line 41) | struct pcap_pkthdr
function main (line 45) | int main(int argc, char **argv)
function exit_handle (line 69) | static void exit_handle(void)
function sig_handle (line 88) | static void sig_handle(int sig)
function pcap_handle (line 110) | static void pcap_handle(u_char *user, const struct pcap_pkthdr *h, const...
function showRuijieMsg (line 222) | static void showRuijieMsg(const u_char *buf, unsigned bufLen)
function showCernetMsg (line 262) | static void showCernetMsg(const u_char *buf)
FILE: src/mycheck.c
function WORD (line 20) | WORD ltobs(WORD x) {
function DWORD (line 24) | DWORD ltobl(DWORD x) {
function hex_to_str (line 32) | void hex_to_str(const BYTE *a, char *b, int hexsize, int upper) {
function BYTE (line 42) | BYTE *ReadCode(const char *file, DWORD *size) {
function BYTE (line 76) | BYTE *ReadCode2(const char *dataFile, DWORD *size) {
function check_free (line 99) | void check_free() {
function check_init (line 106) | int check_init(const char *dataFile) {
function V2_check (line 120) | void V2_check(const BYTE *seed, char *final_str) {
function DWORD (line 136) | DWORD getVer(const char *file) {
FILE: src/mycheck.h
type IMAGE_DOS_HEADER (line 14) | typedef struct _IMAGE_DOS_HEADER { // DOS .EXE header
type IMAGE_FILE_HEADER (line 36) | typedef struct _IMAGE_FILE_HEADER {
type IMAGE_DATA_DIRECTORY (line 46) | typedef struct _IMAGE_DATA_DIRECTORY {
type IMAGE_OPTIONAL_HEADER (line 52) | typedef struct _IMAGE_OPTIONAL_HEADER {
type IMAGE_SECTION_HEADER (line 96) | typedef struct _IMAGE_SECTION_HEADER {
type PE_HEADER_MAP (line 112) | typedef struct _PE_HEADER_MAP
type IMAGE_RESOURCE_DIRECTORY_ENTRY (line 120) | typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
type IMAGE_RESOURCE_DIRECTORY (line 159) | typedef struct _IMAGE_RESOURCE_DIRECTORY {
type IMAGE_RESOURCE_DATA_ENTRY (line 169) | typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
type VS_FIXEDFILEINFO (line 176) | typedef struct tagVS_FIXEDFILEINFO {
type VS_VERSIONINFO (line 192) | typedef struct _VS_VERSIONINFO {
FILE: src/myconfig.c
function encodePass (line 86) | static int encodePass(char *dst, const char *osrc) {
function decodePass (line 115) | static int decodePass(char *dst, const char *src) {
function initConfig (line 151) | void initConfig(int argc, char **argv)
function readFile (line 228) | static int readFile(int *daemonMode)
function readArg (line 284) | static void readArg(char argc, char **argv, int *saveFlag, int *exitFlag...
function showHelp (line 360) | static void showHelp(const char *fileName)
function getAdapter (line 394) | static int getAdapter()
function printConfig (line 436) | static void printConfig()
function openPcap (line 465) | static int openPcap()
function saveConfig (line 492) | static void saveConfig(int daemonMode)
function checkRunning (line 538) | static void checkRunning(int exitFlag, int daemonMode)
FILE: src/myfunc.c
function checkFile (line 79) | static int checkFile() {
function getVersion (line 105) | static int getVersion() {
function newBuffer (line 121) | void newBuffer()
function getAddress (line 132) | static int getAddress()
function u_char (line 213) | static u_char encode(u_char base) /* 算法，将一个字节的8位颠倒并取反 */
function checkSum (line 226) | static void checkSum(u_char *buf) /* 算法，计算两个字节的checksum */
function fillHeader (line 275) | int fillHeader()
function setProperty (line 292) | static int setProperty(u_char type, const u_char *value, int length)
function readPacket (line 309) | static int readPacket(int type)
function fillStartPacket (line 342) | void fillStartPacket()
function fillMd5Packet (line 398) | void fillMd5Packet(const u_char *md5Seed)
function Check (line 414) | static int Check(const u_char *md5Seed) /* 客户端校验 */
function fillEchoPacket (line 432) | void fillEchoPacket(u_char *echoBuf)
function getEchoKey (line 445) | void getEchoKey(const u_char *capBuf)
function u_char (line 455) | u_char *checkPass(u_char id, const u_char *md5Seed, int seedLen)
function fillCernetAddr (line 472) | void fillCernetAddr(u_char *buf)
function isOnline (line 480) | int isOnline()
FILE: src/myini.c
function getLine (line 46) | static void getLine(const char *buf, int inStart, int *lineStart, int *l...
function findKey (line 55) | static int findKey(const char *buf, const char *section, const char *key,
function getString (line 88) | int getString(const char *buf, const char *section, const char *key,
function getInt (line 106) | int getInt(const char *buf, const char *section, const char *key, int de...
function setString (line 115) | void setString(char **buf, const char *section, const char *key, const c...
function getSection (line 170) | static int getSection(const char *buf, int inStart)
function setInt (line 186) | void setInt(char **buf, const char *section, const char *key, int value)
function saveFile (line 193) | int saveFile(const char *buf, const char *fileName)
FILE: src/mystate.c
function setTimer (line 53) | static void setTimer(unsigned interval) /* 设置定时器 */
function switchState (line 63) | int switchState(int type)
function restart (line 122) | int restart()
function renewIP (line 132) | static int renewIP()
function fillEtherAddr (line 146) | static void fillEtherAddr(u_int32_t protocol)
function sendStartPacket (line 154) | static int sendStartPacket()
function sendIdentityPacket (line 181) | static int sendIdentityPacket()
function sendChallengePacket (line 218) | static int sendChallengePacket()
function sendEchoPacket (line 256) | static int sendEchoPacket()
function sendLogoffPacket (line 282) | static int sendLogoffPacket()
function waitEchoPacket (line 298) | static int waitEchoPacket()
function sendArpPacket (line 306) | static void sendArpPacket()
FILE: src/strnormalize.c
function str_normalize_init (line 37) | void str_normalize_init()
function str_normalize_utf8 (line 16484) | void str_normalize_utf8(char *text, unsigned options)
function str_normalize_gbk (line 16546) | void str_normalize_gbk(char *text, unsigned options)
function gbk_to_utf8 (line 16595) | int gbk_to_utf8(const char *from, unsigned int from_len, char **to, unsi...
function utf8_to_gbk (line 16645) | int utf8_to_gbk(const char *from, unsigned int from_len, char **to, unsi...
FILE: src/types.h
type BYTE (line 4) | typedef unsigned char BYTE;
type UCHAR (line 5) | typedef unsigned char UCHAR;
type WORD (line 6) | typedef unsigned short int WORD;
type LONG (line 7) | typedef int LONG;
type DWORD (line 8) | typedef unsigned int DWORD;
type UINT4 (line 9) | typedef unsigned int UINT4;
Condensed preview — 24 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (610K chars).
[
{
"path": ".github/workflows/release-build.yml",
"chars": 1752,
"preview": "name: Build\n\non:\n release:\n types:\n - published\n\njobs:\n build:\n name: Build ${{ matrix.arch }}\n runs-on:"
},
{
"path": "Makefile",
"chars": 1412,
"preview": "#\n# Copyright (C) 2014-2015 KyleRicardo\n#\n# This is free software, licensed under the GNU General Public License v3.\n# S"
},
{
"path": "README.md",
"chars": 7223,
"preview": "# MentoHUST-OpenWrt-ipk\n\n这是一个积累了很长时间的项目。从2014年起，就陆续在折腾这些东西，期间还自己写了一个基于OpenWrt的神州数码客户端[802.1X Evasi0n](https://github.com"
},
{
"path": "files/mentohust.conf",
"chars": 883,
"preview": "# MentoHUST for Linux By HustMoon Studio\n#\n# 配置文件名称必须是小写/etc/mentohust.conf，编码格式建议是UTF-8\n# 配置文件中一行开头的空格和Tab会被忽略，其他的会视为参数"
},
{
"path": "files/mentohust.init",
"chars": 287,
"preview": "#!/bin/sh /etc/rc.common\n\nSTART=99\nSTOP=01\n\nUSE_PROCD=1\nPROG=/usr/sbin/mentohust\n\nstart_service() {\n\tprocd_open_instance"
},
{
"path": "src/Makefile",
"chars": 1018,
"preview": "include $(TOPDIR)/rules.mk\ninclude $(INCLUDE_DIR)/package.mk\n\nCC = mips-openwrt-linux-gcc\nCFLAGS = -Wall -g -O2\nINC_DIR="
},
{
"path": "src/dlfunc.c",
"chars": 4757,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：dlfunc.c\n* 摘\t要：动态载入库函数\n* 作\t者：Hust"
},
{
"path": "src/dlfunc.h",
"chars": 2289,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* 文件名称：dlfunc.h\n* 摘\t要：动态载入库函数\n*/\n#ifndef HUSTMOON_DLFUNC_H\n#define HUSTMOON_DLFU"
},
{
"path": "src/md5.c",
"chars": 9387,
"preview": "/* MD5.c - an implementation of md5 algorithm */\n\n/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All\nrig"
},
{
"path": "src/md5.h",
"chars": 1377,
"preview": "/* MD5.H - header file for MD5.C */\n\n/*\nCopyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All\nrights reserved."
},
{
"path": "src/mentohust.c",
"chars": 6945,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：mentohust.c\n* 摘\t要：MentoHUST主函数\n* "
},
{
"path": "src/mycheck.c",
"chars": 4870,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：mycheck.c\n* 摘\t要：客户端校验算法\n* 作\t者：kkH"
},
{
"path": "src/mycheck.h",
"chars": 5545,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：mycheck.h\n* 摘\t要：客户端校验算法\n* 作\t者：kkH"
},
{
"path": "src/myconfig.c",
"chars": 16548,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：myconfig.c\n* 摘\t要：初始化认证参数\n* 作\t者：Hu"
},
{
"path": "src/myconfig.h",
"chars": 215,
"preview": "/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：myconfig.h\n* 摘\t要：初始化认证参数\n* 作\t者：HustMoon@BYHH\n*/\n#ifndef HUSTMOON_MYCON"
},
{
"path": "src/myfunc.c",
"chars": 15948,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：myfunc.c\n* 摘\t要：认证相关算法及方法\n* 作\t者：Hu"
},
{
"path": "src/myfunc.h",
"chars": 728,
"preview": "/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：myfunc.h\n* 摘\t要：认证相关算法及方法\n* 作\t者：HustMoon@BYHH\n*/\n#ifndef HUSTMOON_MYFUN"
},
{
"path": "src/myini.c",
"chars": 5305,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：myini.c\n* 摘\t要：读取ini文件+写入ini文件\n* 作"
},
{
"path": "src/myini.h",
"chars": 892,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：myini.h\n* 摘\t要：读取ini文件+写入ini文件\n* 作"
},
{
"path": "src/mystate.c",
"chars": 8454,
"preview": "/* -*- Mode: C; tab-width: 4; -*- */\n/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：mystate.c\n* 摘\t要：改变认证状态\n* 作\t者：Hust"
},
{
"path": "src/mystate.h",
"chars": 465,
"preview": "/*\n* Copyright (C) 2009, HustMoon Studio\n*\n* 文件名称：mystate.h\n* 摘\t要：改变认证状态\n* 作\t者：HustMoon@BYHH\n*/\n#ifndef HUSTMOON_MYSTATE"
},
{
"path": "src/strnormalize.c",
"chars": 418209,
"preview": "#include \"strnormalize.h\"\n#include <stdlib.h>\n\n#define SWAPBYTE(x) (((unsigned short)(x) >> 8) | (unsigned short)(x) << "
},
{
"path": "src/strnormalize.h",
"chars": 850,
"preview": "/**\n * Copyright(c) 2012-2013, All Rights Reserved.\n *\n * @file strnormalize.h\n * @details Check GBK character you could"
},
{
"path": "src/types.h",
"chars": 235,
"preview": "#ifndef TYPES_H\n#define TYPES_H\ntypedef unsigned char *POINTER;\ntypedef unsigned char BYTE;\ntypedef unsigned char UCHAR;"
}
]
About this extraction
This page contains the full source code of the KyleRicardo/MentoHUST-OpenWrt-ipk GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 24 files (503.5 KB), approximately 337.3k tokens, and a symbol index with 118 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.