From 19b2aa43d6ec3a8552f007f93f2550e93820254d Mon Sep 17 00:00:00 2001 From: sladro Date: Thu, 19 Mar 2026 11:32:09 +0800 Subject: [PATCH] Add robot dog OCR service and ignore local artifacts --- .gitignore | 34 + app/api/main.py | 32 + app/api/v1/api.py | 394 + app/api/v1/testLogin.py | 122 + app/config/config.py | 89 + app/config/constant.py | 77 + app/core/database.py | 32 + app/crud/base.py | 88 + app/crud/event.py | 130 + app/dao/imageDao.py | 18 + app/main.py | 25 + app/models/models.py | 134 + app/schemas/__init__.py | 0 app/schemas/event.py | 116 + app/schemas/image.py | 15 + app/schemas/ocr.py | 11 + app/services/imageServices.py | 15 + app/util/baiduOCR.py | 535 + app/util/responseHttp.py | 266 + app/util/yolov8Obj.py | 470 + base64.txt | 1 + dict.yaml | 18385 ++++++++++++++++++++++++++++++++ robot_dog.service | 14 + run.py | 14 + start.sh | 32 + test_base64_server.py | 110 + test_generic.py | 27 + test_ocr.py | 7 + test_requests.py | 87 + 29 files changed, 21280 insertions(+) create mode 100644 .gitignore create mode 100644 app/api/main.py create mode 100644 app/api/v1/api.py create mode 100644 app/api/v1/testLogin.py create mode 100644 app/config/config.py create mode 100644 app/config/constant.py create mode 100644 app/core/database.py create mode 100644 app/crud/base.py create mode 100644 app/crud/event.py create mode 100644 app/dao/imageDao.py create mode 100644 app/main.py create mode 100644 app/models/models.py create mode 100644 app/schemas/__init__.py create mode 100644 app/schemas/event.py create mode 100644 app/schemas/image.py create mode 100644 app/schemas/ocr.py create mode 100644 app/services/imageServices.py create mode 100644 app/util/baiduOCR.py create mode 100644 app/util/responseHttp.py create mode 100644 app/util/yolov8Obj.py create mode 100644 base64.txt create mode 100644 dict.yaml create mode 100644 robot_dog.service create mode 100644 run.py create mode 100644 start.sh create mode 100644 test_base64_server.py create mode 100644 test_generic.py create mode 100644 test_ocr.py create mode 100644 test_requests.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8f65f24 --- /dev/null +++ b/.gitignore @@ -0,0 +1,34 @@ +__pycache__/ +*.py[cod] +*$py.class + +.Python +.venv/ +venv/ +env/ +ENV/ + +.env +.env.* + +.idea/ +.vscode/ + +.pytest_cache/ +.mypy_cache/ +.ruff_cache/ +.coverage +.coverage.* +htmlcov/ + +build/ +dist/ +*.egg-info/ +.eggs/ + +logs/ +tmp/ + +*.log +*.pid + diff --git a/app/api/main.py b/app/api/main.py new file mode 100644 index 0000000..523ed8c --- /dev/null +++ b/app/api/main.py @@ -0,0 +1,32 @@ +from fastapi import FastAPI, WebSocket +from fastapi.middleware.cors import CORSMiddleware +from app.api.v1.api import router +# from app.core.config import settings +# from app.services.websocket_service import websocket_service + +app = FastAPI( + title="机器狗后台服务", + description="机器狗后台API接口", + version="1.0.0" +) + +# 配置CORS +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], # 在生产环境中应该设置具体的域名 + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +# 注册路由 +app.include_router(router) + +# @app.websocket("/ws") +# async def websocket_endpoint(websocket: WebSocket): +# """WebSocket端点""" +# await websocket_service.handle_websocket(websocket) + +@app.get("/") +async def root(): + return {"message": "机器狗后台API服务正在运行"} \ No newline at end of file diff --git a/app/api/v1/api.py b/app/api/v1/api.py new file mode 100644 index 0000000..77e5a78 --- /dev/null +++ b/app/api/v1/api.py @@ -0,0 +1,394 @@ +from typing import List, Optional +from fastapi import APIRouter, Depends, HTTPException, Query +from sqlalchemy.ext.asyncio import AsyncSession +import base64 +import io +import cv2 +import numpy as np +from PIL import Image +import os +import uuid +from datetime import datetime + + +from app.core.database import get_db +from app.services.imageServices import ImageService +from app.schemas.image import ImageBase +from app.schemas.ocr import ImageBase64Request +from app.util.responseHttp import ResponseUtil +from app.util.baiduOCR import BaiduOCR, BaiduOCRONNX +from app.util.yolov8Obj import Yolov8Obj, YOLOv8ONNX + +# from app.crud.event import event +# from app.schemas.event import EventList, EventDetail, EventUpdate, EventQuery, TestEvent + +baiduOCR = BaiduOCR() +baiduOcrOnnx = BaiduOCRONNX() +yolov8Obj = Yolov8Obj() +yolov8ONNX = YOLOv8ONNX() + +router = APIRouter(prefix="/api/v1", tags=["ocr"]) + +@router.get("/hello") +async def get_hello(): + + # return {"data":"hello"} + return ResponseUtil.error(msg=f"OCR识别失败", data=None) + +@router.get("/test_select") +async def test_select( + db: AsyncSession = Depends(get_db), + image_query: ImageBase = None +): + """ + 测试查询 + """ + result = await ImageService.get_image_list(db,image_query) + return ResponseUtil.success(msg="success", data=result) + + +@router.get("/test_ocr") +async def test_ocr( + # image_path: str = None +): + """ + 测试OCR + """ + + image_path = '/home/admin-root/haotian/康达瑞贝斯机器狗/data_image/001读表图片/2c7cc83019e7388a7041101da92c9829_frame_000000.jpg' + + + result = baiduOCR.ocr(image_path) + # print(result) + return ResponseUtil.success(msg="success", data=result) + # return ResponseUtil.success(msg="success") + + +@router.post("/ocr_from_base64") +async def ocr_from_base64(request: ImageBase64Request): + """ + 从base64图片数据进行OCR识别 + """ + try: + # 移除base64数据的前缀（如果有） + image_base64 = request.image_base64 + if image_base64.startswith('data:image'): + # 格式如: data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQ... + image_base64 = image_base64.split(',')[1] + + # 解码base64数据 + image_data = base64.b64decode(image_base64) + + # 将字节数据转换为PIL Image对象 + image = Image.open(io.BytesIO(image_data)) + + # 创建临时文件路径 + temp_dir = "tmp/ocr_images" + os.makedirs(temp_dir, exist_ok=True) + temp_filename = f"{uuid.uuid4()}.{request.image_type or 'jpg'}" + temp_path = os.path.join(temp_dir, temp_filename) + + # 保存图片到临时文件 + image.save(temp_path) + + # 使用PaddleOCR进行识别 + result = baiduOCR.ocr(temp_path) + + # 删除临时文件 + # os.remove(temp_path) + + return ResponseUtil.success(msg="OCR识别成功", data=result) + except Exception as e: + return ResponseUtil.error(msg=f"OCR识别失败: {str(e)}", data=None) + + +@router.post("/ocr_onnx_from_base64") +async def ocr_from_base64(request: ImageBase64Request): + """ + 从base64图片数据进行OCR识别 + """ + try: + # 移除base64数据的前缀（如果有） + image_base64 = request.image_base64 + if image_base64.startswith('data:image'): + # 格式如: data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQ... + image_base64 = image_base64.split(',')[1] + + # 解码base64数据 + image_data = base64.b64decode(image_base64) + + # 将字节数据转换为PIL Image对象 + image = Image.open(io.BytesIO(image_data)) + + # 创建临时文件路径 + temp_dir = "./tmp/ocr_images" + os.makedirs(temp_dir, exist_ok=True) + temp_filename = f"{uuid.uuid4()}.{request.image_type or 'jpg'}" + temp_path = os.path.join(temp_dir, temp_filename) + + # 保存图片到临时文件 + image.save(temp_path) + + # 使用PaddleOCR进行识别 + result = baiduOcrOnnx.ocr(temp_path) + print(result) + + # 删除临时文件 + # os.remove(temp_path) + + # return ResponseUtil.success(msg="OCR识别成功", data=[result['text'], result['confidence']]) + return ResponseUtil.success(msg="OCR识别成功", data=result) + except Exception as e: + return ResponseUtil.error(msg=f"OCR识别失败: {str(e)}", data=None) + + +@router.post("/detect_from_base64_0") +async def ocr_from_base64(request: ImageBase64Request): + """ 从base64图片进行目标检测, 检测是否侵占消防区域""" + + try: + image_base64 = request.image_base64 + if image_base64.startswith('data:image'): + image_base64 = image_base64.split(',')[1] + image_data = base64.b64decode(image_base64) + + image = Image.open(io.BytesIO(image_data)) + + temp_dir = "./tmp/detect_images" + os.makedirs(temp_dir, exist_ok=True) + temp_filename = f"{uuid.uuid4()}.{request.image_type or 'jpg'}" + temp_path = os.path.join(temp_dir, temp_filename) + + image.save(temp_path) + + cls, conf, coords = yolov8Obj.detect(temp_path) + + os.remove(temp_path) + + return ResponseUtil.success(msg="侵占消防区域目标检测成功,是否有遮挡", data=(len(cls)==0)) + + except Exception as e: + return ResponseUtil.error(msg=f"检测是否侵占消防区域失败: {str(e)}", data=None) + + +@router.post("/detect_onnx_from_base64_0") +async def ocr_from_base64(request: ImageBase64Request): + """ 从base64图片进行目标检测, 检测是否侵占消防区域""" + + # 为不同类别生成不同颜色 + def get_color(class_id): + np.random.seed(class_id) + return tuple(map(int, np.random.randint(0, 255, 3))) + + try: + # image_base64 = request.image_base64 + # if image_base64.startswith('data:image'): + # image_base64 = image_base64.split(',')[1] + # image_data = base64.b64decode(image_base64) + + # image = Image.open(io.BytesIO(image_data)) + + # temp_dir = "./tmp/detect_images" + # os.makedirs(temp_dir, exist_ok=True) + # temp_filename = f"{uuid.uuid4()}.{request.image_type or 'jpg'}" + # temp_path = os.path.join(temp_dir, temp_filename) + + # image.save(temp_path) + + # boxes, scores, class_ids = yolov8ONNX.detect(image_data) + + # os.remove(temp_path) + + image_base64 = request.image_base64 + if image_base64.startswith('data:image'): + image_base64 = image_base64.split(',')[1] + image_data = base64.b64decode(image_base64) + + # 将字节流转换为OpenCV格式的BGR图像 + image_np = np.frombuffer(image_data, np.uint8) + image_cv = cv2.imdecode(image_np, cv2.IMREAD_COLOR) # 这会得到BGR格式的图像 + + # 不再需要保存到临时文件，直接使用内存中的图像 + boxes, scores, class_ids = yolov8ONNX.detect(image_cv) + + + # 绘制检测结果 + image_with_boxes = image_cv.copy() + + for box, score, class_id in zip(boxes, scores, class_ids): + # 获取边界框坐标 + x1, y1, x2, y2 = map(int, box) + + # 生成随机颜色或使用固定颜色方案 + color = get_color(class_id) # 绿色，也可以根据class_id设置不同颜色 + + # 绘制边界框 + cv2.rectangle(image_with_boxes, (x1, y1), (x2, y2), color, 2) + + # 准备标签文本 + label = f"Class {class_id}: {score:.2f}" + # 如果你有类别名称字典，可以这样使用： + # label = f"{class_names[class_id]}: {score:.2f}" + + # 计算文本大小以绘制背景 + (text_width, text_height), baseline = cv2.getTextSize( + label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1 + ) + + # 绘制文本背景 + cv2.rectangle( + image_with_boxes, + (x1, y1 - text_height - baseline - 5), + (x1 + text_width, y1), + color, + -1 + ) + + # 绘制文本 + cv2.putText( + image_with_boxes, + label, + (x1, y1 - 5), + cv2.FONT_HERSHEY_SIMPLEX, + 0.5, + (0, 0, 0), # 黑色文字 + 1, + cv2.LINE_AA + ) + + # 创建保存目录 + save_dir = "tmp/detect_images" + os.makedirs(save_dir, exist_ok=True) + + # 生成带时间戳的随机文件名 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + random_id = uuid.uuid4().hex[:8] # 取UUID的前8位 + filename = f"detect_{timestamp}_{random_id}.jpg" + output_path = os.path.join(save_dir, filename) + + # 保存图像 + cv2.imwrite(output_path, image_with_boxes) + print(f"检测结果已保存到: {output_path}") + + return ResponseUtil.success(msg="侵占消防区域目标检测成功,是否有遮挡", data=(len(boxes)==0)) + + except Exception as e: + return ResponseUtil.error(msg=f"检测是否侵占消防区域失败: {str(e)}", data=None) + +@router.post("/detect_from_base64_1") +async def ocr_from_base64(request: ImageBase64Request): + """ 从吧色图64图片进行目标检测, 检测是否存在灭火器""" + + # try: + # 为不同类别生成不同颜色 + def get_color(class_id): + np.random.seed(class_id) + return tuple(map(int, np.random.randint(0, 255, 3))) + + try: + + image_base64 = request.image_base64 + if image_base64.startswith('data:image'): + image_base64 = image_base64.split(',')[1] + image_data = base64.b64decode(image_base64) + + # 将字节流转换为OpenCV格式的BGR图像 + image_np = np.frombuffer(image_data, np.uint8) + image_cv = cv2.imdecode(image_np, cv2.IMREAD_COLOR) # 这会得到BGR格式的图像 + + # 不再需要保存到临时文件，直接使用内存中的图像 + boxes, scores, class_ids = yolov8ONNX.detect(image_cv) + + + # 绘制检测结果 + image_with_boxes = image_cv.copy() + + for box, score, class_id in zip(boxes, scores, class_ids): + # 获取边界框坐标 + x1, y1, x2, y2 = map(int, box) + + # 生成随机颜色或使用固定颜色方案 + color = get_color(class_id) # 绿色，也可以根据class_id设置不同颜色 + + # 绘制边界框 + cv2.rectangle(image_with_boxes, (x1, y1), (x2, y2), color, 2) + + # 准备标签文本 + label = f"Class {class_id}: {score:.2f}" + # 如果你有类别名称字典，可以这样使用： + # label = f"{class_names[class_id]}: {score:.2f}" + + # 计算文本大小以绘制背景 + (text_width, text_height), baseline = cv2.getTextSize( + label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1 + ) + + # 绘制文本背景 + cv2.rectangle( + image_with_boxes, + (x1, y1 - text_height - baseline - 5), + (x1 + text_width, y1), + color, + -1 + ) + + # 绘制文本 + cv2.putText( + image_with_boxes, + label, + (x1, y1 - 5), + cv2.FONT_HERSHEY_SIMPLEX, + 0.5, + (0, 0, 0), # 黑色文字 + 1, + cv2.LINE_AA + ) + + # 创建保存目录 + save_dir = "tmp/detect_images" + os.makedirs(save_dir, exist_ok=True) + + # 生成带时间戳的随机文件名 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + random_id = uuid.uuid4().hex[:8] # 取UUID的前8位 + filename = f"detect_{timestamp}_{random_id}.jpg" + output_path = os.path.join(save_dir, filename) + + # 保存图像 + cv2.imwrite(output_path, image_with_boxes) + print(f"检测结果已保存到: {output_path}") + + return ResponseUtil.success(msg="灭火器目标检测成功,是否存在灭火器", data=(len(class_ids)!=0 and 0 in class_ids)) + # return ResponseUtil.success(msg="目标检测成功", data=cls) + + except Exception as e: + return ResponseUtil.error(msg=f"检测是否存在灭火器失败: {str(e)}", data=None) + +# @router.post("/detect_from_base64_1") +# async def ocr_from_base64(request: ImageBase64Request): +# """ 从吧色图64图片进行目标检测, 检测是否存在灭火器""" + +# try: +# image_base64 = request.image_base64 +# if image_base64.startswith('data:image'): +# image_base64 = image_base64.split(',')[1] +# image_data = base64.b64decode(image_base64) + +# image = Image.open(io.BytesIO(image_data)) + +# temp_dir = "./tmp/detect_images" +# os.makedirs(temp_dir, exist_ok=True) +# temp_filename = f"{uuid.uuid4()}.{request.image_type or 'jpg'}" +# temp_path = os.path.join(temp_dir, temp_filename) + +# image.save(temp_path) + +# cls, conf, coords = yolov8Obj.detect(temp_path) + +# os.remove(temp_path) + +# return ResponseUtil.success(msg="灭火器目标检测成功,是否存在灭火器", data=(len(cls)!=0 and 0 in cls)) +# # return ResponseUtil.success(msg="目标检测成功", data=cls) + +# except Exception as e: +# return ResponseUtil.error(msg=f"检测是否存在灭火器失败: {str(e)}", data=None) \ No newline at end of file diff --git a/app/api/v1/testLogin.py b/app/api/v1/testLogin.py new file mode 100644 index 0000000..11a6457 --- /dev/null +++ b/app/api/v1/testLogin.py @@ -0,0 +1,122 @@ +from datetime import datetime, timedelta +from typing import Optional + +from fastapi import Depends, FastAPI, HTTPException, status +from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm +from jose import JWTError, jwt +from passlib.context import CryptContext +from pydantic import BaseModel + +# 配置参数（应从环境变量读取） +SECRET_KEY = "your-secret-key-keep-it-secret!" +ALGORITHM = "HS256" +ACCESS_TOKEN_EXPIRE_MINUTES = 30 + +# 模拟用户数据库 +fake_users_db = { + "johndoe": { + "username": "johndoe", + "full_name": "John Doe", + "email": "johndoe@example.com", + # 哈希后的密码（明文是 secret） + "hashed_password": "$2b$12$EixZaYVK1fsbY1eZIbOnjesN9NwG1s3Z6FDcjyH103a2.dJgD0L4q", + "disabled": False, + } +} + +# Token 模型 +class Token(BaseModel): + access_token: str + token_type: str + +class TokenData(BaseModel): + username: Optional[str] = None + +# 用户模型 +class User(BaseModel): + username: str + email: Optional[str] = None + full_name: Optional[str] = None + disabled: Optional[bool] = None + +class UserInDB(User): + hashed_password: str + +# 密码哈希配置 +pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto") + +# OAuth2 配置 +oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") + +app = FastAPI() + +# 密码验证工具 +def verify_password(plain_password: str, hashed_password: str): + return pwd_context.verify(plain_password, hashed_password) + +# 获取用户 +def get_user(db, username: str): + if username in db: + user_dict = db[username] + return UserInDB(**user_dict) + +# 用户认证 +def authenticate_user(fake_db, username: str, password: str): + user = get_user(fake_db, username) + if not user: + return False + # if not verify_password(password, user.hashed_password): + # return False + return user + +# 创建访问令牌 +def create_access_token(data: dict, expires_delta: Optional[timedelta] = None): + to_encode = data.copy() + if expires_delta: + expire = datetime.utcnow() + expires_delta + else: + expire = datetime.utcnow() + timedelta(minutes=15) + to_encode.update({"exp": expire}) + encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM) + return encoded_jwt + +# 获取当前用户（依赖注入） +async def get_current_user(token: str = Depends(oauth2_scheme)): + credentials_exception = HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Could not validate credentials", + headers={"WWW-Authenticate": "Bearer"}, + ) + try: + payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM]) + username: str = payload.get("sub") + if username is None: + raise credentials_exception + token_data = TokenData(username=username) + except JWTError: + raise credentials_exception + user = get_user(fake_users_db, username=token_data.username) + if user is None: + raise credentials_exception + return user + +# 登录路由 +@app.post("/token", response_model=Token) +async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()): + user = authenticate_user(fake_users_db, form_data.username, form_data.password) + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Incorrect username or password", + headers={"WWW-Authenticate": "Bearer"}, + ) + access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) + access_token = create_access_token( + data={"sub": user.username}, expires_delta=access_token_expires + ) + return {"access_token": access_token, "token_type": "bearer"} + +# 受保护路由 +@app.get("/users/me/", response_model=User) +async def read_users_me(current_user: User = Depends(get_current_user)): + return current_user \ No newline at end of file diff --git a/app/config/config.py b/app/config/config.py new file mode 100644 index 0000000..0ececeb --- /dev/null +++ b/app/config/config.py @@ -0,0 +1,89 @@ +from pydantic_settings import BaseSettings +import os +import sys +import argparse +from dotenv import load_dotenv + +class DataBaseSettings(BaseSettings): + # 数据库配置 + DB_HOST: str = "10.0.0.17" + DB_PORT: int = 3306 + DB_USER: str = "root" + DB_PASSWORD: str = "root" + DB_NAME: str = "kangda_robotic_dog" + DB_CHARSET: str = "utf8mb4" + DB_POOL_SIZE: int = 5 + DB_MAX_OVERFLOW: int = 10 + DB_POOL_TIMEOUT: int = 30 + DB_POOL_RECYCLE: int = 1800 + + # class Config: + # env_file = ".env" + +class OCRSettings(BaseException): + TEXT_DETECTION_MODEL_DIR= "/root/robot_dog_project/kangda_robotic_dog/models/PP-OCRv5_server_det_infer_20250814/" + TEXT_RECONGNITION_MODEL_DIR= "/root/robot_dog_project/kangda_robotic_dog/models/PP-OCRv5_server_rec_infer_20250815/" + + # TEXT_DETECTION_MODEL_ONNX_DIR: str ='/home/admin-root/haotian/康达瑞贝斯机器狗/det_shape_20250814.onnx' + # TEXT_RECONGNITION_MODEL_ONNX_DIR: str ='/home/admin-root/haotian/康达瑞贝斯机器狗/rec_shape_20250815.onnx' + + TEXT_DETECTION_MODEL_ONNX_DIR="/root/robot_dog_project/kangda_robotic_dog/models/det_mobile_14_shape.onnx" + TEXT_RECONGNITION_MODEL_ONNX_DIR="/root/robot_dog_project/kangda_robotic_dog/models/rec_mobile_14_shape.onnx" + +class YoloV8Settings(BaseException): + YOLOV8_MODEL_DIR= "/root/robot_dog_project/kangda_robotic_dog/models/best.pt" + YOLOV8_MODEL_ONNX_DIRS="/root/robot_dog_project/kangda_robotic_dog/models/yolov8_20250820.onnx" + + +class GetSettings: + + def __init__(self): + self.parse_cli_args() + + def get_database_settings(self): + return DataBaseSettings() + + def get_ocr_settings(self): + return OCRSettings() + + def get_yolov8_settings(self): + return YoloV8Settings() + + + def parse_cli_args(self): + """ + 解析命令行参数 + """ + if 'uvicorn' in sys.argv[0]: + # 使用uvicorn启动时，命令行参数需要按照uvicorn的文档进行配置，无法自定义参数 + pass + else: + # 使用argparse定义命令行参数 + parser = argparse.ArgumentParser(description='命令行参数') + parser.add_argument('--env', type=str, default='dev', help='运行环境') + # 解析命令行参数 + args = parser.parse_args() + # 设置环境变量，如果未设置命令行参数，默认APP_ENV为dev + os.environ['APP_ENV'] = args.env if args.env else 'dev' + # 读取运行环境 + run_env = os.environ.get('APP_ENV', '') + # 运行环境未指定时默认加载.env.dev + env_file = '.env.dev' + # 运行环境不为空时按命令行参数加载对应.env文件 + if run_env != '': + env_file = f'.env.{run_env}' + + + print(f"加载配置 .env.{run_env}") + # 加载配置 + load_dotenv(env_file) + +get_settings = GetSettings() + +database_settings = get_settings.get_database_settings() + +ocr_settings = get_settings.get_ocr_settings() + +yolov8_settings = get_settings.get_yolov8_settings() + + diff --git a/app/config/constant.py b/app/config/constant.py new file mode 100644 index 0000000..42b0799 --- /dev/null +++ b/app/config/constant.py @@ -0,0 +1,77 @@ +# from config.env import DataBaseConfig + + +class CommonConstant: + """ + 常用常量 + + WWW: www主域 + HTTP: http请求 + HTTPS: https请求 + LOOKUP_RMI: RMI远程方法调用 + LOOKUP_LDAP: LDAP远程方法调用 + LOOKUP_LDAPS: LDAPS远程方法调用 + YES: 是否为系统默认（是） + NO: 是否为系统默认（否） + DEPT_NORMAL: 部门正常状态 + DEPT_DISABLE: 部门停用状态 + UNIQUE: 校验是否唯一的返回标识（是） + NOT_UNIQUE: 校验是否唯一的返回标识（否） + """ + + WWW = 'www.' + HTTP = 'http://' + HTTPS = 'https://' + LOOKUP_RMI = 'rmi:' + LOOKUP_LDAP = 'ldap:' + LOOKUP_LDAPS = 'ldaps:' + YES = 'Y' + NO = 'N' + DEPT_NORMAL = '0' + DEPT_DISABLE = '1' + UNIQUE = True + NOT_UNIQUE = False + + +class HttpStatusConstant: + """ + 返回状态码 + + SUCCESS: 操作成功 + CREATED: 对象创建成功 + ACCEPTED: 请求已经被接受 + NO_CONTENT: 操作已经执行成功，但是没有返回数据 + MOVED_PERM: 资源已被移除 + SEE_OTHER: 重定向 + NOT_MODIFIED: 资源没有被修改 + BAD_REQUEST: 参数列表错误（缺少，格式不匹配） + UNAUTHORIZED: 未授权 + FORBIDDEN: 访问受限，授权过期 + NOT_FOUND: 资源，服务未找到 + BAD_METHOD: 不允许的http方法 + CONFLICT: 资源冲突，或者资源被锁 + UNSUPPORTED_TYPE: 不支持的数据，媒体类型 + ERROR: 系统内部错误 + NOT_IMPLEMENTED: 接口未实现 + WARN: 系统警告消息 + """ + + SUCCESS = 200 + CREATED = 201 + ACCEPTED = 202 + NO_CONTENT = 204 + MOVED_PERM = 301 + SEE_OTHER = 303 + NOT_MODIFIED = 304 + BAD_REQUEST = 400 + UNAUTHORIZED = 401 + FORBIDDEN = 403 + NOT_FOUND = 404 + BAD_METHOD = 405 + CONFLICT = 409 + UNSUPPORTED_TYPE = 415 + ERROR = 500 + NOT_IMPLEMENTED = 501 + WARN = 601 + + diff --git a/app/core/database.py b/app/core/database.py new file mode 100644 index 0000000..a4708c9 --- /dev/null +++ b/app/core/database.py @@ -0,0 +1,32 @@ +from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession + +from sqlalchemy.orm import sessionmaker, declarative_base +from app.config.config import database_settings + +engine = create_async_engine( + f"mysql+aiomysql://{database_settings.DB_USER}:{database_settings.DB_PASSWORD}@{database_settings.DB_HOST}:{database_settings.DB_PORT}/{database_settings.DB_NAME}", + pool_size=database_settings.DB_POOL_SIZE, # 连接池常驻连接数 + max_overflow=database_settings.DB_MAX_OVERFLOW, # 池最大溢出连接数 + pool_timeout=database_settings.DB_POOL_TIMEOUT, # 获取连接超时时间（秒） + pool_recycle=database_settings.DB_POOL_RECYCLE, # 连接回收间隔（秒） + echo=False # 关闭SQL日志输出 +) + +# expire_on_commit=False 禁用提交后过期对象 --> 提交后原对象仍然可以使用. +async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False) + +# ORM模型基类 +Base = declarative_base() + + +# 获取数据库会话 +async def get_db(): + async with async_session() as session: + try: + yield session + # await session.commit() + except Exception: + await session.rollback() + raise + finally: + await session.close() \ No newline at end of file diff --git a/app/crud/base.py b/app/crud/base.py new file mode 100644 index 0000000..22103a5 --- /dev/null +++ b/app/crud/base.py @@ -0,0 +1,88 @@ +from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union +from fastapi.encoders import jsonable_encoder +from pydantic import BaseModel +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select, update, delete +from app.core.database import Base + +ModelType = TypeVar("ModelType", bound=Base) +CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel) +UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel) + +''' + Generic[ModelType, CreateSchemaType, UpdateSchemaType] 是 Python 类型提示中泛型编程的关键语法，用于声明一个​​泛型类​​。 + 它的作用是让 CRUDBase 类具备类型参数化的能力，允许在继承或实例化时动态绑定具体类型，从而实现代码复用和类型安全 + 声明 CRUDBase 类需要三个类型参数：ModelType、CreateSchemaType、UpdateSchemaType。 + 这些类型参数会在类的内部方法中使用（如 get、create、update），确保类型一致性。 + +''' +class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): + def __init__(self, model: Type[ModelType]): + """ + CRUD对象与SQLAlchemy模型类一起使用 + :param model: SQLAlchemy模型类 + """ + self.model = model + + # 根据id获取对象 + async def get(self, db: AsyncSession, id: Any) -> Optional[ModelType]: + """ + 通过ID获取对象 + """ + query = select(self.model).where(self.model.id == id) + result = await db.execute(query) + return result.scalar_one_or_none() + + # 分页查询 + async def get_multi( + self, db: AsyncSession, *, skip: int = 0, limit: int = 100 + ) -> List[ModelType]: + """ + 获取多个对象 + """ + query = select(self.model).offset(skip).limit(limit) + result = await db.execute(query) + return result.scalars().all() + + async def create(self, db: AsyncSession, *, obj_in: CreateSchemaType) -> ModelType: + """ + 创建对象 + """ + obj_in_data = jsonable_encoder(obj_in) + db_obj = self.model(**obj_in_data) + db.add(db_obj) + await db.commit() + await db.refresh(db_obj) + return db_obj + + async def update( + self, + db: AsyncSession, + *, + db_obj: ModelType, + obj_in: Union[UpdateSchemaType, Dict[str, Any]] + ) -> ModelType: + """ + 更新对象 + """ + obj_data = jsonable_encoder(db_obj) + if isinstance(obj_in, dict): + update_data = obj_in + else: + update_data = obj_in.dict(exclude_unset=True) + for field in obj_data: + if field in update_data: + setattr(db_obj, field, update_data[field]) + db.add(db_obj) + await db.commit() + await db.refresh(db_obj) + return db_obj + + async def remove(self, db: AsyncSession, *, id: Any) -> ModelType: + """ + 删除对象 + """ + obj = await self.get(db=db, id=id) + await db.delete(obj) + await db.commit() + return obj \ No newline at end of file diff --git a/app/crud/event.py b/app/crud/event.py new file mode 100644 index 0000000..2e0634d --- /dev/null +++ b/app/crud/event.py @@ -0,0 +1,130 @@ +from typing import List, Optional, Dict, Any +from sqlalchemy import select, and_, or_, join +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.orm import selectinload +from app.crud.base import CRUDBase +from app.models.models import Event, Image, Temperature +from app.schemas.event import EventUpdate, EventQuery, TestEvent + +class CRUDEvent(CRUDBase[Event, EventUpdate, EventUpdate]): + async def get_by_id(self, db: AsyncSession, *, event_id: str) -> Optional[Event]: + """根据ID获取事件""" + query = ( + select(Event) + .options( + selectinload(Event.images), + selectinload(Event.temperatures) + ) + .where(Event.eventId == event_id) + ) + result = await db.execute(query) + return result.scalar_one_or_none() + + async def get_multi_with_query( + self, + db: AsyncSession, + *, + query: EventQuery + ) -> List[Event]: + """根据查询条件获取事件列表""" + conditions = [] + + if query.start_time: + conditions.append(Event.insDate >= query.start_time) + if query.end_time: + conditions.append(Event.insDate <= query.end_time) + if query.etypeName: + conditions.append(Event.etypeName == query.etypeName) + if query.area: + conditions.append(Event.area == query.area) + + query_stmt = ( + select(Event) + .options( + selectinload(Event.images), + selectinload(Event.temperatures) + ) + ) + + if conditions: + query_stmt = query_stmt.where(and_(*conditions)) + + query_stmt = query_stmt.offset(query.skip).limit(query.limit) + + result = await db.execute(query_stmt) + return result.scalars().all() + + async def update_event( + self, + db: AsyncSession, + *, + event_id: str, + obj_in: EventUpdate + ) -> Optional[Event]: + """更新事件信息""" + event = await self.get_by_id(db, event_id=event_id) + if not event: + return None + + update_data = obj_in.model_dump() + for field, value in update_data.items(): + setattr(event, field, value) + + # db.add(event) + await db.commit() + await db.refresh(event) + return event + + async def delete_event( + self, + db: AsyncSession, + *, + event_id: str + ) -> Optional[Event]: + """删除事件""" + event = await self.get_by_id(db, event_id=event_id) + if not event: + return None + + await db.delete(event) + await db.commit() + return event + + + async def get_test( + self, + db: AsyncSession, + + + ) -> List[TestEvent]: #响应类型要写对啊 + + ''' + eventId + number + name + imageUrl + localPath + temperature + confidence + createTime + ''' + + query_stmt = ( + select(Event.eventId, Event.number, Event.name, Image.imageUrl, Image.localPath, Temperature.temperature, Temperature.confidence, Temperature.createTime) + .select_from(Event) + .outerjoin(Image, Event.eventId == Image.eventId) + .outerjoin(Temperature, Image.imageId == Temperature.imageId) + # 多个查询条件 + .where(and_(Event.etypeName=="日常巡检", True)) + ) + + result = await db.execute(query_stmt) + + # 获取字典 + result = result.mappings().all() + + # print(result) + return [TestEvent(**row) for row in result] + + +event = CRUDEvent(Event) \ No newline at end of file diff --git a/app/dao/imageDao.py b/app/dao/imageDao.py new file mode 100644 index 0000000..b9cc15c --- /dev/null +++ b/app/dao/imageDao.py @@ -0,0 +1,18 @@ +from typing import List +# from app.models.models import image +from app.schemas.image import ImageBase +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select +from app.models.models import Image + +class ImageDao: + + @classmethod + async def get_image_list(cls, db: AsyncSession, query_model: ImageBase): + + stmt = ( + select(Image) + ) + + result = await db.execute(stmt) + return result.mappings().all() \ No newline at end of file diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..c393011 --- /dev/null +++ b/app/main.py @@ -0,0 +1,25 @@ +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware +from app.api.v1.api import router + + +app = FastAPI( + title="测试fastapi", + description="测试啊", + version="1.0.0" +) + +# 配置CORS +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +app.include_router(router, prefix="/api/v1") + +@app.get("/") +async def root(): + return {"message": "测试成功"} \ No newline at end of file diff --git a/app/models/models.py b/app/models/models.py new file mode 100644 index 0000000..c4ed830 --- /dev/null +++ b/app/models/models.py @@ -0,0 +1,134 @@ +from datetime import datetime +from sqlalchemy import Column, String, DateTime, Integer, Text, ForeignKey, Index, BigInteger +from sqlalchemy.orm import relationship +from app.core.database import Base + + + +class Image(Base): + __tablename__ = "image" + + imageId = Column(BigInteger, primary_key=True, autoincrement=True, comment='图片ID') + localPath = Column(String(500), comment='本地存储路径') + type = Column(String(2), comment='图片类型, 0 ocr 图片, 1 目标检测图片') + result = Column(String(500), comment='检测结果') + createTime = Column(DateTime, default=datetime.now, comment='创建时间') + updateTime = Column(DateTime, default=datetime.now, onupdate=datetime.now, comment='更新时间') + + +# class Event(Base): +# __tablename__ = "event" + +# eventId = Column(String(50), primary_key=True) +# tenantInfoId = Column(String(100)) +# reportEventId = Column(String(100)) +# number = Column(String(20)) +# name = Column(String(20)) +# eclassify = Column(String(5)) +# operationType = Column(String(5)) +# etype = Column(String(20)) +# etypeName = Column(String(20)) +# enTypeName = Column(String(30)) +# hkTypeName = Column(String(20)) +# reportStatus = Column(String(5)) +# results = Column(String(5)) +# insDate = Column(DateTime) +# insDateShow = Column(DateTime) +# updDate = Column(DateTime) +# updDateShow = Column(DateTime) +# fileType = Column(String(5)) +# area = Column(String(20)) +# floor = Column(String(10)) +# map = Column(String(20)) +# staffId = Column(String(40)) +# targetUserId = Column(String(40)) +# position = Column(String(100)) +# actualStaffName = Column(String(20)) +# targetStaffName = Column(String(20)) +# routeName = Column(String(20)) +# phoneAddress = Column(String(500)) +# width = Column(String(10)) +# height = Column(String(10)) +# resolution = Column(String(10)) +# originX = Column(String(20)) +# originY = Column(String(20)) +# imgList = Column(String(20)) +# robotType = Column(String(5)) +# eventFloor = Column(String(10)) +# floorName = Column(String(10)) +# coordId = Column(String(40)) +# coord = Column(String(40)) +# coordName = Column(String(30)) +# positonName = Column(String(20)) +# processingRemark = Column(String(300)) +# carId = Column(String(40)) +# parkingSpaceType = Column(String(10)) +# parkingSpaceNumber = Column(String(40)) +# carNumber = Column(String(40)) +# eno = Column(String(40)) +# instrument = Column(String(40)) +# evideo = Column(String(40)) +# createTime = Column(DateTime, default=datetime.now, comment='本地后台创建时间') +# updateTime = Column(DateTime, default=datetime.now, onupdate=datetime.now, comment='本地后台更新时间') + +# # 关系 +# images = relationship("Image", back_populates="event", cascade="all, delete-orphan") +# temperatures = relationship("Temperature", back_populates="event", cascade="all, delete-orphan") +# process_logs = relationship("ProcessLog", back_populates="event", cascade="all, delete-orphan") + + +# class Image(Base): +# __tablename__ = "image" + +# imageId = Column(BigInteger, primary_key=True, autoincrement=True, comment='图片ID') +# eventId = Column(String(50), ForeignKey('event.eventId'), nullable=False, comment='关联事件ID') +# imageUrl = Column(String(500), nullable=False, comment='图片URL') +# localPath = Column(String(500), comment='本地存储路径') +# createTime = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间') + +# # 关系 +# event = relationship("Event", back_populates="images" ) +# temperatures = relationship("Temperature", back_populates="image") + +# __table_args__ = ( +# Index('idx_image_event_id', 'eventId'), +# ) + + +# class Temperature(Base): +# __tablename__ = "temperature" + +# tempId = Column(BigInteger, primary_key=True, autoincrement=True, comment='温度记录ID') +# eventId = Column(String(50), ForeignKey('event.eventId'), nullable=False, comment='关联事件ID') +# imageId = Column(BigInteger, ForeignKey('image.imageId'), nullable=False, comment='关联图片ID') +# temperature = Column(String(20), nullable=False, comment='温度值') +# # status = Column(String(2), comment='温度是否正常') +# confidence = Column(String(40), nullable=False, comment='识别置信度') +# createTime = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间') + +# # 关系 +# event = relationship("Event", back_populates="temperatures") +# image = relationship("Image", back_populates="temperatures") + +# __table_args__ = ( +# Index('idx_temp_event_id', 'eventId'), +# Index('idx_temp_create_time', 'createTime'), +# ) + + +# class ProcessLog(Base): +# __tablename__ = "process_log" + +# logId = Column(BigInteger, primary_key=True, autoincrement=True, comment='日志ID') +# eventId = Column(String(50), ForeignKey('event.eventId'), nullable=False, comment='关联事件ID') +# processStatus = Column(Integer, nullable=False, comment='处理状态') +# errorMessage = Column(Text, comment='错误信息') +# createTime = Column(DateTime, default=datetime.now, nullable=False, comment='创建时间') + +# # 关系 +# event = relationship("Event", back_populates="process_logs") + +# __table_args__ = ( +# Index('idx_log_event_id', 'eventId'), +# Index('idx_log_create_time', 'createTime'), +# ) \ No newline at end of file diff --git a/app/schemas/__init__.py b/app/schemas/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/schemas/event.py b/app/schemas/event.py new file mode 100644 index 0000000..ae13b77 --- /dev/null +++ b/app/schemas/event.py @@ -0,0 +1,116 @@ +from datetime import datetime +from typing import List, Optional +from pydantic import BaseModel, ConfigDict + +class ImageBase(BaseModel): + imageUrl: str + localPath: Optional[str] = None + + model_config = ConfigDict(from_attributes=True) + +class TemperatureBase(BaseModel): + temperature: str + confidence: str + createTime: datetime + + model_config = ConfigDict(from_attributes=True) + +class EventBase(BaseModel): + eventId: str + tenantInfoId: Optional[str] = None + reportEventId: Optional[str] = None + number: Optional[str] = None + name: Optional[str] = None + etypeName: Optional[str] = None + insDate: Optional[datetime] = None + + model_config = ConfigDict(from_attributes=True) + +class EventList(EventBase): + images: List[ImageBase] = [] + temperatures: List[TemperatureBase] = [] + + model_config = ConfigDict(from_attributes=True) + +class EventDetail(EventBase): + eclassify: Optional[str] = None + operationType: Optional[str] = None + etype: Optional[str] = None + enTypeName: Optional[str] = None + hkTypeName: Optional[str] = None + reportStatus: Optional[str] = None + results: Optional[str] = None + insDateShow: Optional[datetime] = None + updDate: Optional[datetime] = None + updDateShow: Optional[datetime] = None + fileType: Optional[str] = None + area: Optional[str] = None + floor: Optional[str] = None + map: Optional[str] = None + staffId: Optional[str] = None + targetUserId: Optional[str] = None + position: Optional[str] = None + actualStaffName: Optional[str] = None + targetStaffName: Optional[str] = None + routeName: Optional[str] = None + phoneAddress: Optional[str] = None + width: Optional[str] = None + height: Optional[str] = None + resolution: Optional[str] = None + originX: Optional[str] = None + originY: Optional[str] = None + robotType: Optional[str] = None + eventFloor: Optional[str] = None + floorName: Optional[str] = None + coordId: Optional[str] = None + coord: Optional[str] = None + coordName: Optional[str] = None + positonName: Optional[str] = None + processingRemark: Optional[str] = None + carId: Optional[str] = None + parkingSpaceType: Optional[str] = None + parkingSpaceNumber: Optional[str] = None + carNumber: Optional[str] = None + eno: Optional[str] = None + instrument: Optional[str] = None + evideo: Optional[str] = None + createTime: Optional[datetime] = None + updateTime: Optional[datetime] = None + images: List[ImageBase] = [] + temperatures: List[TemperatureBase] = [] + + model_config = ConfigDict(from_attributes=True) + +class EventUpdate(BaseModel): + number: Optional[str] = None + name: Optional[str] = None + etypeName: Optional[str] = None + area: Optional[str] = None + position: Optional[str] = None + processingRemark: Optional[str] = None + + model_config = ConfigDict(from_attributes=True) + +class EventQuery(BaseModel): + start_time: Optional[datetime] = None + end_time: Optional[datetime] = None + etypeName: Optional[str] = None + area: Optional[str] = None + skip: int = 0 + limit: int = 100 + + model_config = ConfigDict(from_attributes=True) + + +class TestEvent(BaseModel): + eventId: str + number: Optional[str] = None + name : Optional[str] = None + imageUrl : Optional[str] = None + localPath: Optional[str] = None + temperature: Optional[str] = None + confidence : Optional[str] = None + createTime: Optional[datetime] = None + + model_config = ConfigDict(from_attributes=True) + \ No newline at end of file diff --git a/app/schemas/image.py b/app/schemas/image.py new file mode 100644 index 0000000..40900e0 --- /dev/null +++ b/app/schemas/image.py @@ -0,0 +1,15 @@ +from pydantic import BaseModel, ConfigDict +from typing import Optional +from datetime import datetime + +class ImageBase(BaseModel): + + imageId: Optional[int] = None + localPath: Optional[str] = None + type : Optional[str] = None + result : Optional[str] = None + createTime : Optional[datetime] = None + updateTime : Optional[datetime] = None + + + model_config = ConfigDict(from_attributes=True) \ No newline at end of file diff --git a/app/schemas/ocr.py b/app/schemas/ocr.py new file mode 100644 index 0000000..a234b1b --- /dev/null +++ b/app/schemas/ocr.py @@ -0,0 +1,11 @@ +from pydantic import BaseModel +from typing import Optional + +class ImageBase64Request(BaseModel): + image_base64: str + image_type: Optional[str] = "jpg" # 图片类型，如 jpg, png 等 + +# class OCRResponse(BaseModel): +# success: bool +# message: str +# data: Optional[list] = None \ No newline at end of file diff --git a/app/services/imageServices.py b/app/services/imageServices.py new file mode 100644 index 0000000..f423adb --- /dev/null +++ b/app/services/imageServices.py @@ -0,0 +1,15 @@ + +from sqlalchemy.ext.asyncio import AsyncSession +from typing import List, Optional +from app.schemas.image import ImageBase +from app.dao.imageDao import ImageDao + + +class ImageService: + + @classmethod + async def get_image_list(cls, db: AsyncSession, query_model: ImageBase): + + result = await ImageDao.get_image_list(db, query_model) + + return result \ No newline at end of file diff --git a/app/util/baiduOCR.py b/app/util/baiduOCR.py new file mode 100644 index 0000000..2c9d0f3 --- /dev/null +++ b/app/util/baiduOCR.py @@ -0,0 +1,535 @@ +from paddleocr import PaddleOCR +import os +import cv2 +import yaml +import numpy as np +import onnxruntime as ort +from PIL import Image, ImageDraw, ImageFont +# import math + + +from app.config.config import OCRSettings + + + + +class BaiduOCR: + + def __init__(self): + self.model = PaddleOCR( + # 文本检测模型地址 + # text_detection_model_dir = "/home/admin-root/haotian/康达瑞贝斯机器狗/ocr_model/PP-OCRv5_server_det", + text_detection_model_dir=OCRSettings.TEXT_DETECTION_MODEL_DIR, + # 文本识别模型地址 + # text_recognition_model_dir = "/home/admin-root/haotian/康达瑞贝斯机器狗/ocr_model/PP-OCRv5_server_rec", + text_recognition_model_dir=OCRSettings.TEXT_RECONGNITION_MODEL_DIR, + use_doc_orientation_classify=False, + use_doc_unwarping=False, + use_textline_orientation=False, + # 多gpu有问题 + device='gpu:2' + ) + def ocr(self, image_path:str): + try: + result = self.model.predict(image_path) + except IndexError: + return [] + except Exception: + raise + + if not result: + return [] + + self.draw_ocr_result(image_path, result) + + result = self.parse_result(result) + if not result: + return [] + + return result[0] + + def parse_result(self, result): + text_list = [] + for item in result: + rec_texts = item.get('rec_texts') + rec_scores = item.get('rec_scores') + + if rec_texts is None or rec_scores is None: + continue + + text_list.append([rec_texts, rec_scores]) + return text_list + + def draw_ocr_result(self, image_path: str, result): + """ + 在原图上绘制 OCR 识别结果 + """ + # 读取原图 + image = cv2.imread(image_path) + if image is None: + return + + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + + # 转换为 PIL Image 以支持中文显示 + pil_img = Image.fromarray(image) + draw = ImageDraw.Draw(pil_img) + + # 尝试加载中文字体（根据系统调整路径） + try: + # font = ImageFont.truetype("simhei.ttf", 20) # Windows + font = ImageFont.truetype("/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc", 20) # Linux + # font = ImageFont.truetype("/System/Library/Fonts/PingFang.ttc", 20) # macOS + except: + font = ImageFont.load_default() + + # 绘制每个检测框和文本 + for idx, item in enumerate(result): + box = item['rec_boxes'] # shape=(1, 4) + text = item['rec_texts'] + score = item['rec_scores'] + + # 处理可能的列表类型 + if isinstance(text, list): + text = text[0] if len(text) > 0 else "" + if isinstance(score, list): + score = score[0] if len(score) > 0 else 0.0 + + # 提取坐标 + if box is None: + continue + + box = box.flatten() + if len(box) < 4: + continue + + x1, y1, x2, y2 = int(box[0]), int(box[1]), int(box[2]), int(box[3]) + + # 绘制矩形框 + draw.rectangle([(x1, y1), (x2, y2)], outline=(255, 0, 0), width=2) + + # 绘制文本和置信度 + text_position = (x1, max(0, y1 - 25)) + text_with_score = f"{text} ({float(score):.2f})" + draw.text(text_position, text_with_score, fill=(0, 255, 0), font=font) + + # 转换回 OpenCV 格式 + result_img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR) + + # 获取文件夹路径并创建 + os.makedirs(os.path.dirname(image_path), exist_ok=True) + + cv2.imwrite(image_path, result_img) + + # return result_img + + + + +class BaiduOCRONNX: + def __init__(self, det_model_path=OCRSettings.TEXT_DETECTION_MODEL_ONNX_DIR, rec_model_path=OCRSettings.TEXT_RECONGNITION_MODEL_ONNX_DIR): + """ + 初始化ONNX推理器 + + Args: + det_model_path: 检测模型路径 (det.onnx) + rec_model_path: 识别模型路径 (rec.onnx) + """ + # 初始化检测模型 + self.det_session = ort.InferenceSession(det_model_path) + self.det_input_name = self.det_session.get_inputs()[0].name + + # 初始化识别模型 + self.rec_session = ort.InferenceSession(rec_model_path) + self.rec_input_name = self.rec_session.get_inputs()[0].name + + # 字符集（根据您的模型调整） + # self.character = ['blank', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', + # ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', + # '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', + # 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', + # 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', + # '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', + # 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', + # 'z', '{', '|', '}', '~'] + [chr(i) for i in range(19968, 40870)] # 中文字符 + self.character = self.get_dict() + + if self.character is None: + raise ValueError('请检查字典文件是否存在！') + + def get_dict(self, dict_path='./dict.yaml'): + """ + 加载字典 + """ + with open(dict_path, 'r', encoding='utf-8') as f: + dict_rec = yaml.safe_load(f) + return dict_rec.get('character_dict', []) + + def resize_norm_img_det(self, img, input_shape=(640, 640)): + """ + 检测模型的图像预处理 - 固定输入形状 [1, 3, 640, 640] + """ + h, w, _ = img.shape + target_h, target_w = input_shape + + # 计算缩放比例 - 保持宽高比 + ratio_h = target_h / h + ratio_w = target_w / w + ratio = min(ratio_h, ratio_w) + + # 计算缩放后的尺寸 + new_h = int(h * ratio) + new_w = int(w * ratio) + + # 调整图像大小 + resized_img = cv2.resize(img, (new_w, new_h)) + + # 创建目标尺寸的图像，用灰色填充 + padded_img = np.ones((target_h, target_w, 3), dtype=np.float32) * 114.0 # 直接用float32 + + # 计算居中位置 + top = (target_h - new_h) // 2 + left = (target_w - new_w) // 2 + + # 将缩放后的图像放到居中位置 + padded_img[top:top+new_h, left:left+new_w] = resized_img.astype(np.float32) + + # 归一化 + img = (padded_img / 255.0 - np.array([0.485, 0.456, 0.406], dtype=np.float32)) / np.array([0.229, 0.224, 0.225], dtype=np.float32) + img = img.transpose(2, 0, 1).astype(np.float32) + img = np.expand_dims(img, axis=0).astype(np.float32) + + return img, ratio, (top, left) + + def post_process_det(self, dt_boxes, ratio, padding_info, ori_shape): + """ + 检测结果后处理 - 适配固定输入形状 + """ + if dt_boxes is None: + return None + + ori_h, ori_w = ori_shape + top, left = padding_info + + # 将坐标从模型输出空间转换回原图空间 + dt_boxes[:, :, 0] = (dt_boxes[:, :, 0] - left) / ratio + dt_boxes[:, :, 1] = (dt_boxes[:, :, 1] - top) / ratio + + # 裁剪到原图范围内 + dt_boxes[:, :, 0] = np.clip(dt_boxes[:, :, 0], 0, ori_w) + dt_boxes[:, :, 1] = np.clip(dt_boxes[:, :, 1], 0, ori_h) + + return dt_boxes + + def boxes_from_bitmap(self, pred, bitmap, dest_width, dest_height, max_candidates=1000, box_thresh=0.6): + """ + 从位图中提取文本框 + """ + bitmap = bitmap.astype(np.uint8) + height, width = bitmap.shape + + # 查找轮廓 + contours, _ = cv2.findContours(bitmap, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) + + num_contours = min(len(contours), max_candidates) + boxes = [] + scores = [] + + for i in range(num_contours): + contour = contours[i] + points, sside = self.get_mini_boxes(contour) + if sside < 5: + continue + + points = np.array(points) + score = self.box_score_fast(pred, points.reshape(-1, 2)) + if box_thresh > score: + continue + + # 扩展box + box = self.unclip(points, 1.5).reshape(-1, 1, 2) + box, sside = self.get_mini_boxes(box) + if sside < 5 + 2: + continue + + box = np.array(box) + box[:, 0] = np.clip(box[:, 0] / width * dest_width, 0, dest_width) + box[:, 1] = np.clip(box[:, 1] / height * dest_height, 0, dest_height) + + boxes.append(box.astype(np.int16)) + scores.append(score) + + return np.array(boxes), scores + + def get_mini_boxes(self, contour): + """获取最小外接矩形""" + bounding_box = cv2.minAreaRect(contour) + points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0]) + + index_1, index_2, index_3, index_4 = 0, 1, 2, 3 + if points[1][1] > points[0][1]: + index_1 = 0 + index_4 = 1 + else: + index_1 = 1 + index_4 = 0 + + if points[3][1] > points[2][1]: + index_2 = 2 + index_3 = 3 + else: + index_2 = 3 + index_3 = 2 + + box = [points[index_1], points[index_2], points[index_3], points[index_4]] + return box, min(bounding_box[1]) + + def box_score_fast(self, bitmap, _box): + """快速计算box得分""" + h, w = bitmap.shape[:2] + box = _box.copy() + xmin = np.clip(np.floor(box[:, 0].min()).astype(int), 0, w - 1) + xmax = np.clip(np.ceil(box[:, 0].max()).astype(int), 0, w - 1) + ymin = np.clip(np.floor(box[:, 1].min()).astype(int), 0, h - 1) + ymax = np.clip(np.ceil(box[:, 1].max()).astype(int), 0, h - 1) + + mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8) + box[:, 0] = box[:, 0] - xmin + box[:, 1] = box[:, 1] - ymin + cv2.fillPoly(mask, box.reshape(1, -1, 2).astype(np.int32), 1) + + return cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0] + + def unclip(self, box, unclip_ratio): + """扩展文本框""" + from shapely.geometry import Polygon + import pyclipper + + poly = Polygon(box) + distance = poly.area * unclip_ratio / poly.length + + offset = pyclipper.PyclipperOffset() + offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON) + expanded = offset.Execute(distance) + + if len(expanded) == 0: + return box + else: + return np.array(expanded[0]) + + def resize_norm_img_rec(self, img, input_shape=(320, 48)): + """ + 识别模型的图像预处理 - 固定输入形状 [1, 3, 48, 320] + """ + target_w, target_h = input_shape # 注意：宽度在前 + + h, w = img.shape[:2] + + # 计算缩放比例，保持宽高比 + ratio_h = target_h / h + ratio_w = target_w / w + ratio = min(ratio_h, ratio_w) + + # 计算缩放后的尺寸 + new_h = int(h * ratio) + new_w = int(w * ratio) + + # 调整图像大小 + resized_image = cv2.resize(img, (new_w, new_h)) + + # 创建目标尺寸的图像，用黑色填充 + padded_image = np.zeros((target_h, target_w, 3), dtype=np.float32) # 直接用float32 + + # 将缩放后的图像放到左上角（识别模型通常左对齐） + padded_image[:new_h, :new_w] = resized_image.astype(np.float32) + + # 归一化 + # padded_image = (padded_image / 255.0 - np.array([0.485, 0.456, 0.406], dtype=np.float32)) / np.array([0.229, 0.224, 0.225], dtype=np.float32) + + # 不缩放反而会将识别结果再移后一个?? + padded_image = (padded_image / 255.0).astype(np.float32) + padded_image = padded_image.transpose((2, 0, 1)).astype(np.float32) + + return np.expand_dims(padded_image, axis=0).astype(np.float32) + + def decode_rec_result(self, preds_prob): + """ + 解码识别结果 + """ + preds_idx = np.argmax(preds_prob, axis=1) + preds_prob = np.max(preds_prob, axis=1) + + # CTC解码 + last_idx = 0 + preds_text = [] + preds_conf = [] + + for i, idx in enumerate(preds_idx): + if idx != last_idx and idx != 0: # 0是blank + if idx < len(self.character): + preds_text.append(self.character[idx]) + preds_conf.append(preds_prob[i]) + last_idx = idx + + text = ''.join(preds_text) + conf = np.mean(preds_conf) if preds_conf else 0.0 + + return text, conf + + def detect_text(self, image): + """ + 文本检测 - 适配固定输入形状 [1, 3, 640, 640] + """ + ori_h, ori_w = image.shape[:2] + + # 预处理 + det_img, ratio, padding_info = self.resize_norm_img_det(image) + + # 推理 + det_output = self.det_session.run(None, {self.det_input_name: det_img})[0] + + # 后处理 + mask = det_output[0, 0, :, :] + threshold = 0.3 + bitmap = (mask > threshold).astype(np.uint8) * 255 + + # 从位图中提取文本框（坐标是在640x640空间中的） + boxes, scores = self.boxes_from_bitmap(mask, bitmap, 640, 640) + + # 将坐标转换回原图空间 + if len(boxes) > 0: + boxes = self.post_process_det(boxes, ratio, padding_info, (ori_h, ori_w)) + + return boxes, scores + + def recognize_text(self, image): + """ + 文本识别 + """ + # 预处理 + rec_img = self.resize_norm_img_rec(image) + + # 推理 + rec_output = self.rec_session.run(None, {self.rec_input_name: rec_img})[0] + + # 解码 + text, conf = self.decode_rec_result(rec_output[0]) + + return text, conf + + def get_rotate_crop_image(self, img, points): + """ + 根据四个点坐标裁剪并矫正图像 + """ + img_crop_width = int( + max( + np.linalg.norm(points[0] - points[1]), + np.linalg.norm(points[2] - points[3]))) + img_crop_height = int( + max( + np.linalg.norm(points[0] - points[3]), + np.linalg.norm(points[1] - points[2]))) + pts_std = np.float32([[0, 0], [img_crop_width, 0], + [img_crop_width, img_crop_height], + [0, img_crop_height]]) + M = cv2.getPerspectiveTransform(points, pts_std) + dst_img = cv2.warpPerspective( + img, + M, (img_crop_width, img_crop_height), + borderMode=cv2.BORDER_REPLICATE, + flags=cv2.INTER_CUBIC) + dst_img_height, dst_img_width = dst_img.shape[0:2] + if dst_img_height * 1.0 / dst_img_width >= 1.5: + dst_img = np.rot90(dst_img) + return dst_img + + def ocr(self, image_path): + """ + 完整的OCR流程 + """ + # 读取图像 + image = cv2.imread(image_path) + if image is None: + return [] + + # 1. 文本检测 + dt_boxes, scores = self.detect_text(image) + + if dt_boxes is None or len(dt_boxes) == 0: + return [] + + # 2. 文本识别 + ocr_results = [] + + text_list = [] + confidence_list = [] + for i, box in enumerate(dt_boxes): + # 裁剪文本区域 + box_points = box.astype(np.float32) + crop_img = self.get_rotate_crop_image(image, box_points) + if crop_img.size == 0: + continue + + # 识别文本 + text, conf = self.recognize_text(crop_img) + + if conf > 0.5: # 置信度过滤 + ocr_results.append({ + 'text': text, + 'confidence': conf, + 'box': box.tolist(), + 'score': scores[i] if i < len(scores) else 0.0 + }) + + text_list.append(text) + confidence_list.append(round(conf.item(), 2)) + + # return ocr_results + return [text_list, confidence_list] + + +# 使用示例 +def main(): + # 初始化OCR + # ocr = PaddleOCRONNX('/home/admin-root/haotian/康达瑞贝斯机器狗/det_shape.onnx', '/home/admin-root/haotian/康达瑞贝斯机器狗/rec_shape.onnx') + + ocr = BaiduOCRONNX('/home/admin-root/haotian/康达瑞贝斯机器狗/det_shape_20250814.onnx', '/home/admin-root/haotian/康达瑞贝斯机器狗/rec_shape_20250815.onnx') + + # 执行OCR + image_path = '/home/admin-root/haotian/康达瑞贝斯机器狗/data_image/001读表图片/3aee64cc1f90d93a5a45979f7b17cb4b_frame_001460.jpg' + results = ocr.ocr(image_path) + + # 打印结果 + for result in results: + print(f"文本: {result['text']}") + print(f"置信度: {result['confidence']:.3f}") + print(f"检测得分: {result['score']:.3f}") + print(f"坐标: {result['box']}") + print("-" * 50) + + # 可视化结果 + visualize_results(image_path, results) + +def visualize_results(image_path, results): + """ + 可视化OCR结果 + """ + image = cv2.imread(image_path) + + for result in results: + box = np.array(result['box'], dtype=np.int32) + cv2.polylines(image, [box], True, (0, 255, 0), 2) + + # 在框上方显示文本 + cv2.putText(image, result['text'], + (box[0][0], box[0][1] - 10), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2) + + cv2.imwrite('result_shape_20250815.jpg', image) + + + + +if __name__ == '__main__': + ocr = BaiduOCR() + print(ocr.ocr("")) diff --git a/app/util/responseHttp.py b/app/util/responseHttp.py new file mode 100644 index 0000000..c34d1b2 --- /dev/null +++ b/app/util/responseHttp.py @@ -0,0 +1,266 @@ +from datetime import datetime +from fastapi import status +from fastapi.encoders import jsonable_encoder +from fastapi.responses import JSONResponse, Response, StreamingResponse +from pydantic import BaseModel +from starlette.background import BackgroundTask +from typing import Any, Dict, Mapping, Optional +from app.config.constant import HttpStatusConstant + + +class ResponseUtil: + """ + 响应工具类 + """ + + @classmethod + def success( + cls, + msg: str = '操作成功', + data: Optional[Any] = None, + rows: Optional[Any] = None, + dict_content: Optional[Dict] = None, + model_content: Optional[BaseModel] = None, + headers: Optional[Mapping[str, str]] = None, + media_type: Optional[str] = None, + background: Optional[BackgroundTask] = None, + ) -> Response: + """ + 成功响应方法 + + :param msg: 可选，自定义成功响应信息 + :param data: 可选，成功响应结果中属性为data的值 + :param rows: 可选，成功响应结果中属性为rows的值 + :param dict_content: 可选，dict类型，成功响应结果中自定义属性的值 + :param model_content: 可选，BaseModel类型，成功响应结果中自定义属性的值 + :param headers: 可选，响应头信息 + :param media_type: 可选，响应结果媒体类型 + :param background: 可选，响应返回后执行的后台任务 + :return: 成功响应结果 + """ + result = {'code': HttpStatusConstant.SUCCESS, 'msg': msg} + + if data is not None: + result['data'] = data + if rows is not None: + result['rows'] = rows + if dict_content is not None: + result.update(dict_content) + if model_content is not None: + result.update(model_content.model_dump(by_alias=True)) + + result.update({'success': True, 'time': datetime.now()}) + + return JSONResponse( + status_code=status.HTTP_200_OK, + content=jsonable_encoder(result), + headers=headers, + media_type=media_type, + background=background, + ) + + @classmethod + def failure( + cls, + msg: str = '操作失败', + data: Optional[Any] = None, + rows: Optional[Any] = None, + dict_content: Optional[Dict] = None, + model_content: Optional[BaseModel] = None, + headers: Optional[Mapping[str, str]] = None, + media_type: Optional[str] = None, + background: Optional[BackgroundTask] = None, + ) -> Response: + """ + 失败响应方法 + + :param msg: 可选，自定义失败响应信息 + :param data: 可选，失败响应结果中属性为data的值 + :param rows: 可选，失败响应结果中属性为rows的值 + :param dict_content: 可选，dict类型，失败响应结果中自定义属性的值 + :param model_content: 可选，BaseModel类型，失败响应结果中自定义属性的值 + :param headers: 可选，响应头信息 + :param media_type: 可选，响应结果媒体类型 + :param background: 可选，响应返回后执行的后台任务 + :return: 失败响应结果 + """ + result = {'code': HttpStatusConstant.WARN, 'msg': msg} + + if data is not None: + result['data'] = data + if rows is not None: + result['rows'] = rows + if dict_content is not None: + result.update(dict_content) + if model_content is not None: + result.update(model_content.model_dump(by_alias=True)) + + result.update({'success': False, 'time': datetime.now()}) + + return JSONResponse( + status_code=status.HTTP_200_OK, + content=jsonable_encoder(result), + headers=headers, + media_type=media_type, + background=background, + ) + + @classmethod + def unauthorized( + cls, + msg: str = '登录信息已过期，访问系统资源失败', + data: Optional[Any] = None, + rows: Optional[Any] = None, + dict_content: Optional[Dict] = None, + model_content: Optional[BaseModel] = None, + headers: Optional[Mapping[str, str]] = None, + media_type: Optional[str] = None, + background: Optional[BackgroundTask] = None, + ) -> Response: + """ + 未认证响应方法 + + :param msg: 可选，自定义未认证响应信息 + :param data: 可选，未认证响应结果中属性为data的值 + :param rows: 可选，未认证响应结果中属性为rows的值 + :param dict_content: 可选，dict类型，未认证响应结果中自定义属性的值 + :param model_content: 可选，BaseModel类型，未认证响应结果中自定义属性的值 + :param headers: 可选，响应头信息 + :param media_type: 可选，响应结果媒体类型 + :param background: 可选，响应返回后执行的后台任务 + :return: 未认证响应结果 + """ + result = {'code': HttpStatusConstant.UNAUTHORIZED, 'msg': msg} + + if data is not None: + result['data'] = data + if rows is not None: + result['rows'] = rows + if dict_content is not None: + result.update(dict_content) + if model_content is not None: + result.update(model_content.model_dump(by_alias=True)) + + result.update({'success': False, 'time': datetime.now()}) + + return JSONResponse( + status_code=status.HTTP_200_OK, + content=jsonable_encoder(result), + headers=headers, + media_type=media_type, + background=background, + ) + + @classmethod + def forbidden( + cls, + msg: str = '该用户无此接口权限', + data: Optional[Any] = None, + rows: Optional[Any] = None, + dict_content: Optional[Dict] = None, + model_content: Optional[BaseModel] = None, + headers: Optional[Mapping[str, str]] = None, + media_type: Optional[str] = None, + background: Optional[BackgroundTask] = None, + ) -> Response: + """ + 未授权响应方法 + + :param msg: 可选，自定义未授权响应信息 + :param data: 可选，未授权响应结果中属性为data的值 + :param rows: 可选，未授权响应结果中属性为rows的值 + :param dict_content: 可选，dict类型，未授权响应结果中自定义属性的值 + :param model_content: 可选，BaseModel类型，未授权响应结果中自定义属性的值 + :param headers: 可选，响应头信息 + :param media_type: 可选，响应结果媒体类型 + :param background: 可选，响应返回后执行的后台任务 + :return: 未授权响应结果 + """ + result = {'code': HttpStatusConstant.FORBIDDEN, 'msg': msg} + + if data is not None: + result['data'] = data + if rows is not None: + result['rows'] = rows + if dict_content is not None: + result.update(dict_content) + if model_content is not None: + result.update(model_content.model_dump(by_alias=True)) + + result.update({'success': False, 'time': datetime.now()}) + + return JSONResponse( + status_code=status.HTTP_200_OK, + content=jsonable_encoder(result), + headers=headers, + media_type=media_type, + background=background, + ) + + @classmethod + def error( + cls, + msg: str = '接口异常', + data: Optional[Any] = None, + rows: Optional[Any] = None, + dict_content: Optional[Dict] = None, + model_content: Optional[BaseModel] = None, + headers: Optional[Mapping[str, str]] = None, + media_type: Optional[str] = None, + background: Optional[BackgroundTask] = None, + ) -> Response: + """ + 错误响应方法 + + :param msg: 可选，自定义错误响应信息 + :param data: 可选，错误响应结果中属性为data的值 + :param rows: 可选，错误响应结果中属性为rows的值 + :param dict_content: 可选，dict类型，错误响应结果中自定义属性的值 + :param model_content: 可选，BaseModel类型，错误响应结果中自定义属性的值 + :param headers: 可选，响应头信息 + :param media_type: 可选，响应结果媒体类型 + :param background: 可选，响应返回后执行的后台任务 + :return: 错误响应结果 + """ + result = {'code': HttpStatusConstant.ERROR, 'msg': msg} + + if data is not None: + result['data'] = data + if rows is not None: + result['rows'] = rows + if dict_content is not None: + result.update(dict_content) + if model_content is not None: + result.update(model_content.model_dump(by_alias=True)) + + result.update({'success': False, 'time': datetime.now()}) + + return JSONResponse( + status_code=status.HTTP_200_OK, + content=jsonable_encoder(result), + headers=headers, + media_type=media_type, + background=background, + ) + + @classmethod + def streaming( + cls, + *, + data: Any = None, + headers: Optional[Mapping[str, str]] = None, + media_type: Optional[str] = None, + background: Optional[BackgroundTask] = None, + ) -> Response: + """ + 流式响应方法 + + :param data: 流式传输的内容 + :param headers: 可选，响应头信息 + :param media_type: 可选，响应结果媒体类型 + :param background: 可选，响应返回后执行的后台任务 + :return: 流式响应结果 + """ + return StreamingResponse( + status_code=status.HTTP_200_OK, content=data, headers=headers, media_type=media_type, background=background + ) diff --git a/app/util/yolov8Obj.py b/app/util/yolov8Obj.py new file mode 100644 index 0000000..032945e --- /dev/null +++ b/app/util/yolov8Obj.py @@ -0,0 +1,470 @@ +from ultralytics import YOLO +# from rknn.api import RKNN +import cv2 +import numpy as np +import onnxruntime as ort +import time + +from app.config.config import yolov8_settings + + + + +class Yolov8Obj: + + def __init__(self): + self.model = YOLO(yolov8_settings.YOLOV8_MODEL_DIR) + + def detect(self, image_path): + result = self.model.predict(image_path) + boxes = result[0].boxes + + cls = boxes.cls.tolist() + conf = boxes.conf.tolist() + coords = boxes.xyxy.tolist() + + return cls, conf, coords + + +class YOLOv8ONNX: + def __init__(self, model_path=yolov8_settings.YOLOV8_MODEL_ONNX_DIRS, conf_threshold=0.5, iou_threshold=0.4): + """ + 初始化YOLOv8 ONNX模型 + + Args: + model_path: ONNX模型文件路径 + conf_threshold: 置信度阈值 + iou_threshold: NMS IoU阈值 + """ + self.conf_threshold = conf_threshold + self.iou_threshold = iou_threshold + + # 创建ONNX Runtime会话 + self.session = ort.InferenceSession(model_path) + + # 获取模型输入输出信息 + self.input_name = self.session.get_inputs()[0].name + self.output_name = self.session.get_outputs()[0].name + + # 获取输入尺寸 + input_shape = self.session.get_inputs()[0].shape + self.input_height = input_shape[2] + self.input_width = input_shape[3] + + def preprocess(self, image): + """ + 预处理图像 + + Args: + image: 输入图像 (BGR格式) + + Returns: + preprocessed_image: 预处理后的图像 + scale_ratio: 缩放比例 + pad_info: 填充信息 (pad_x, pad_y) + """ + # 获取原图尺寸 + h, w = image.shape[:2] + + # 计算缩放比例 + scale = min(self.input_height / h, self.input_width / w) + new_h, new_w = int(h * scale), int(w * scale) + + # 等比例缩放 + resized_image = cv2.resize(image, (new_w, new_h)) + + # 计算填充 + pad_x = (self.input_width - new_w) // 2 + pad_y = (self.input_height - new_h) // 2 + + # 创建填充后的图像 + padded_image = np.full((self.input_height, self.input_width, 3), 114, dtype=np.uint8) + padded_image[pad_y:pad_y + new_h, pad_x:pad_x + new_w] = resized_image + + # 转换为模型输入格式: BGR -> RGB, HWC -> CHW, 归一化 + input_image = padded_image[:, :, ::-1].transpose(2, 0, 1).astype(np.float32) / 255.0 + input_image = np.expand_dims(input_image, axis=0) # 添加batch维度 + + return input_image, scale, (pad_x, pad_y) + + def postprocess(self, outputs, scale, pad_info, original_shape): + """ + 后处理模型输出 - 针对YOLOv8格式优化 + + Args: + outputs: 模型原始输出 + scale: 图像缩放比例 + pad_info: 填充信息 + original_shape: 原图尺寸 + + Returns: + boxes: 检测框 [[x1, y1, x2, y2], ...] + scores: 置信度分数 + class_ids: 类别ID + """ + predictions = outputs[0] # 形状通常是: [1, 6, 8400] 或 [1, num_classes+4, num_boxes] + + # YOLOv8输出格式: [batch, 4+num_classes, num_boxes] + # 需要转置为 [batch, num_boxes, 4+num_classes] + if len(predictions.shape) == 3: + predictions = predictions.transpose(0, 2, 1) # [1, num_boxes, 4+num_classes] + + predictions = predictions[0] # 移除batch维度: [num_boxes, 4+num_classes] + + # 打印调试信息 + # print(f"预测输出形状: {predictions.shape}") + # print(f"前几个预测值: {predictions[:5]}") + + # 分离坐标和分类信息 + boxes = predictions[:, :4] # [x_center, y_center, width, height] + scores = predictions[:, 4:] # 类别置信度 [num_boxes, num_classes] + + # print(f"检测框形状: {boxes.shape}") + # print(f"分数形状: {scores.shape}") + + # 获取最高置信度和对应类别 + class_ids = np.argmax(scores, axis=1) + confidences = np.max(scores, axis=1) + + # print(f"置信度范围: {confidences.min():.4f} - {confidences.max():.4f}") + # print(f"检测到的类别: {np.unique(class_ids)}") + + # 过滤低置信度检测 + valid_indices = confidences > self.conf_threshold + valid_boxes = boxes[valid_indices] + valid_confidences = confidences[valid_indices] + valid_class_ids = class_ids[valid_indices] + + # print(f"过滤后检测数量: {len(valid_boxes)}") + + if len(valid_boxes) == 0: + return [], [], [] + + # 转换为 [x1, y1, x2, y2] 格式 + x_center, y_center, width, height = valid_boxes[:, 0], valid_boxes[:, 1], valid_boxes[:, 2], valid_boxes[:, 3] + x1 = x_center - width / 2 + y1 = y_center - height / 2 + x2 = x_center + width / 2 + y2 = y_center + height / 2 + + converted_boxes = np.stack([x1, y1, x2, y2], axis=1) + + # 坐标反变换到原图 + pad_x, pad_y = pad_info + converted_boxes[:, [0, 2]] = (converted_boxes[:, [0, 2]] - pad_x) / scale + converted_boxes[:, [1, 3]] = (converted_boxes[:, [1, 3]] - pad_y) / scale + + # 限制坐标范围 + h, w = original_shape[:2] + converted_boxes[:, [0, 2]] = np.clip(converted_boxes[:, [0, 2]], 0, w) + converted_boxes[:, [1, 3]] = np.clip(converted_boxes[:, [1, 3]], 0, h) + + # 非极大值抑制 (NMS) + indices = cv2.dnn.NMSBoxes( + converted_boxes.tolist(), + valid_confidences.tolist(), + self.conf_threshold, + self.iou_threshold + ) + + if len(indices) > 0: + indices = indices.flatten() + return converted_boxes[indices], valid_confidences[indices], valid_class_ids[indices] + + return [], [], [] + + def detect(self, image): + """ + 对图像进行目标检测 + + Args: + image: 输入图像 (BGR格式) + + Returns: + boxes: 检测框列表 + scores: 置信度分数列表 + class_ids: 类别ID列表 + """ + # 预处理 + input_image, scale, pad_info = self.preprocess(image) + + # 推理 + outputs = self.session.run([self.output_name], {self.input_name: input_image}) + + # 后处理 + boxes, scores, class_ids = self.postprocess(outputs, scale, pad_info, image.shape) + + return boxes, scores, class_ids + + +class YOLOv8RKNN: + def __init__(self, model_path, input_size=(640, 640)): + self.model_path = model_path + self.input_size = input_size + self.rknn = RKNN() + + # 类别名称，根据你的2个类别修改 + self.class_names = ['class1', 'class2'] # 请替换为你实际的类别名称 + + # 初始化模型 + self.load_model() + + def load_model(self): + """加载RKNN模型""" + print("Loading RKNN model...") + ret = self.rknn.load_rknn(self.model_path) + if ret != 0: + print("Load RKNN model failed!") + return False + + # 初始化运行时环境（在RK3588设备上运行） + print("Init RKNN runtime...") + ret = self.rknn.init_runtime(target='rk3588', device_id=None, perf_debug=False, eval_mem=False) + if ret != 0: + print("Init RKNN runtime failed!") + return False + + print("RKNN model loaded successfully!") + return True + + def preprocess(self, image): + """图像预处理""" + # 获取原始图像尺寸 + self.orig_height, self.orig_width = image.shape[:2] + + # Resize到模型输入尺寸，保持宽高比 + scale = min(self.input_size[0]/self.orig_width, self.input_size[1]/self.orig_height) + new_width = int(self.orig_width * scale) + new_height = int(self.orig_height * scale) + + # 缩放图像 + resized = cv2.resize(image, (new_width, new_height)) + + # 创建输入图像（填充到目标尺寸） + input_image = np.full((self.input_size[1], self.input_size[0], 3), 114, dtype=np.uint8) + + # 计算填充位置（居中） + y_offset = (self.input_size[1] - new_height) // 2 + x_offset = (self.input_size[0] - new_width) // 2 + + # 将缩放后的图像放到中心位置 + input_image[y_offset:y_offset+new_height, x_offset:x_offset+new_width] = resized + + # 保存缩放参数用于后处理 + self.scale = scale + self.x_offset = x_offset + self.y_offset = y_offset + + return input_image + + def postprocess(self, outputs, conf_threshold=0.5, nms_threshold=0.4): + """后处理：解析YOLO输出并进行NMS""" + # YOLOv8输出格式: [batch, 84, 8400] (2个类别: 4+2+80=84，但实际只有6维) + # 对于2类别: [x, y, w, h, conf_class1, conf_class2] + predictions = outputs[0][0] # 移除batch维度 + + # 转置为 [8400, 6] 格式 + predictions = predictions.transpose() + + boxes = [] + scores = [] + class_ids = [] + + for detection in predictions: + # 提取坐标和类别置信度 + x, y, w, h = detection[:4] + class_confs = detection[4:6] # 2个类别的置信度 + + # 找到最大置信度的类别 + class_id = np.argmax(class_confs) + max_conf = class_confs[class_id] + + if max_conf >= conf_threshold: + # 转换坐标格式 (中心点 -> 左上角) + x1 = x - w/2 + y1 = y - h/2 + x2 = x + w/2 + y2 = y + h/2 + + # 将坐标映射回原图尺寸 + x1 = (x1 - self.x_offset) / self.scale + y1 = (y1 - self.y_offset) / self.scale + x2 = (x2 - self.x_offset) / self.scale + y2 = (y2 - self.y_offset) / self.scale + + # 限制在图像边界内 + x1 = max(0, min(x1, self.orig_width)) + y1 = max(0, min(y1, self.orig_height)) + x2 = max(0, min(x2, self.orig_width)) + y2 = max(0, min(y2, self.orig_height)) + + boxes.append([x1, y1, x2, y2]) + scores.append(max_conf) + class_ids.append(class_id) + + # 执行NMS + if len(boxes) > 0: + boxes = np.array(boxes) + scores = np.array(scores) + class_ids = np.array(class_ids) + + # OpenCV NMS + indices = cv2.dnn.NMSBoxes(boxes, scores, conf_threshold, nms_threshold) + + if len(indices) > 0: + indices = indices.flatten() + return boxes[indices], scores[indices], class_ids[indices] + + return np.array([]), np.array([]), np.array([]) + + def detect(self, image, conf_threshold=0.5, nms_threshold=0.4): + """执行检测""" + # 预处理 + input_image = self.preprocess(image) + + # 推理 + start_time = time.time() + outputs = self.rknn.inference(inputs=[input_image]) + inference_time = time.time() - start_time + + # 后处理 + boxes, scores, class_ids = self.postprocess(outputs, conf_threshold, nms_threshold) + + return boxes, scores, class_ids, inference_time + + def draw_detections(self, image, boxes, scores, class_ids): + """在图像上绘制检测结果""" + for i in range(len(boxes)): + x1, y1, x2, y2 = boxes[i].astype(int) + score = scores[i] + class_id = int(class_ids[i]) + + # 绘制边界框 + cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2) + + # 绘制标签 + label = f"{self.class_names[class_id]}: {score:.2f}" + label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)[0] + cv2.rectangle(image, (x1, y1-label_size[1]-10), + (x1+label_size[0], y1), (0, 255, 0), -1) + cv2.putText(image, label, (x1, y1-5), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 2) + + return image + + def release(self): + """释放资源""" + if self.rknn: + self.rknn.release() + +def main(): + # 初始化检测器 + model_path = "/home/orangepi/Desktop/康达机器狗/model_rknn/yolov8_20250820.rknn" + detector = YOLOv8RKNN(model_path) + + # 测试单张图片 + def test_image(image_path): + image = cv2.imread(image_path) + if image is None: + print(f"Cannot load image: {image_path}") + return + + # 执行检测 + boxes, scores, class_ids, inference_time = detector.detect(image) + + print(f"Inference time: {inference_time*1000:.2f}ms") + print(f"Detected {len(boxes)} objects") + + # 绘制结果 + result_image = detector.draw_detections(image, boxes, scores, class_ids) + + # 显示结果 + # cv2.imshow("Detection Result", result_image) + # cv2.waitKey(0) + # cv2.destroyAllWindows() + + cv2.imwrite("xxxxxxx.jpg", result_image) + + # 测试摄像头实时检测 + def test_camera(): + cap = cv2.VideoCapture(0) # 使用默认摄像头 + if not cap.isOpened(): + print("Cannot open camera") + return + + while True: + ret, frame = cap.read() + if not ret: + break + + # 执行检测 + boxes, scores, class_ids, inference_time = detector.detect(frame) + + # 绘制结果 + result_frame = detector.draw_detections(frame, boxes, scores, class_ids) + + # 显示FPS + fps = 1.0 / inference_time if inference_time > 0 else 0 + cv2.putText(result_frame, f"FPS: {fps:.1f}", (10, 30), + cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) + + cv2.imshow("Real-time Detection", result_frame) + + if cv2.waitKey(1) & 0xFF == ord('q'): + break + + cap.release() + cv2.destroyAllWindows() + + # 选择测试模式 + mode = input("选择模式 (1: 图片检测, 2: 摄像头实时检测): ") + + if mode == "1": + image_path = input("输入图片路径: ") + test_image(image_path) + elif mode == "2": + test_camera() + else: + print("无效选择") + + # 释放资源 + detector.release() + +def draw_detections(image, boxes, scores, class_ids, class_names=None): + """ + 在图像上绘制检测结果 + + Args: + image: 输入图像 + boxes: 检测框 + scores: 置信度分数 + class_ids: 类别ID + class_names: 类别名称列表（可选） + + Returns: + 绘制了检测结果的图像 + """ + result_image = image.copy() + + for i, (box, score, class_id) in enumerate(zip(boxes, scores, class_ids)): + x1, y1, x2, y2 = map(int, box) + + # 绘制边界框 + cv2.rectangle(result_image, (x1, y1), (x2, y2), (0, 255, 0), 2) + + # 准备标签文本 + if class_names and class_id < len(class_names): + label = f"{class_names[class_id]}: {score:.2f}" + else: + label = f"Class {class_id}: {score:.2f}" + + # 绘制标签背景 + label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)[0] + cv2.rectangle(result_image, (x1, y1 - label_size[1] - 10), + (x1 + label_size[0], y1), (0, 255, 0), -1) + + # 绘制标签文本 + cv2.putText(result_image, label, (x1, y1 - 5), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 2) + + return result_image \ No newline at end of file diff --git a/base64.txt b/base64.txt new file mode 100644 index 0000000..accfc8a --- /dev/null +++ b/base64.txt @@ -0,0 +1 @@ +'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' \ No newline at end of file diff --git a/dict.yaml b/dict.yaml new file mode 100644 index 0000000..dda5f7e --- /dev/null +++ b/dict.yaml @@ -0,0 +1,18385 @@ +character_dict: + - blank + - 　 + - 一 + - 乙 + - 二 + - 十 + - 丁 + - 厂 + - 七 + - 卜 + - 八 + - 人 + - 入 + - 儿 + - 匕 + - 几 + - 九 + - 刁 + - 了 + - 刀 + - 力 + - 乃 + - 又 + - 三 + - 干 + - 于 + - 亏 + - 工 + - 土 + - 士 + - 才 + - 下 + - 寸 + - 大 + - 丈 + - 与 + - 万 + - 上 + - 小 + - 口 + - 山 + - 巾 + - 千 + - 乞 + - 川 + - 亿 + - 个 + - 夕 + - 久 + - 么 + - 勺 + - 凡 + - 丸 + - 及 + - 广 + - 亡 + - 门 + - 丫 + - 义 + - 之 + - 尸 + - 己 + - 已 + - 巳 + - 弓 + - 子 + - 卫 + - 也 + - 女 + - 刃 + - 飞 + - 习 + - 叉 + - 马 + - 乡 + - 丰 + - 王 + - 开 + - 井 + - 天 + - 夫 + - 元 + - 无 + - 云 + - 专 + - 丐 + - 扎 + - 艺 + - 木 + - 五 + - 支 + - 厅 + - 不 + - 犬 + - 太 + - 区 + - 历 + - 歹 + - 友 + - 尤 + - 匹 + - 车 + - 巨 + - 牙 + - 屯 + - 戈 + - 比 + - 互 + - 切 + - 瓦 + - 止 + - 少 + - 曰 + - 日 + - 中 + - 贝 + - 冈 + - 内 + - 水 + - 见 + - 午 + - 牛 + - 手 + - 气 + - 毛 + - 壬 + - 升 + - 夭 + - 长 + - 仁 + - 什 + - 片 + - 仆 + - 化 + - 仇 + - 币 + - 仍 + - 仅 + - 斤 + - 爪 + - 反 + - 介 + - 父 + - 从 + - 仑 + - 今 + - 凶 + - 分 + - 乏 + - 公 + - 仓 + - 月 + - 氏 + - 勿 + - 欠 + - 风 + - 丹 + - 匀 + - 乌 + - 勾 + - 凤 + - 六 + - 文 + - 亢 + - 方 + - 火 + - 为 + - 斗 + - 忆 + - 计 + - 订 + - 户 + - 认 + - 冗 + - 讥 + - 心 + - 尺 + - 引 + - 丑 + - 巴 + - 孔 + - 队 + - 办 + - 以 + - 允 + - 予 + - 邓 + - 劝 + - 双 + - 书 + - 幻 + - 玉 + - 刊 + - 未 + - 末 + - 示 + - 击 + - 打 + - 巧 + - 正 + - 扑 + - 卉 + - 扒 + - 功 + - 扔 + - 去 + - 甘 + - 世 + - 艾 + - 古 + - 节 + - 本 + - 术 + - 可 + - 丙 + - 左 + - 厉 + - 石 + - 右 + - 布 + - 夯 + - 戊 + - 龙 + - 平 + - 灭 + - 轧 + - 东 + - 卡 + - 北 + - 占 + - 凸 + - 卢 + - 业 + - 旧 + - 帅 + - 归 + - 旦 + - 目 + - 且 + - 叶 + - 甲 + - 申 + - 叮 + - 电 + - 号 + - 田 + - 由 + - 只 + - 叭 + - 史 + - 央 + - 兄 + - 叽 + - 叼 + - 叫 + - 叩 + - 叨 + - 另 + - 叹 + - 冉 + - 皿 + - 凹 + - 囚 + - 四 + - 生 + - 矢 + - 失 + - 乍 + - 禾 + - 丘 + - 付 + - 仗 + - 代 + - 仙 + - 们 + - 仪 + - 白 + - 仔 + - 他 + - 斥 + - 瓜 + - 乎 + - 丛 + - 令 + - 用 + - 甩 + - 印 + - 尔 + - 乐 + - 句 + - 匆 + - 册 + - 卯 + - 犯 + - 外 + - 处 + - 冬 + - 鸟 + - 务 + - 包 + - 饥 + - 主 + - 市 + - 立 + - 冯 + - 玄 + - 闪 + - 兰 + - 半 + - 汁 + - 汇 + - 头 + - 汉 + - 宁 + - 穴 + - 它 + - 讨 + - 写 + - 让 + - 礼 + - 训 + - 议 + - 必 + - 讯 + - 记 + - 永 + - 司 + - 尼 + - 民 + - 弗 + - 弘 + - 出 + - 辽 + - 奶 + - 奴 + - 召 + - 加 + - 皮 + - 边 + - 孕 + - 发 + - 圣 + - 对 + - 台 + - 矛 + - 纠 + - 母 + - 幼 + - 丝 + - 邦 + - 式 + - 迂 + - 刑 + - 戎 + - 动 + - 扛 + - 寺 + - 吉 + - 扣 + - 考 + - 托 + - 老 + - 巩 + - 圾 + - 执 + - 扩 + - 扫 + - 地 + - 场 + - 扬 + - 耳 + - 芋 + - 共 + - 芒 + - 亚 + - 芝 + - 朽 + - 朴 + - 机 + - 权 + - 过 + - 臣 + - 吏 + - 再 + - 协 + - 西 + - 压 + - 厌 + - 戌 + - 在 + - 百 + - 有 + - 存 + - 而 + - 页 + - 匠 + - 夸 + - 夺 + - 灰 + - 达 + - 列 + - 死 + - 成 + - 夹 + - 夷 + - 轨 + - 邪 + - 尧 + - 划 + - 迈 + - 毕 + - 至 + - 此 + - 贞 + - 师 + - 尘 + - 尖 + - 劣 + - 光 + - 当 + - 早 + - 吁 + - 吐 + - 吓 + - 虫 + - 曲 + - 团 + - 吕 + - 同 + - 吊 + - 吃 + - 因 + - 吸 + - 吗 + - 吆 + - 屿 + - 屹 + - 岁 + - 帆 + - 回 + - 岂 + - 则 + - 刚 + - 网 + - 肉 + - 年 + - 朱 + - 先 + - 丢 + - 廷 + - 舌 + - 竹 + - 迁 + - 乔 + - 迄 + - 伟 + - 传 + - 乒 + - 乓 + - 休 + - 伍 + - 伏 + - 优 + - 臼 + - 伐 + - 延 + - 仲 + - 件 + - 任 + - 伤 + - 价 + - 伦 + - 份 + - 华 + - 仰 + - 仿 + - 伙 + - 伪 + - 自 + - 伊 + - 血 + - 向 + - 似 + - 后 + - 行 + - 舟 + - 全 + - 会 + - 杀 + - 合 + - 兆 + - 企 + - 众 + - 爷 + - 伞 + - 创 + - 肌 + - 肋 + - 朵 + - 杂 + - 危 + - 旬 + - 旨 + - 旭 + - 负 + - 匈 + - 名 + - 各 + - 多 + - 争 + - 色 + - 壮 + - 冲 + - 妆 + - 冰 + - 庄 + - 庆 + - 亦 + - 刘 + - 齐 + - 交 + - 衣 + - 次 + - 产 + - 决 + - 亥 + - 充 + - 妄 + - 闭 + - 问 + - 闯 + - 羊 + - 并 + - 关 + - 米 + - 灯 + - 州 + - 汗 + - 污 + - 江 + - 汛 + - 池 + - 汝 + - 汤 + - 忙 + - 兴 + - 宇 + - 守 + - 宅 + - 字 + - 安 + - 讲 + - 讳 + - 军 + - 讶 + - 许 + - 讹 + - 论 + - 讼 + - 农 + - 讽 + - 设 + - 访 + - 诀 + - 寻 + - 那 + - 迅 + - 尽 + - 导 + - 异 + - 弛 + - 孙 + - 阵 + - 阳 + - 收 + - 阶 + - 阴 + - 防 + - 奸 + - 如 + - 妇 + - 妃 + - 好 + - 她 + - 妈 + - 戏 + - 羽 + - 观 + - 欢 + - 买 + - 红 + - 驮 + - 纤 + - 驯 + - 约 + - 级 + - 纪 + - 驰 + - 纫 + - 巡 + - 寿 + - 弄 + - 麦 + - 玖 + - 玛 + - 形 + - 进 + - 戒 + - 吞 + - 远 + - 违 + - 韧 + - 运 + - 扶 + - 抚 + - 坛 + - 技 + - 坏 + - 抠 + - 扰 + - 扼 + - 拒 + - 找 + - 批 + - 址 + - 扯 + - 走 + - 抄 + - 贡 + - 汞 + - 坝 + - 攻 + - 赤 + - 折 + - 抓 + - 扳 + - 抡 + - 扮 + - 抢 + - 孝 + - 坎 + - 均 + - 抑 + - 抛 + - 投 + - 坟 + - 坑 + - 抗 + - 坊 + - 抖 + - 护 + - 壳 + - 志 + - 块 + - 扭 + - 声 + - 把 + - 报 + - 拟 + - 却 + - 抒 + - 劫 + - 芙 + - 芜 + - 苇 + - 芽 + - 花 + - 芹 + - 芥 + - 芬 + - 苍 + - 芳 + - 严 + - 芦 + - 芯 + - 劳 + - 克 + - 芭 + - 苏 + - 杆 + - 杠 + - 杜 + - 材 + - 村 + - 杖 + - 杏 + - 杉 + - 巫 + - 极 + - 李 + - 杨 + - 求 + - 甫 + - 匣 + - 更 + - 束 + - 吾 + - 豆 + - 两 + - 酉 + - 丽 + - 医 + - 辰 + - 励 + - 否 + - 还 + - 尬 + - 歼 + - 来 + - 连 + - 轩 + - 步 + - 卤 + - 坚 + - 肖 + - 旱 + - 盯 + - 呈 + - 时 + - 吴 + - 助 + - 县 + - 里 + - 呆 + - 吱 + - 吠 + - 呕 + - 园 + - 旷 + - 围 + - 呀 + - 吨 + - 足 + - 邮 + - 男 + - 困 + - 吵 + - 串 + - 员 + - 呐 + - 听 + - 吟 + - 吩 + - 呛 + - 吻 + - 吹 + - 呜 + - 吭 + - 吧 + - 邑 + - 吼 + - 囤 + - 别 + - 吮 + - 岖 + - 岗 + - 帐 + - 财 + - 针 + - 钉 + - 牡 + - 告 + - 我 + - 乱 + - 利 + - 秃 + - 秀 + - 私 + - 每 + - 兵 + - 估 + - 体 + - 何 + - 佐 + - 佑 + - 但 + - 伸 + - 佃 + - 作 + - 伯 + - 伶 + - 佣 + - 低 + - 你 + - 住 + - 位 + - 伴 + - 身 + - 皂 + - 伺 + - 佛 + - 囱 + - 近 + - 彻 + - 役 + - 返 + - 余 + - 希 + - 坐 + - 谷 + - 妥 + - 含 + - 邻 + - 岔 + - 肝 + - 肛 + - 肚 + - 肘 + - 肠 + - 龟 + - 甸 + - 免 + - 狂 + - 犹 + - 狈 + - 角 + - 删 + - 条 + - 彤 + - 卵 + - 灸 + - 岛 + - 刨 + - 迎 + - 饭 + - 饮 + - 系 + - 言 + - 冻 + - 状 + - 亩 + - 况 + - 床 + - 库 + - 庇 + - 疗 + - 吝 + - 应 + - 这 + - 冷 + - 庐 + - 序 + - 辛 + - 弃 + - 冶 + - 忘 + - 闰 + - 闲 + - 间 + - 闷 + - 判 + - 兑 + - 灶 + - 灿 + - 灼 + - 弟 + - 汪 + - 沐 + - 沛 + - 汰 + - 沥 + - 沙 + - 汽 + - 沃 + - 沦 + - 汹 + - 泛 + - 沧 + - 没 + - 沟 + - 沪 + - 沈 + - 沉 + - 沁 + - 怀 + - 忧 + - 忱 + - 快 + - 完 + - 宋 + - 宏 + - 牢 + - 究 + - 穷 + - 灾 + - 良 + - 证 + - 启 + - 评 + - 补 + - 初 + - 社 + - 祀 + - 识 + - 诈 + - 诉 + - 罕 + - 诊 + - 词 + - 译 + - 君 + - 灵 + - 即 + - 层 + - 屁 + - 尿 + - 尾 + - 迟 + - 局 + - 改 + - 张 + - 忌 + - 际 + - 陆 + - 阿 + - 陈 + - 阻 + - 附 + - 坠 + - 妓 + - 妙 + - 妖 + - 姊 + - 妨 + - 妒 + - 努 + - 忍 + - 劲 + - 矣 + - 鸡 + - 纬 + - 驱 + - 纯 + - 纱 + - 纲 + - 纳 + - 驳 + - 纵 + - 纷 + - 纸 + - 纹 + - 纺 + - 驴 + - 纽 + - 奉 + - 玩 + - 环 + - 武 + - 青 + - 责 + - 现 + - 玫 + - 表 + - 规 + - 抹 + - 卦 + - 坷 + - 坯 + - 拓 + - 拢 + - 拔 + - 坪 + - 拣 + - 坦 + - 担 + - 坤 + - 押 + - 抽 + - 拐 + - 拖 + - 者 + - 拍 + - 顶 + - 拆 + - 拎 + - 拥 + - 抵 + - 拘 + - 势 + - 抱 + - 拄 + - 垃 + - 拉 + - 拦 + - 幸 + - 拌 + - 拧 + - 拂 + - 拙 + - 招 + - 坡 + - 披 + - 拨 + - 择 + - 抬 + - 拇 + - 拗 + - 其 + - 取 + - 茉 + - 苦 + - 昔 + - 苛 + - 若 + - 茂 + - 苹 + - 苗 + - 英 + - 苟 + - 苑 + - 苞 + - 范 + - 直 + - 茁 + - 茄 + - 茎 + - 苔 + - 茅 + - 枉 + - 林 + - 枝 + - 杯 + - 枢 + - 柜 + - 枚 + - 析 + - 板 + - 松 + - 枪 + - 枫 + - 构 + - 杭 + - 杰 + - 述 + - 枕 + - 丧 + - 或 + - 画 + - 卧 + - 事 + - 刺 + - 枣 + - 雨 + - 卖 + - 郁 + - 矾 + - 矿 + - 码 + - 厕 + - 奈 + - 奔 + - 奇 + - 奋 + - 态 + - 欧 + - 殴 + - 垄 + - 妻 + - 轰 + - 顷 + - 转 + - 斩 + - 轮 + - 软 + - 到 + - 非 + - 叔 + - 歧 + - 肯 + - 齿 + - 些 + - 卓 + - 虎 + - 虏 + - 肾 + - 贤 + - 尚 + - 旺 + - 具 + - 味 + - 果 + - 昆 + - 国 + - 哎 + - 咕 + - 昌 + - 呵 + - 畅 + - 明 + - 易 + - 咙 + - 昂 + - 迪 + - 典 + - 固 + - 忠 + - 呻 + - 咒 + - 咋 + - 咐 + - 呼 + - 鸣 + - 咏 + - 呢 + - 咄 + - 咖 + - 岸 + - 岩 + - 帖 + - 罗 + - 帜 + - 帕 + - 岭 + - 凯 + - 败 + - 账 + - 贩 + - 贬 + - 购 + - 贮 + - 图 + - 钓 + - 制 + - 知 + - 迭 + - 氛 + - 垂 + - 牧 + - 物 + - 乖 + - 刮 + - 秆 + - 和 + - 季 + - 委 + - 秉 + - 佳 + - 侍 + - 岳 + - 供 + - 使 + - 例 + - 侠 + - 侥 + - 版 + - 侄 + - 侦 + - 侣 + - 侧 + - 凭 + - 侨 + - 佩 + - 货 + - 侈 + - 依 + - 卑 + - 的 + - 迫 + - 质 + - 欣 + - 征 + - 往 + - 爬 + - 彼 + - 径 + - 所 + - 舍 + - 金 + - 刹 + - 命 + - 肴 + - 斧 + - 爸 + - 采 + - 觅 + - 受 + - 乳 + - 贪 + - 念 + - 贫 + - 忿 + - 肤 + - 肺 + - 肢 + - 肿 + - 胀 + - 朋 + - 股 + - 肮 + - 肪 + - 肥 + - 服 + - 胁 + - 周 + - 昏 + - 鱼 + - 兔 + - 狐 + - 忽 + - 狗 + - 狞 + - 备 + - 饰 + - 饱 + - 饲 + - 变 + - 京 + - 享 + - 庞 + - 店 + - 夜 + - 庙 + - 府 + - 底 + - 疟 + - 疙 + - 疚 + - 剂 + - 卒 + - 郊 + - 庚 + - 废 + - 净 + - 盲 + - 放 + - 刻 + - 育 + - 氓 + - 闸 + - 闹 + - 郑 + - 券 + - 卷 + - 单 + - 炬 + - 炒 + - 炊 + - 炕 + - 炎 + - 炉 + - 沫 + - 浅 + - 法 + - 泄 + - 沽 + - 河 + - 沾 + - 泪 + - 沮 + - 油 + - 泊 + - 沿 + - 泡 + - 注 + - 泣 + - 泞 + - 泻 + - 泌 + - 泳 + - 泥 + - 沸 + - 沼 + - 波 + - 泼 + - 泽 + - 治 + - 怔 + - 怯 + - 怖 + - 性 + - 怕 + - 怜 + - 怪 + - 怡 + - 学 + - 宝 + - 宗 + - 定 + - 宠 + - 宜 + - 审 + - 宙 + - 官 + - 空 + - 帘 + - 宛 + - 实 + - 试 + - 郎 + - 诗 + - 肩 + - 房 + - 诚 + - 衬 + - 衫 + - 视 + - 祈 + - 话 + - 诞 + - 诡 + - 询 + - 该 + - 详 + - 建 + - 肃 + - 录 + - 隶 + - 帚 + - 屉 + - 居 + - 届 + - 刷 + - 屈 + - 弧 + - 弥 + - 弦 + - 承 + - 孟 + - 陋 + - 陌 + - 孤 + - 陕 + - 降 + - 函 + - 限 + - 妹 + - 姑 + - 姐 + - 姓 + - 妮 + - 始 + - 姆 + - 迢 + - 驾 + - 叁 + - 参 + - 艰 + - 线 + - 练 + - 组 + - 绅 + - 细 + - 驶 + - 织 + - 驹 + - 终 + - 驻 + - 绊 + - 驼 + - 绍 + - 绎 + - 经 + - 贯 + - 契 + - 贰 + - 奏 + - 春 + - 帮 + - 玷 + - 珍 + - 玲 + - 玻 + - 毒 + - 型 + - 拭 + - 挂 + - 封 + - 持 + - 拷 + - 拱 + - 项 + - 垮 + - 挎 + - 城 + - 挟 + - 挠 + - 政 + - 赴 + - 赵 + - 挡 + - 拽 + - 哉 + - 挺 + - 括 + - 垢 + - 拴 + - 拾 + - 挑 + - 垛 + - 指 + - 垫 + - 挣 + - 挤 + - 拼 + - 挖 + - 按 + - 挥 + - 挪 + - 拯 + - 某 + - 甚 + - 荆 + - 茸 + - 革 + - 茬 + - 荐 + - 巷 + - 带 + - 草 + - 茧 + - 茵 + - 茶 + - 荒 + - 茫 + - 荡 + - 荣 + - 荤 + - 荧 + - 故 + - 胡 + - 荫 + - 荔 + - 南 + - 药 + - 标 + - 栈 + - 柑 + - 枯 + - 柄 + - 栋 + - 相 + - 查 + - 柏 + - 栅 + - 柳 + - 柱 + - 柿 + - 栏 + - 柠 + - 树 + - 勃 + - 要 + - 柬 + - 咸 + - 威 + - 歪 + - 研 + - 砖 + - 厘 + - 厚 + - 砌 + - 砂 + - 泵 + - 砚 + - 砍 + - 面 + - 耐 + - 耍 + - 牵 + - 鸥 + - 残 + - 殃 + - 轴 + - 轻 + - 鸦 + - 皆 + - 韭 + - 背 + - 战 + - 点 + - 虐 + - 临 + - 览 + - 竖 + - 省 + - 削 + - 尝 + - 昧 + - 盹 + - 是 + - 盼 + - 眨 + - 哇 + - 哄 + - 哑 + - 显 + - 冒 + - 映 + - 星 + - 昨 + - 咧 + - 昭 + - 畏 + - 趴 + - 胃 + - 贵 + - 界 + - 虹 + - 虾 + - 蚁 + - 思 + - 蚂 + - 虽 + - 品 + - 咽 + - 骂 + - 勋 + - 哗 + - 咱 + - 响 + - 哈 + - 哆 + - 咬 + - 咳 + - 咪 + - 哪 + - 哟 + - 炭 + - 峡 + - 罚 + - 贱 + - 贴 + - 贻 + - 骨 + - 幽 + - 钙 + - 钝 + - 钞 + - 钟 + - 钢 + - 钠 + - 钥 + - 钦 + - 钧 + - 钩 + - 钮 + - 卸 + - 缸 + - 拜 + - 看 + - 矩 + - 毡 + - 氢 + - 怎 + - 牲 + - 选 + - 适 + - 秒 + - 香 + - 种 + - 秋 + - 科 + - 重 + - 复 + - 竿 + - 段 + - 便 + - 俩 + - 贷 + - 顺 + - 修 + - 俏 + - 保 + - 促 + - 俄 + - 俐 + - 侮 + - 俭 + - 俗 + - 俘 + - 信 + - 皇 + - 泉 + - 鬼 + - 侵 + - 禹 + - 侯 + - 追 + - 俊 + - 盾 + - 待 + - 徊 + - 衍 + - 律 + - 很 + - 须 + - 叙 + - 剑 + - 逃 + - 食 + - 盆 + - 胚 + - 胧 + - 胆 + - 胜 + - 胞 + - 胖 + - 脉 + - 胎 + - 勉 + - 狭 + - 狮 + - 独 + - 狰 + - 狡 + - 狱 + - 狠 + - 贸 + - 怨 + - 急 + - 饵 + - 饶 + - 蚀 + - 饺 + - 饼 + - 峦 + - 弯 + - 将 + - 奖 + - 哀 + - 亭 + - 亮 + - 度 + - 迹 + - 庭 + - 疮 + - 疯 + - 疫 + - 疤 + - 咨 + - 姿 + - 亲 + - 音 + - 帝 + - 施 + - 闺 + - 闻 + - 闽 + - 阀 + - 阁 + - 差 + - 养 + - 美 + - 姜 + - 叛 + - 送 + - 类 + - 迷 + - 籽 + - 娄 + - 前 + - 首 + - 逆 + - 兹 + - 总 + - 炼 + - 炸 + - 烁 + - 炮 + - 炫 + - 烂 + - 剃 + - 洼 + - 洁 + - 洪 + - 洒 + - 柒 + - 浇 + - 浊 + - 洞 + - 测 + - 洗 + - 活 + - 派 + - 洽 + - 染 + - 洛 + - 浏 + - 济 + - 洋 + - 洲 + - 浑 + - 浓 + - 津 + - 恃 + - 恒 + - 恢 + - 恍 + - 恬 + - 恤 + - 恰 + - 恼 + - 恨 + - 举 + - 觉 + - 宣 + - 宦 + - 室 + - 宫 + - 宪 + - 突 + - 穿 + - 窃 + - 客 + - 诫 + - 冠 + - 诬 + - 语 + - 扁 + - 袄 + - 祖 + - 神 + - 祝 + - 祠 + - 误 + - 诱 + - 诲 + - 说 + - 诵 + - 垦 + - 退 + - 既 + - 屋 + - 昼 + - 屏 + - 屎 + - 费 + - 陡 + - 逊 + - 眉 + - 孩 + - 陨 + - 除 + - 险 + - 院 + - 娃 + - 姥 + - 姨 + - 姻 + - 娇 + - 姚 + - 娜 + - 怒 + - 架 + - 贺 + - 盈 + - 勇 + - 怠 + - 癸 + - 蚤 + - 柔 + - 垒 + - 绑 + - 绒 + - 结 + - 绕 + - 骄 + - 绘 + - 给 + - 绚 + - 骆 + - 络 + - 绝 + - 绞 + - 骇 + - 统 + - 耕 + - 耘 + - 耗 + - 耙 + - 艳 + - 泰 + - 秦 + - 珠 + - 班 + - 素 + - 匿 + - 蚕 + - 顽 + - 盏 + - 匪 + - 捞 + - 栽 + - 捕 + - 埂 + - 捂 + - 振 + - 载 + - 赶 + - 起 + - 盐 + - 捎 + - 捍 + - 捏 + - 埋 + - 捉 + - 捆 + - 捐 + - 损 + - 袁 + - 捌 + - 都 + - 哲 + - 逝 + - 捡 + - 挫 + - 换 + - 挽 + - 挚 + - 热 + - 恐 + - 捣 + - 壶 + - 捅 + - 埃 + - 挨 + - 耻 + - 耿 + - 耽 + - 聂 + - 恭 + - 莽 + - 莱 + - 莲 + - 莫 + - 莉 + - 荷 + - 获 + - 晋 + - 恶 + - 莹 + - 莺 + - 真 + - 框 + - 梆 + - 桂 + - 桔 + - 栖 + - 档 + - 桐 + - 株 + - 桥 + - 桦 + - 栓 + - 桃 + - 格 + - 桩 + - 校 + - 核 + - 样 + - 根 + - 索 + - 哥 + - 速 + - 逗 + - 栗 + - 贾 + - 酌 + - 配 + - 翅 + - 辱 + - 唇 + - 夏 + - 砸 + - 砰 + - 砾 + - 础 + - 破 + - 原 + - 套 + - 逐 + - 烈 + - 殊 + - 殉 + - 顾 + - 轿 + - 较 + - 顿 + - 毙 + - 致 + - 柴 + - 桌 + - 虑 + - 监 + - 紧 + - 党 + - 逞 + - 晒 + - 眠 + - 晓 + - 哮 + - 唠 + - 鸭 + - 晃 + - 哺 + - 晌 + - 剔 + - 晕 + - 蚌 + - 畔 + - 蚣 + - 蚊 + - 蚪 + - 蚓 + - 哨 + - 哩 + - 圃 + - 哭 + - 哦 + - 恩 + - 鸯 + - 唤 + - 唁 + - 哼 + - 唧 + - 啊 + - 唉 + - 唆 + - 罢 + - 峭 + - 峨 + - 峰 + - 圆 + - 峻 + - 贼 + - 贿 + - 赂 + - 赃 + - 钱 + - 钳 + - 钻 + - 钾 + - 铁 + - 铃 + - 铅 + - 缺 + - 氧 + - 氨 + - 特 + - 牺 + - 造 + - 乘 + - 敌 + - 秤 + - 租 + - 积 + - 秧 + - 秩 + - 称 + - 秘 + - 透 + - 笔 + - 笑 + - 笋 + - 债 + - 借 + - 值 + - 倚 + - 俺 + - 倾 + - 倒 + - 倘 + - 俱 + - 倡 + - 候 + - 赁 + - 俯 + - 倍 + - 倦 + - 健 + - 臭 + - 射 + - 躬 + - 息 + - 倔 + - 徒 + - 徐 + - 殷 + - 舰 + - 舱 + - 般 + - 航 + - 途 + - 拿 + - 耸 + - 爹 + - 舀 + - 爱 + - 豺 + - 豹 + - 颁 + - 颂 + - 翁 + - 胰 + - 脆 + - 脂 + - 胸 + - 胳 + - 脏 + - 脐 + - 胶 + - 脑 + - 脓 + - 逛 + - 狸 + - 狼 + - 卿 + - 逢 + - 鸵 + - 留 + - 鸳 + - 皱 + - 饿 + - 馁 + - 凌 + - 凄 + - 恋 + - 桨 + - 浆 + - 衰 + - 衷 + - 高 + - 郭 + - 席 + - 准 + - 座 + - 症 + - 病 + - 疾 + - 斋 + - 疹 + - 疼 + - 疲 + - 脊 + - 效 + - 离 + - 紊 + - 唐 + - 瓷 + - 资 + - 凉 + - 站 + - 剖 + - 竞 + - 部 + - 旁 + - 旅 + - 畜 + - 阅 + - 羞 + - 羔 + - 瓶 + - 拳 + - 粉 + - 料 + - 益 + - 兼 + - 烤 + - 烘 + - 烦 + - 烧 + - 烛 + - 烟 + - 烙 + - 递 + - 涛 + - 浙 + - 涝 + - 浦 + - 酒 + - 涉 + - 消 + - 涡 + - 浩 + - 海 + - 涂 + - 浴 + - 浮 + - 涣 + - 涤 + - 流 + - 润 + - 涧 + - 涕 + - 浪 + - 浸 + - 涨 + - 烫 + - 涩 + - 涌 + - 悖 + - 悟 + - 悄 + - 悍 + - 悔 + - 悯 + - 悦 + - 害 + - 宽 + - 家 + - 宵 + - 宴 + - 宾 + - 窍 + - 窄 + - 容 + - 宰 + - 案 + - 请 + - 朗 + - 诸 + - 诺 + - 读 + - 扇 + - 诽 + - 袜 + - 袖 + - 袍 + - 被 + - 祥 + - 课 + - 冥 + - 谁 + - 调 + - 冤 + - 谅 + - 谆 + - 谈 + - 谊 + - 剥 + - 恳 + - 展 + - 剧 + - 屑 + - 弱 + - 陵 + - 祟 + - 陶 + - 陷 + - 陪 + - 娱 + - 娟 + - 恕 + - 娥 + - 娘 + - 通 + - 能 + - 难 + - 预 + - 桑 + - 绢 + - 绣 + - 验 + - 继 + - 骏 + - 球 + - 琐 + - 理 + - 琉 + - 琅 + - 捧 + - 堵 + - 措 + - 描 + - 域 + - 捺 + - 掩 + - 捷 + - 排 + - 焉 + - 掉 + - 捶 + - 赦 + - 堆 + - 推 + - 埠 + - 掀 + - 授 + - 捻 + - 教 + - 掏 + - 掐 + - 掠 + - 掂 + - 培 + - 接 + - 掷 + - 控 + - 探 + - 据 + - 掘 + - 掺 + - 职 + - 基 + - 聆 + - 勘 + - 聊 + - 娶 + - 著 + - 菱 + - 勒 + - 黄 + - 菲 + - 萌 + - 萝 + - 菌 + - 萎 + - 菜 + - 萄 + - 菊 + - 菩 + - 萍 + - 菠 + - 萤 + - 营 + - 乾 + - 萧 + - 萨 + - 菇 + - 械 + - 彬 + - 梦 + - 婪 + - 梗 + - 梧 + - 梢 + - 梅 + - 检 + - 梳 + - 梯 + - 桶 + - 梭 + - 救 + - 曹 + - 副 + - 票 + - 酝 + - 酗 + - 厢 + - 戚 + - 硅 + - 硕 + - 奢 + - 盔 + - 爽 + - 聋 + - 袭 + - 盛 + - 匾 + - 雪 + - 辅 + - 辆 + - 颅 + - 虚 + - 彪 + - 雀 + - 堂 + - 常 + - 眶 + - 匙 + - 晨 + - 睁 + - 眯 + - 眼 + - 悬 + - 野 + - 啪 + - 啦 + - 曼 + - 晦 + - 晚 + - 啄 + - 啡 + - 距 + - 趾 + - 啃 + - 跃 + - 略 + - 蚯 + - 蛀 + - 蛇 + - 唬 + - 累 + - 鄂 + - 唱 + - 患 + - 啰 + - 唾 + - 唯 + - 啤 + - 啥 + - 啸 + - 崖 + - 崎 + - 崭 + - 逻 + - 崔 + - 帷 + - 崩 + - 崇 + - 崛 + - 婴 + - 圈 + - 铐 + - 铛 + - 铝 + - 铜 + - 铭 + - 铲 + - 银 + - 矫 + - 甜 + - 秸 + - 梨 + - 犁 + - 秽 + - 移 + - 笨 + - 笼 + - 笛 + - 笙 + - 符 + - 第 + - 敏 + - 做 + - 袋 + - 悠 + - 偿 + - 偶 + - 偎 + - 偷 + - 您 + - 售 + - 停 + - 偏 + - 躯 + - 兜 + - 假 + - 衅 + - 徘 + - 徙 + - 得 + - 衔 + - 盘 + - 舶 + - 船 + - 舵 + - 斜 + - 盒 + - 鸽 + - 敛 + - 悉 + - 欲 + - 彩 + - 领 + - 脚 + - 脖 + - 脯 + - 豚 + - 脸 + - 脱 + - 象 + - 够 + - 逸 + - 猜 + - 猪 + - 猎 + - 猫 + - 凰 + - 猖 + - 猛 + - 祭 + - 馅 + - 馆 + - 凑 + - 减 + - 毫 + - 烹 + - 庶 + - 麻 + - 庵 + - 痊 + - 痒 + - 痕 + - 廊 + - 康 + - 庸 + - 鹿 + - 盗 + - 章 + - 竟 + - 商 + - 族 + - 旋 + - 望 + - 率 + - 阎 + - 阐 + - 着 + - 羚 + - 盖 + - 眷 + - 粘 + - 粗 + - 粒 + - 断 + - 剪 + - 兽 + - 焊 + - 焕 + - 清 + - 添 + - 鸿 + - 淋 + - 涯 + - 淹 + - 渠 + - 渐 + - 淑 + - 淌 + - 混 + - 淮 + - 淆 + - 渊 + - 淫 + - 渔 + - 淘 + - 淳 + - 液 + - 淤 + - 淡 + - 淀 + - 深 + - 涮 + - 涵 + - 婆 + - 梁 + - 渗 + - 情 + - 惜 + - 惭 + - 悼 + - 惧 + - 惕 + - 惟 + - 惊 + - 惦 + - 悴 + - 惋 + - 惨 + - 惯 + - 寇 + - 寅 + - 寄 + - 寂 + - 宿 + - 窒 + - 窑 + - 密 + - 谋 + - 谍 + - 谎 + - 谐 + - 袱 + - 祷 + - 祸 + - 谓 + - 谚 + - 谜 + - 逮 + - 敢 + - 尉 + - 屠 + - 弹 + - 隋 + - 堕 + - 随 + - 蛋 + - 隅 + - 隆 + - 隐 + - 婚 + - 婶 + - 婉 + - 颇 + - 颈 + - 绩 + - 绪 + - 续 + - 骑 + - 绰 + - 绳 + - 维 + - 绵 + - 绷 + - 绸 + - 综 + - 绽 + - 绿 + - 缀 + - 巢 + - 琴 + - 琳 + - 琢 + - 琼 + - 斑 + - 替 + - 揍 + - 款 + - 堪 + - 塔 + - 搭 + - 堰 + - 揩 + - 越 + - 趁 + - 趋 + - 超 + - 揽 + - 堤 + - 提 + - 博 + - 揭 + - 喜 + - 彭 + - 揣 + - 插 + - 揪 + - 搜 + - 煮 + - 援 + - 搀 + - 裁 + - 搁 + - 搓 + - 搂 + - 搅 + - 壹 + - 握 + - 搔 + - 揉 + - 斯 + - 期 + - 欺 + - 联 + - 葫 + - 散 + - 惹 + - 葬 + - 募 + - 葛 + - 董 + - 葡 + - 敬 + - 葱 + - 蒋 + - 蒂 + - 落 + - 韩 + - 朝 + - 辜 + - 葵 + - 棒 + - 棱 + - 棋 + - 椰 + - 植 + - 森 + - 焚 + - 椅 + - 椒 + - 棵 + - 棍 + - 椎 + - 棉 + - 棚 + - 棕 + - 棺 + - 榔 + - 椭 + - 惠 + - 惑 + - 逼 + - 粟 + - 棘 + - 酣 + - 酥 + - 厨 + - 厦 + - 硬 + - 硝 + - 确 + - 硫 + - 雁 + - 殖 + - 裂 + - 雄 + - 颊 + - 雳 + - 暂 + - 雅 + - 翘 + - 辈 + - 悲 + - 紫 + - 凿 + - 辉 + - 敞 + - 棠 + - 赏 + - 掌 + - 晴 + - 睐 + - 暑 + - 最 + - 晰 + - 量 + - 鼎 + - 喷 + - 喳 + - 晶 + - 喇 + - 遇 + - 喊 + - 遏 + - 晾 + - 景 + - 畴 + - 践 + - 跋 + - 跌 + - 跑 + - 跛 + - 遗 + - 蛙 + - 蛛 + - 蜓 + - 蜒 + - 蛤 + - 喝 + - 鹃 + - 喂 + - 喘 + - 喉 + - 喻 + - 啼 + - 喧 + - 嵌 + - 幅 + - 帽 + - 赋 + - 赌 + - 赎 + - 赐 + - 赔 + - 黑 + - 铸 + - 铺 + - 链 + - 销 + - 锁 + - 锄 + - 锅 + - 锈 + - 锋 + - 锌 + - 锐 + - 甥 + - 掰 + - 短 + - 智 + - 氮 + - 毯 + - 氯 + - 鹅 + - 剩 + - 稍 + - 程 + - 稀 + - 税 + - 筐 + - 等 + - 筑 + - 策 + - 筛 + - 筒 + - 筏 + - 答 + - 筋 + - 筝 + - 傲 + - 傅 + - 牌 + - 堡 + - 集 + - 焦 + - 傍 + - 储 + - 皓 + - 皖 + - 粤 + - 奥 + - 街 + - 惩 + - 御 + - 循 + - 艇 + - 舒 + - 逾 + - 番 + - 释 + - 禽 + - 腊 + - 脾 + - 腋 + - 腔 + - 腕 + - 鲁 + - 猩 + - 猬 + - 猾 + - 猴 + - 惫 + - 然 + - 馈 + - 馋 + - 装 + - 蛮 + - 就 + - 敦 + - 斌 + - 痘 + - 痢 + - 痪 + - 痛 + - 童 + - 竣 + - 阔 + - 善 + - 翔 + - 羡 + - 普 + - 粪 + - 尊 + - 奠 + - 道 + - 遂 + - 曾 + - 焰 + - 港 + - 滞 + - 湖 + - 湘 + - 渣 + - 渤 + - 渺 + - 湿 + - 温 + - 渴 + - 溃 + - 溅 + - 滑 + - 湃 + - 渝 + - 湾 + - 渡 + - 游 + - 滋 + - 渲 + - 溉 + - 愤 + - 慌 + - 惰 + - 愕 + - 愣 + - 惶 + - 愧 + - 愉 + - 慨 + - 割 + - 寒 + - 富 + - 寓 + - 窜 + - 窝 + - 窖 + - 窗 + - 窘 + - 遍 + - 雇 + - 裕 + - 裤 + - 裙 + - 禅 + - 禄 + - 谢 + - 谣 + - 谤 + - 谦 + - 犀 + - 属 + - 屡 + - 强 + - 粥 + - 疏 + - 隔 + - 隙 + - 隘 + - 媒 + - 絮 + - 嫂 + - 媚 + - 婿 + - 登 + - 缅 + - 缆 + - 缉 + - 缎 + - 缓 + - 缔 + - 缕 + - 骗 + - 编 + - 骚 + - 缘 + - 瑟 + - 鹉 + - 瑞 + - 瑰 + - 瑙 + - 魂 + - 肆 + - 摄 + - 摸 + - 填 + - 搏 + - 塌 + - 鼓 + - 摆 + - 携 + - 搬 + - 摇 + - 搞 + - 塘 + - 摊 + - 聘 + - 斟 + - 蒜 + - 勤 + - 靴 + - 靶 + - 鹊 + - 蓝 + - 墓 + - 幕 + - 蓬 + - 蓄 + - 蒲 + - 蓉 + - 蒙 + - 蒸 + - 献 + - 椿 + - 禁 + - 楚 + - 楷 + - 榄 + - 想 + - 槐 + - 榆 + - 楼 + - 概 + - 赖 + - 酪 + - 酬 + - 感 + - 碍 + - 碘 + - 碑 + - 碎 + - 碰 + - 碗 + - 碌 + - 尴 + - 雷 + - 零 + - 雾 + - 雹 + - 辐 + - 辑 + - 输 + - 督 + - 频 + - 龄 + - 鉴 + - 睛 + - 睹 + - 睦 + - 瞄 + - 睫 + - 睡 + - 睬 + - 嗜 + - 鄙 + - 嗦 + - 愚 + - 暖 + - 盟 + - 歇 + - 暗 + - 暇 + - 照 + - 畸 + - 跨 + - 跷 + - 跳 + - 跺 + - 跪 + - 路 + - 跤 + - 跟 + - 遣 + - 蜈 + - 蜗 + - 蛾 + - 蜂 + - 蜕 + - 嗅 + - 嗡 + - 嗓 + - 署 + - 置 + - 罪 + - 罩 + - 蜀 + - 幌 + - 错 + - 锚 + - 锡 + - 锣 + - 锤 + - 锥 + - 锦 + - 键 + - 锯 + - 锰 + - 矮 + - 辞 + - 稚 + - 稠 + - 颓 + - 愁 + - 筹 + - 签 + - 简 + - 筷 + - 毁 + - 舅 + - 鼠 + - 催 + - 傻 + - 像 + - 躲 + - 魁 + - 衙 + - 微 + - 愈 + - 遥 + - 腻 + - 腰 + - 腥 + - 腮 + - 腹 + - 腺 + - 鹏 + - 腾 + - 腿 + - 鲍 + - 猿 + - 颖 + - 触 + - 解 + - 煞 + - 雏 + - 馍 + - 馏 + - 酱 + - 禀 + - 痹 + - 廓 + - 痴 + - 痰 + - 廉 + - 靖 + - 新 + - 韵 + - 意 + - 誊 + - 粮 + - 数 + - 煎 + - 塑 + - 慈 + - 煤 + - 煌 + - 满 + - 漠 + - 滇 + - 源 + - 滤 + - 滥 + - 滔 + - 溪 + - 溜 + - 漓 + - 滚 + - 溢 + - 溯 + - 滨 + - 溶 + - 溺 + - 粱 + - 滩 + - 慎 + - 誉 + - 塞 + - 寞 + - 窥 + - 窟 + - 寝 + - 谨 + - 褂 + - 裸 + - 福 + - 谬 + - 群 + - 殿 + - 辟 + - 障 + - 媳 + - 嫉 + - 嫌 + - 嫁 + - 叠 + - 缚 + - 缝 + - 缠 + - 缤 + - 剿 + - 静 + - 碧 + - 璃 + - 赘 + - 熬 + - 墙 + - 墟 + - 嘉 + - 摧 + - 赫 + - 截 + - 誓 + - 境 + - 摘 + - 摔 + - 撇 + - 聚 + - 慕 + - 暮 + - 摹 + - 蔓 + - 蔑 + - 蔡 + - 蔗 + - 蔽 + - 蔼 + - 熙 + - 蔚 + - 兢 + - 模 + - 槛 + - 榴 + - 榜 + - 榨 + - 榕 + - 歌 + - 遭 + - 酵 + - 酷 + - 酿 + - 酸 + - 碟 + - 碱 + - 碳 + - 磁 + - 愿 + - 需 + - 辖 + - 辗 + - 雌 + - 裳 + - 颗 + - 瞅 + - 墅 + - 嗽 + - 踊 + - 蜻 + - 蜡 + - 蝇 + - 蜘 + - 蝉 + - 嘛 + - 嘀 + - 赚 + - 锹 + - 锻 + - 镀 + - 舞 + - 舔 + - 稳 + - 熏 + - 箕 + - 算 + - 箩 + - 管 + - 箫 + - 舆 + - 僚 + - 僧 + - 鼻 + - 魄 + - 魅 + - 貌 + - 膜 + - 膊 + - 膀 + - 鲜 + - 疑 + - 孵 + - 馒 + - 裹 + - 敲 + - 豪 + - 膏 + - 遮 + - 腐 + - 瘩 + - 瘟 + - 瘦 + - 辣 + - 彰 + - 竭 + - 端 + - 旗 + - 精 + - 粹 + - 歉 + - 弊 + - 熄 + - 熔 + - 煽 + - 潇 + - 漆 + - 漱 + - 漂 + - 漫 + - 滴 + - 漾 + - 演 + - 漏 + - 慢 + - 慷 + - 寨 + - 赛 + - 寡 + - 察 + - 蜜 + - 寥 + - 谭 + - 肇 + - 褐 + - 褪 + - 谱 + - 隧 + - 嫩 + - 翠 + - 熊 + - 凳 + - 骡 + - 缩 + - 慧 + - 撵 + - 撕 + - 撒 + - 撩 + - 趣 + - 趟 + - 撑 + - 撮 + - 撬 + - 播 + - 擒 + - 墩 + - 撞 + - 撤 + - 增 + - 撰 + - 聪 + - 鞋 + - 鞍 + - 蕉 + - 蕊 + - 蔬 + - 蕴 + - 横 + - 槽 + - 樱 + - 橡 + - 樟 + - 橄 + - 敷 + - 豌 + - 飘 + - 醋 + - 醇 + - 醉 + - 磕 + - 磊 + - 磅 + - 碾 + - 震 + - 霄 + - 霉 + - 瞒 + - 题 + - 暴 + - 瞎 + - 嘻 + - 嘶 + - 嘲 + - 嘹 + - 影 + - 踢 + - 踏 + - 踩 + - 踪 + - 蝶 + - 蝴 + - 蝠 + - 蝎 + - 蝌 + - 蝗 + - 蝙 + - 嘿 + - 嘱 + - 幢 + - 墨 + - 镇 + - 镐 + - 镑 + - 靠 + - 稽 + - 稻 + - 黎 + - 稿 + - 稼 + - 箱 + - 篓 + - 箭 + - 篇 + - 僵 + - 躺 + - 僻 + - 德 + - 艘 + - 膝 + - 膛 + - 鲤 + - 鲫 + - 熟 + - 摩 + - 褒 + - 瘪 + - 瘤 + - 瘫 + - 凛 + - 颜 + - 毅 + - 糊 + - 遵 + - 憋 + - 潜 + - 澎 + - 潮 + - 潭 + - 鲨 + - 澳 + - 潘 + - 澈 + - 澜 + - 澄 + - 懂 + - 憔 + - 懊 + - 憎 + - 额 + - 翩 + - 褥 + - 谴 + - 鹤 + - 憨 + - 慰 + - 劈 + - 履 + - 豫 + - 缭 + - 撼 + - 擂 + - 操 + - 擅 + - 燕 + - 蕾 + - 薯 + - 薛 + - 薇 + - 擎 + - 薪 + - 薄 + - 颠 + - 翰 + - 噩 + - 橱 + - 橙 + - 橘 + - 整 + - 融 + - 瓢 + - 醒 + - 霍 + - 霎 + - 辙 + - 冀 + - 餐 + - 嘴 + - 踱 + - 蹄 + - 蹂 + - 蟆 + - 螃 + - 器 + - 噪 + - 鹦 + - 赠 + - 默 + - 黔 + - 镜 + - 赞 + - 穆 + - 篮 + - 篡 + - 篷 + - 篱 + - 儒 + - 邀 + - 衡 + - 膨 + - 雕 + - 鲸 + - 磨 + - 瘾 + - 瘸 + - 凝 + - 辨 + - 辩 + - 糙 + - 糖 + - 糕 + - 燃 + - 濒 + - 澡 + - 激 + - 懒 + - 憾 + - 懈 + - 窿 + - 壁 + - 避 + - 缰 + - 缴 + - 戴 + - 擦 + - 藉 + - 鞠 + - 藏 + - 藐 + - 檬 + - 檐 + - 檀 + - 礁 + - 磷 + - 霜 + - 霞 + - 瞭 + - 瞧 + - 瞬 + - 瞳 + - 瞩 + - 瞪 + - 曙 + - 蹋 + - 蹈 + - 螺 + - 蟋 + - 蟀 + - 嚎 + - 赡 + - 穗 + - 魏 + - 簧 + - 簇 + - 繁 + - 徽 + - 爵 + - 朦 + - 臊 + - 鳄 + - 癌 + - 辫 + - 赢 + - 糟 + - 糠 + - 燥 + - 懦 + - 豁 + - 臀 + - 臂 + - 翼 + - 骤 + - 藕 + - 鞭 + - 藤 + - 覆 + - 瞻 + - 蹦 + - 嚣 + - 镰 + - 翻 + - 鳍 + - 鹰 + - 瀑 + - 襟 + - 璧 + - 戳 + - 孽 + - 警 + - 蘑 + - 藻 + - 攀 + - 曝 + - 蹲 + - 蹭 + - 蹬 + - 巅 + - 簸 + - 簿 + - 蟹 + - 颤 + - 靡 + - 癣 + - 瓣 + - 羹 + - 鳖 + - 爆 + - 疆 + - 鬓 + - 壤 + - 馨 + - 耀 + - 躁 + - 蠕 + - 嚼 + - 嚷 + - 巍 + - 籍 + - 鳞 + - 魔 + - 糯 + - 灌 + - 譬 + - 蠢 + - 霸 + - 露 + - 霹 + - 躏 + - 黯 + - 髓 + - 赣 + - 囊 + - 镶 + - 瓤 + - 罐 + - 矗 + - 乂 + - 乜 + - 兀 + - 弋 + - 孑 + - 孓 + - 幺 + - 亓 + - 韦 + - 廿 + - 丏 + - 卅 + - 仄 + - 厄 + - 仃 + - 仉 + - 仂 + - 兮 + - 刈 + - 爻 + - 卞 + - 闩 + - 讣 + - 尹 + - 夬 + - 爿 + - 毋 + - 邗 + - 邛 + - 艽 + - 艿 + - 札 + - 叵 + - 匝 + - 丕 + - 匜 + - 劢 + - 卟 + - 叱 + - 叻 + - 仨 + - 仕 + - 仟 + - 仡 + - 仫 + - 仞 + - 卮 + - 氐 + - 犰 + - 刍 + - 邝 + - 邙 + - 汀 + - 讦 + - 讧 + - 讪 + - 讫 + - 尻 + - 阡 + - 尕 + - 弁 + - 驭 + - 匡 + - 耒 + - 玎 + - 玑 + - 邢 + - 圩 + - 圬 + - 圭 + - 扦 + - 圪 + - 圳 + - 圹 + - 扪 + - 圮 + - 圯 + - 芊 + - 芍 + - 芄 + - 芨 + - 芑 + - 芎 + - 芗 + - 亘 + - 厍 + - 夼 + - 戍 + - 尥 + - 乩 + - 旯 + - 曳 + - 岌 + - 屺 + - 凼 + - 囡 + - 钇 + - 缶 + - 氘 + - 氖 + - 牝 + - 伎 + - 伛 + - 伢 + - 佤 + - 仵 + - 伥 + - 伧 + - 伉 + - 伫 + - 囟 + - 汆 + - 刖 + - 夙 + - 旮 + - 刎 + - 犷 + - 犸 + - 舛 + - 凫 + - 邬 + - 饧 + - 汕 + - 汔 + - 汐 + - 汲 + - 汜 + - 汊 + - 忖 + - 忏 + - 讴 + - 讵 + - 祁 + - 讷 + - 聿 + - 艮 + - 厾 + - 阱 + - 阮 + - 阪 + - 丞 + - 妁 + - 牟 + - 纡 + - 纣 + - 纥 + - 纨 + - 玕 + - 玙 + - 抟 + - 抔 + - 圻 + - 坂 + - 坍 + - 坞 + - 抃 + - 抉 + - 㧐 + - 芫 + - 邯 + - 芸 + - 芾 + - 苈 + - 苣 + - 芷 + - 芮 + - 苋 + - 芼 + - 苌 + - 苁 + - 芩 + - 芪 + - 芡 + - 芟 + - 苄 + - 苎 + - 苡 + - 杌 + - 杓 + - 杞 + - 杈 + - 忑 + - 孛 + - 邴 + - 邳 + - 矶 + - 奁 + - 豕 + - 忒 + - 欤 + - 轫 + - 迓 + - 邶 + - 忐 + - 卣 + - 邺 + - 旰 + - 呋 + - 呒 + - 呓 + - 呔 + - 呖 + - 呃 + - 旸 + - 吡 + - 町 + - 虬 + - 呗 + - 吽 + - 吣 + - 吲 + - 帏 + - 岐 + - 岈 + - 岘 + - 岑 + - 岚 + - 兕 + - 囵 + - 囫 + - 钊 + - 钋 + - 钌 + - 迕 + - 氙 + - 氚 + - 牤 + - 佞 + - 邱 + - 攸 + - 佚 + - 佝 + - 佟 + - 佗 + - 伽 + - 彷 + - 佘 + - 佥 + - 孚 + - 豸 + - 坌 + - 肟 + - 邸 + - 奂 + - 劬 + - 狄 + - 狁 + - 鸠 + - 邹 + - 饨 + - 饩 + - 饪 + - 饫 + - 饬 + - 亨 + - 庑 + - 庋 + - 疔 + - 疖 + - 肓 + - 闱 + - 闳 + - 闵 + - 羌 + - 炀 + - 沣 + - 沅 + - 沔 + - 沤 + - 沌 + - 沏 + - 沚 + - 汩 + - 汨 + - 沂 + - 汾 + - 沨 + - 汴 + - 汶 + - 沆 + - 沩 + - 泐 + - 怃 + - 怄 + - 忡 + - 忤 + - 忾 + - 怅 + - 忻 + - 忪 + - 怆 + - 忭 + - 忸 + - 诂 + - 诃 + - 诅 + - 诋 + - 诌 + - 诏 + - 诒 + - 孜 + - 陇 + - 陀 + - 陂 + - 陉 + - 妍 + - 妩 + - 妪 + - 妣 + - 妊 + - 妗 + - 妫 + - 妞 + - 姒 + - 妤 + - 邵 + - 劭 + - 刭 + - 甬 + - 邰 + - 纭 + - 纰 + - 纴 + - 纶 + - 纾 + - 玮 + - 玡 + - 玭 + - 玠 + - 玢 + - 玥 + - 玦 + - 盂 + - 忝 + - 匦 + - 坩 + - 抨 + - 拤 + - 坫 + - 拈 + - 垆 + - 抻 + - 劼 + - 拃 + - 拊 + - 坼 + - 坻 + - 㧟 + - 坨 + - 坭 + - 抿 + - 坳 + - 耶 + - 苷 + - 苯 + - 苤 + - 茏 + - 苫 + - 苜 + - 苴 + - 苒 + - 苘 + - 茌 + - 苻 + - 苓 + - 茚 + - 茆 + - 茑 + - 茓 + - 茔 + - 茕 + - 茀 + - 苕 + - 枥 + - 枇 + - 杪 + - 杳 + - 枧 + - 杵 + - 枨 + - 枞 + - 枋 + - 杻 + - 杷 + - 杼 + - 矸 + - 砀 + - 刳 + - 奄 + - 瓯 + - 殁 + - 郏 + - 轭 + - 郅 + - 鸢 + - 盱 + - 昊 + - 昙 + - 杲 + - 昃 + - 咂 + - 呸 + - 昕 + - 昀 + - 旻 + - 昉 + - 炅 + - 咔 + - 畀 + - 虮 + - 咀 + - 呷 + - 黾 + - 呱 + - 呤 + - 咚 + - 咆 + - 咛 + - 呶 + - 呣 + - 呦 + - 咝 + - 岢 + - 岿 + - 岬 + - 岫 + - 帙 + - 岣 + - 峁 + - 刿 + - 迥 + - 岷 + - 剀 + - 帔 + - 峄 + - 沓 + - 囹 + - 罔 + - 钍 + - 钎 + - 钏 + - 钒 + - 钕 + - 钗 + - 邾 + - 迮 + - 牦 + - 竺 + - 迤 + - 佶 + - 佬 + - 佰 + - 侑 + - 侉 + - 臾 + - 岱 + - 侗 + - 侃 + - 侏 + - 侩 + - 佻 + - 佾 + - 侪 + - 佼 + - 佯 + - 侬 + - 帛 + - 阜 + - 侔 + - 徂 + - 刽 + - 郄 + - 怂 + - 籴 + - 瓮 + - 戗 + - 肼 + - 䏝 + - 肽 + - 肱 + - 肫 + - 剁 + - 迩 + - 郇 + - 狙 + - 狎 + - 狍 + - 狒 + - 咎 + - 炙 + - 枭 + - 饯 + - 饴 + - 冽 + - 冼 + - 庖 + - 疠 + - 疝 + - 疡 + - 兖 + - 妾 + - 劾 + - 炜 + - 𬉼 + - 炖 + - 炘 + - 炝 + - 炔 + - 泔 + - 沭 + - 泷 + - 泸 + - 泱 + - 泅 + - 泗 + - 泠 + - 泺 + - 泖 + - 泫 + - 泮 + - 沱 + - 泯 + - 泓 + - 泾 + - 怙 + - 怵 + - 怦 + - 怛 + - 怏 + - 怍 + - 㤘 + - 怩 + - 怫 + - 怿 + - 宕 + - 穹 + - 宓 + - 诓 + - 诔 + - 诖 + - 诘 + - 戾 + - 诙 + - 戽 + - 郓 + - 衩 + - 祆 + - 祎 + - 祉 + - 祇 + - 诛 + - 诜 + - 诟 + - 诠 + - 诣 + - 诤 + - 诧 + - 诨 + - 诩 + - 戕 + - 孢 + - 亟 + - 陔 + - 妲 + - 妯 + - 姗 + - 帑 + - 弩 + - 孥 + - 驽 + - 虱 + - 迦 + - 迨 + - 绀 + - 绁 + - 绂 + - 驷 + - 驸 + - 绉 + - 绌 + - 驿 + - 骀 + - 甾 + - 珏 + - 珐 + - 珂 + - 珑 + - 玳 + - 珀 + - 顸 + - 珉 + - 珈 + - 拮 + - 垭 + - 挝 + - 垣 + - 挞 + - 垤 + - 赳 + - 贲 + - 垱 + - 垌 + - 郝 + - 垧 + - 垓 + - 挦 + - 垠 + - 茜 + - 荚 + - 荑 + - 贳 + - 荜 + - 莒 + - 茼 + - 茴 + - 茱 + - 莛 + - 荞 + - 茯 + - 荏 + - 荇 + - 荃 + - 荟 + - 荀 + - 茗 + - 荠 + - 茭 + - 茨 + - 垩 + - 荥 + - 荦 + - 荨 + - 荩 + - 剋 + - 荪 + - 茹 + - 荬 + - 荮 + - 柰 + - 栉 + - 柯 + - 柘 + - 栊 + - 柩 + - 枰 + - 栌 + - 柙 + - 枵 + - 柚 + - 枳 + - 柞 + - 柝 + - 栀 + - 柢 + - 栎 + - 枸 + - 柈 + - 柁 + - 枷 + - 柽 + - 剌 + - 酊 + - 郦 + - 甭 + - 砗 + - 砘 + - 砒 + - 斫 + - 砭 + - 砜 + - 奎 + - 耷 + - 虺 + - 殂 + - 殇 + - 殄 + - 殆 + - 轱 + - 轲 + - 轳 + - 轶 + - 轸 + - 虿 + - 毖 + - 觇 + - 尜 + - 哐 + - 眄 + - 眍 + - 𠳐 + - 郢 + - 眇 + - 眊 + - 眈 + - 禺 + - 哂 + - 咴 + - 曷 + - 昴 + - 昱 + - 昵 + - 咦 + - 哓 + - 哔 + - 畎 + - 毗 + - 呲 + - 胄 + - 畋 + - 畈 + - 虼 + - 虻 + - 盅 + - 咣 + - 哕 + - 剐 + - 郧 + - 咻 + - 囿 + - 咿 + - 哌 + - 哙 + - 哚 + - 咯 + - 咩 + - 咤 + - 哝 + - 哏 + - 哞 + - 峙 + - 峣 + - 罘 + - 帧 + - 峒 + - 峤 + - 峋 + - 峥 + - 贶 + - 钚 + - 钛 + - 钡 + - 钣 + - 钤 + - 钨 + - 钫 + - 钯 + - 氡 + - 氟 + - 牯 + - 郜 + - 秕 + - 秭 + - 竽 + - 笈 + - 笃 + - 俦 + - 俨 + - 俅 + - 俪 + - 叟 + - 垡 + - 牮 + - 俣 + - 俚 + - 皈 + - 俑 + - 俟 + - 逅 + - 徇 + - 徉 + - 舢 + - 俞 + - 郗 + - 俎 + - 郤 + - 爰 + - 郛 + - 瓴 + - 胨 + - 胪 + - 胛 + - 胂 + - 胙 + - 胍 + - 胗 + - 胝 + - 朐 + - 胫 + - 鸨 + - 匍 + - 狨 + - 狯 + - 飑 + - 狩 + - 狲 + - 訇 + - 逄 + - 昝 + - 饷 + - 饸 + - 饹 + - 胤 + - 孪 + - 娈 + - 弈 + - 奕 + - 庥 + - 疬 + - 疣 + - 疥 + - 疭 + - 庠 + - 竑 + - 彦 + - 飒 + - 闼 + - 闾 + - 闿 + - 阂 + - 羑 + - 迸 + - 籼 + - 酋 + - 炳 + - 炻 + - 炽 + - 炯 + - 烀 + - 炷 + - 烃 + - 洱 + - 洹 + - 洧 + - 洌 + - 浃 + - 洇 + - 洄 + - 洙 + - 涎 + - 洎 + - 洫 + - 浍 + - 洮 + - 洵 + - 浒 + - 浔 + - 浕 + - 洳 + - 恸 + - 恓 + - 恹 + - 恫 + - 恺 + - 恻 + - 恂 + - 恪 + - 恽 + - 宥 + - 扃 + - 衲 + - 衽 + - 衿 + - 袂 + - 祛 + - 祜 + - 祓 + - 祚 + - 诮 + - 祗 + - 祢 + - 诰 + - 诳 + - 鸩 + - 昶 + - 郡 + - 咫 + - 弭 + - 牁 + - 胥 + - 陛 + - 陟 + - 娅 + - 姮 + - 娆 + - 姝 + - 姣 + - 姘 + - 姹 + - 怼 + - 羿 + - 炱 + - 矜 + - 绔 + - 骁 + - 骅 + - 绗 + - 绛 + - 骈 + - 耖 + - 挈 + - 珥 + - 珙 + - 顼 + - 珰 + - 珩 + - 珧 + - 珣 + - 珞 + - 琤 + - 珲 + - 敖 + - 恚 + - 埔 + - 埕 + - 埘 + - 埙 + - 埚 + - 挹 + - 耆 + - 耄 + - 埒 + - 捋 + - 贽 + - 垸 + - 捃 + - 盍 + - 荸 + - 莆 + - 莳 + - 莴 + - 莪 + - 莠 + - 莓 + - 莜 + - 莅 + - 荼 + - 莩 + - 荽 + - 莸 + - 荻 + - 莘 + - 莎 + - 莞 + - 莨 + - 渇 + - 鸪 + - 莼 + - 栲 + - 栳 + - 郴 + - 桓 + - 桡 + - 桎 + - 桢 + - 桤 + - 梃 + - 栝 + - 桕 + - 桁 + - 桧 + - 桅 + - 栟 + - 桉 + - 栩 + - 逑 + - 逋 + - 彧 + - 鬲 + - 豇 + - 酐 + - 逦 + - 厝 + - 孬 + - 砝 + - 砹 + - 砺 + - 砧 + - 砷 + - 砟 + - 砼 + - 砥 + - 砣 + - 剞 + - 砻 + - 轼 + - 轾 + - 辂 + - 鸫 + - 趸 + - 龀 + - 鸬 + - 虔 + - 逍 + - 眬 + - 唛 + - 晟 + - 眩 + - 眙 + - 哧 + - 哽 + - 唔 + - 晁 + - 晏 + - 鸮 + - 趵 + - 趿 + - 畛 + - 蚨 + - 蚜 + - 蚍 + - 蚋 + - 蚬 + - 蚝 + - 蚧 + - 唢 + - 圄 + - 唣 + - 唏 + - 盎 + - 唑 + - 崂 + - 崃 + - 罡 + - 罟 + - 峪 + - 觊 + - 赅 + - 钰 + - 钲 + - 钴 + - 钵 + - 钹 + - 钺 + - 钽 + - 钼 + - 钿 + - 铀 + - 铂 + - 铄 + - 铆 + - 铈 + - 铉 + - 铊 + - 铋 + - 铌 + - 铍 + - 䥽 + - 铎 + - 氩 + - 氤 + - 氦 + - 毪 + - 舐 + - 秣 + - 秫 + - 盉 + - 笄 + - 笕 + - 笊 + - 笏 + - 笆 + - 俸 + - 倩 + - 俵 + - 偌 + - 俳 + - 俶 + - 倬 + - 倏 + - 恁 + - 倭 + - 倪 + - 俾 + - 倜 + - 隼 + - 隽 + - 倌 + - 倥 + - 臬 + - 皋 + - 郫 + - 倨 + - 衄 + - 颀 + - 徕 + - 舫 + - 釜 + - 奚 + - 衾 + - 胯 + - 胱 + - 胴 + - 胭 + - 脍 + - 胼 + - 朕 + - 脒 + - 胺 + - 鸱 + - 玺 + - 鸲 + - 狷 + - 猁 + - 狳 + - 猃 + - 狺 + - 逖 + - 桀 + - 袅 + - 饽 + - 凇 + - 栾 + - 挛 + - 亳 + - 疳 + - 疴 + - 疸 + - 疽 + - 痈 + - 疱 + - 痂 + - 痉 + - 衮 + - 凋 + - 颃 + - 恣 + - 旆 + - 旄 + - 旃 + - 阃 + - 阄 + - 訚 + - 阆 + - 恙 + - 粑 + - 朔 + - 郸 + - 烜 + - 烨 + - 烩 + - 烊 + - 剡 + - 郯 + - 烬 + - 涑 + - 浯 + - 涞 + - 涟 + - 娑 + - 涅 + - 涠 + - 浞 + - 涓 + - 浥 + - 涔 + - 浜 + - 浠 + - 浣 + - 浚 + - 悚 + - 悭 + - 悝 + - 悒 + - 悌 + - 悛 + - 宸 + - 窈 + - 剜 + - 诹 + - 冢 + - 诼 + - 袒 + - 袢 + - 祯 + - 诿 + - 谀 + - 谂 + - 谄 + - 谇 + - 屐 + - 屙 + - 陬 + - 勐 + - 奘 + - 牂 + - 蚩 + - 陲 + - 姬 + - 娠 + - 娌 + - 娉 + - 娲 + - 娩 + - 娴 + - 娣 + - 娓 + - 婀 + - 畚 + - 逡 + - 绠 + - 骊 + - 绡 + - 骋 + - 绥 + - 绦 + - 绨 + - 骎 + - 邕 + - 鸶 + - 彗 + - 耜 + - 焘 + - 舂 + - 琏 + - 琇 + - 麸 + - 揶 + - 埴 + - 埯 + - 捯 + - 掳 + - 掴 + - 埸 + - 埵 + - 赧 + - 埤 + - 捭 + - 逵 + - 埝 + - 堋 + - 堍 + - 掬 + - 鸷 + - 掖 + - 捽 + - 掊 + - 堉 + - 掸 + - 捩 + - 掮 + - 悫 + - 埭 + - 埽 + - 掇 + - 掼 + - 聃 + - 菁 + - 萁 + - 菘 + - 堇 + - 萘 + - 萋 + - 菽 + - 菖 + - 萜 + - 萸 + - 萑 + - 棻 + - 菔 + - 菟 + - 萏 + - 萃 + - 菏 + - 菹 + - 菪 + - 菅 + - 菀 + - 萦 + - 菰 + - 菡 + - 梵 + - 梿 + - 梏 + - 觋 + - 桴 + - 桷 + - 梓 + - 棁 + - 桫 + - 棂 + - 啬 + - 郾 + - 匮 + - 敕 + - 豉 + - 鄄 + - 酞 + - 酚 + - 戛 + - 硎 + - 硭 + - 硒 + - 硖 + - 硗 + - 硐 + - 硇 + - 硌 + - 鸸 + - 瓠 + - 匏 + - 厩 + - 龚 + - 殒 + - 殓 + - 殍 + - 赉 + - 雩 + - 辄 + - 堑 + - 眭 + - 眦 + - 啧 + - 晡 + - 晤 + - 眺 + - 眵 + - 眸 + - 圊 + - 喏 + - 喵 + - 啉 + - 勖 + - 晞 + - 唵 + - 晗 + - 冕 + - 啭 + - 畦 + - 趺 + - 啮 + - 跄 + - 蚶 + - 蛄 + - 蛎 + - 蛆 + - 蚰 + - 蛊 + - 圉 + - 蚱 + - 蛉 + - 蛏 + - 蚴 + - 啁 + - 啕 + - 唿 + - 啐 + - 唼 + - 唷 + - 啖 + - 啵 + - 啶 + - 啷 + - 唳 + - 唰 + - 啜 + - 帻 + - 崚 + - 崦 + - 帼 + - 崮 + - 崤 + - 崆 + - 赇 + - 赈 + - 赊 + - 铑 + - 铒 + - 铗 + - 铙 + - 铟 + - 铠 + - 铡 + - 铢 + - 铣 + - 铤 + - 铧 + - 铨 + - 铩 + - 铪 + - 铫 + - 铬 + - 铮 + - 铯 + - 铰 + - 铱 + - 铳 + - 铵 + - 铷 + - 氪 + - 牾 + - 鸹 + - 秾 + - 逶 + - 笺 + - 筇 + - 笸 + - 笪 + - 笮 + - 笠 + - 笥 + - 笤 + - 笳 + - 笾 + - 笞 + - 偾 + - 偃 + - 偕 + - 偈 + - 傀 + - 偬 + - 偻 + - 皑 + - 皎 + - 鸻 + - 徜 + - 舸 + - 舻 + - 舴 + - 舷 + - 龛 + - 翎 + - 脬 + - 脘 + - 脲 + - 匐 + - 猗 + - 猡 + - 猞 + - 猝 + - 斛 + - 猕 + - 馗 + - 馃 + - 馄 + - 鸾 + - 孰 + - 庹 + - 庾 + - 痔 + - 痍 + - 疵 + - 翊 + - 旌 + - 旎 + - 袤 + - 阇 + - 阈 + - 阉 + - 阊 + - 阋 + - 阍 + - 阏 + - 羟 + - 粝 + - 粕 + - 敝 + - 焐 + - 烯 + - 焓 + - 烽 + - 焖 + - 烷 + - 焗 + - 渍 + - 渚 + - 淇 + - 淅 + - 淞 + - 渎 + - 涿 + - 淖 + - 挲 + - 淠 + - 涸 + - 渑 + - 淦 + - 淝 + - 淬 + - 涪 + - 淙 + - 涫 + - 渌 + - 淄 + - 惬 + - 悻 + - 悱 + - 惝 + - 惘 + - 悸 + - 惆 + - 惚 + - 惇 + - 惮 + - 窕 + - 谌 + - 谏 + - 扈 + - 皲 + - 谑 + - 裆 + - 袷 + - 裉 + - 谒 + - 谔 + - 谕 + - 谖 + - 谗 + - 谙 + - 谛 + - 谝 + - 逯 + - 郿 + - 隈 + - 粜 + - 隍 + - 隗 + - 婧 + - 婊 + - 婕 + - 娼 + - 婢 + - 婵 + - 胬 + - 袈 + - 翌 + - 恿 + - 欸 + - 绫 + - 骐 + - 绮 + - 绯 + - 绱 + - 骒 + - 绲 + - 骓 + - 绶 + - 绺 + - 绻 + - 绾 + - 骖 + - 缁 + - 耠 + - 琫 + - 琵 + - 琶 + - 琪 + - 瑛 + - 琦 + - 琥 + - 琨 + - 靓 + - 琰 + - 琮 + - 琯 + - 琬 + - 琛 + - 琚 + - 辇 + - 鼋 + - 揳 + - 堞 + - 搽 + - 揸 + - 揠 + - 堙 + - 趄 + - 揖 + - 颉 + - 塄 + - 揿 + - 耋 + - 揄 + - 蛩 + - 蛰 + - 塆 + - 摒 + - 揆 + - 掾 + - 聒 + - 葑 + - 葚 + - 靰 + - 靸 + - 葳 + - 葺 + - 葸 + - 萼 + - 葆 + - 葩 + - 葶 + - 蒌 + - 萱 + - 戟 + - 葭 + - 楮 + - 棼 + - 椟 + - 棹 + - 椤 + - 棰 + - 赍 + - 椋 + - 椁 + - 椪 + - 棣 + - 椐 + - 鹁 + - 覃 + - 酤 + - 酢 + - 酡 + - 鹂 + - 厥 + - 殚 + - 殛 + - 雯 + - 雱 + - 辊 + - 辋 + - 椠 + - 辍 + - 辎 + - 斐 + - 睄 + - 睑 + - 睇 + - 睃 + - 戢 + - 喋 + - 嗒 + - 喃 + - 喱 + - 喹 + - 晷 + - 喈 + - 跖 + - 跗 + - 跞 + - 跚 + - 跎 + - 跏 + - 跆 + - 蛱 + - 蛲 + - 蛭 + - 蛳 + - 蛐 + - 蛔 + - 蛞 + - 蛴 + - 蛟 + - 蛘 + - 喁 + - 喟 + - 啾 + - 嗖 + - 喑 + - 嗟 + - 喽 + - 嗞 + - 喀 + - 喔 + - 喙 + - 嵘 + - 嵖 + - 崴 + - 遄 + - 詈 + - 嵎 + - 崽 + - 嵬 + - 嵛 + - 嵯 + - 嵝 + - 嵫 + - 幄 + - 嵋 + - 赕 + - 铻 + - 铼 + - 铿 + - 锃 + - 锂 + - 锆 + - 锇 + - 锉 + - 锏 + - 锑 + - 锒 + - 锔 + - 锕 + - 掣 + - 矬 + - 氰 + - 毳 + - 毽 + - 犊 + - 犄 + - 犋 + - 鹄 + - 犍 + - 嵇 + - 黍 + - 稃 + - 稂 + - 筚 + - 筵 + - 筌 + - 傣 + - 傈 + - 舄 + - 牍 + - 傥 + - 傧 + - 遑 + - 傩 + - 遁 + - 徨 + - 媭 + - 畲 + - 弑 + - 颌 + - 翕 + - 釉 + - 鹆 + - 舜 + - 貂 + - 腈 + - 腌 + - 腓 + - 腆 + - 腴 + - 腑 + - 腚 + - 腱 + - 鱿 + - 鲀 + - 鲂 + - 颍 + - 猢 + - 猹 + - 猥 + - 飓 + - 觞 + - 觚 + - 猱 + - 颎 + - 飧 + - 馇 + - 馊 + - 亵 + - 脔 + - 裒 + - 痣 + - 痨 + - 痦 + - 痞 + - 痤 + - 痫 + - 痧 + - 赓 + - 竦 + - 瓿 + - 啻 + - 颏 + - 鹇 + - 阑 + - 阒 + - 阕 + - 粞 + - 遒 + - 孳 + - 焯 + - 焜 + - 焙 + - 焱 + - 鹈 + - 湛 + - 渫 + - 湮 + - 湎 + - 湜 + - 渭 + - 湍 + - 湫 + - 溲 + - 湟 + - 溆 + - 湲 + - 湔 + - 湉 + - 渥 + - 湄 + - 滁 + - 愠 + - 惺 + - 愦 + - 惴 + - 愀 + - 愎 + - 愔 + - 喾 + - 寐 + - 谟 + - 扉 + - 裢 + - 裎 + - 裥 + - 祾 + - 祺 + - 谠 + - 幂 + - 谡 + - 谥 + - 谧 + - 遐 + - 孱 + - 弼 + - 巽 + - 骘 + - 媪 + - 媛 + - 婷 + - 巯 + - 翚 + - 皴 + - 婺 + - 骛 + - 缂 + - 缃 + - 缄 + - 彘 + - 缇 + - 缈 + - 缌 + - 缑 + - 缒 + - 缗 + - 飨 + - 耢 + - 瑚 + - 瑁 + - 瑜 + - 瑗 + - 瑄 + - 瑕 + - 遨 + - 骜 + - 韫 + - 髡 + - 塬 + - 鄢 + - 趔 + - 趑 + - 摅 + - 摁 + - 蜇 + - 搋 + - 搪 + - 搐 + - 搛 + - 搠 + - 摈 + - 彀 + - 毂 + - 搦 + - 搡 + - 蓁 + - 戡 + - 蓍 + - 鄞 + - 靳 + - 蓐 + - 蓦 + - 鹋 + - 蒽 + - 蓓 + - 蓖 + - 蓊 + - 蒯 + - 蓟 + - 蓑 + - 蒿 + - 蒺 + - 蓠 + - 蒟 + - 蒡 + - 蒹 + - 蒴 + - 蒗 + - 蓥 + - 颐 + - 楔 + - 楠 + - 楂 + - 楝 + - 楫 + - 楸 + - 椴 + - 槌 + - 楯 + - 皙 + - 榈 + - 槎 + - 榉 + - 楦 + - 楣 + - 楹 + - 椽 + - 裘 + - 剽 + - 甄 + - 酮 + - 酰 + - 酯 + - 酩 + - 蜃 + - 碛 + - 碓 + - 硼 + - 碉 + - 碚 + - 碇 + - 碜 + - 鹌 + - 辏 + - 龃 + - 龅 + - 訾 + - 粲 + - 虞 + - 睚 + - 嗪 + - 韪 + - 嗷 + - 嗉 + - 睨 + - 睢 + - 雎 + - 睥 + - 嘟 + - 嗑 + - 嗫 + - 嗬 + - 嗔 + - 嗝 + - 戥 + - 嗄 + - 煦 + - 暄 + - 遢 + - 暌 + - 跬 + - 跶 + - 跸 + - 跐 + - 跣 + - 跹 + - 跻 + - 蛸 + - 蜊 + - 蜍 + - 蜉 + - 蜣 + - 畹 + - 蛹 + - 嗣 + - 嗯 + - 嗥 + - 嗲 + - 嗳 + - 嗌 + - 嗍 + - 嗨 + - 嗐 + - 嗤 + - 嗵 + - 罨 + - 嵊 + - 嵩 + - 嵴 + - 骰 + - 锗 + - 锛 + - 锜 + - 锝 + - 锞 + - 锟 + - 锢 + - 锨 + - 锩 + - 锭 + - 锱 + - 雉 + - 氲 + - 犏 + - 歃 + - 稞 + - 稗 + - 稔 + - 筠 + - 筢 + - 筮 + - 筲 + - 筱 + - 牒 + - 煲 + - 敫 + - 徭 + - 愆 + - 艄 + - 觎 + - 毹 + - 貊 + - 貅 + - 貉 + - 颔 + - 腠 + - 腩 + - 腼 + - 腭 + - 腧 + - 塍 + - 媵 + - 詹 + - 鲅 + - 鲆 + - 鲇 + - 鲈 + - 稣 + - 鲋 + - 鲐 + - 肄 + - 鹐 + - 飕 + - 觥 + - 遛 + - 馐 + - 鹑 + - 亶 + - 瘃 + - 痱 + - 痼 + - 痿 + - 瘐 + - 瘁 + - 瘆 + - 麂 + - 裔 + - 歆 + - 旒 + - 雍 + - 阖 + - 阗 + - 阙 + - 羧 + - 豢 + - 粳 + - 猷 + - 煳 + - 煜 + - 煨 + - 煅 + - 煊 + - 煸 + - 煺 + - 滟 + - 溱 + - 溘 + - 漭 + - 滢 + - 溥 + - 溧 + - 溽 + - 裟 + - 溻 + - 溷 + - 滗 + - 滫 + - 溴 + - 滏 + - 滃 + - 滦 + - 溏 + - 滂 + - 滓 + - 溟 + - 滪 + - 愫 + - 慑 + - 慊 + - 鲎 + - 骞 + - 窦 + - 窠 + - 窣 + - 裱 + - 褚 + - 裨 + - 裾 + - 裰 + - 禊 + - 谩 + - 谪 + - 媾 + - 嫫 + - 媲 + - 嫒 + - 嫔 + - 媸 + - 缙 + - 缜 + - 缛 + - 辔 + - 骝 + - 缟 + - 缡 + - 缢 + - 缣 + - 骟 + - 耥 + - 璈 + - 瑶 + - 瑭 + - 獒 + - 觏 + - 慝 + - 嫠 + - 韬 + - 叆 + - 髦 + - 摽 + - 墁 + - 撂 + - 摞 + - 撄 + - 翥 + - 踅 + - 摭 + - 墉 + - 墒 + - 榖 + - 綦 + - 蔫 + - 蔷 + - 靺 + - 靼 + - 鞅 + - 靿 + - 甍 + - 蔸 + - 蔟 + - 蔺 + - 戬 + - 蕖 + - 蔻 + - 蓿 + - 斡 + - 鹕 + - 蓼 + - 榛 + - 榧 + - 榻 + - 榫 + - 榭 + - 槔 + - 榱 + - 槁 + - 槟 + - 槠 + - 榷 + - 僰 + - 酽 + - 酶 + - 酹 + - 厮 + - 碡 + - 碴 + - 碣 + - 碲 + - 磋 + - 臧 + - 豨 + - 殡 + - 霆 + - 霁 + - 辕 + - 蜚 + - 裴 + - 翡 + - 龇 + - 龈 + - 睿 + - 䁖 + - 睽 + - 嘞 + - 嘈 + - 嘌 + - 嘁 + - 嘎 + - 暧 + - 暝 + - 踌 + - 踉 + - 蜞 + - 蜥 + - 蜮 + - 蝈 + - 蜴 + - 蜱 + - 蜩 + - 蜷 + - 蜿 + - 螂 + - 蜢 + - 嘘 + - 嘡 + - 鹗 + - 嘣 + - 嘤 + - 嘚 + - 嗾 + - 嘧 + - 罴 + - 罱 + - 幔 + - 嶂 + - 幛 + - 赙 + - 罂 + - 骷 + - 骶 + - 鹘 + - 锲 + - 锴 + - 锶 + - 锷 + - 锸 + - 锵 + - 镁 + - 镂 + - 犒 + - 箐 + - 箦 + - 箧 + - 箍 + - 箸 + - 箬 + - 箅 + - 箪 + - 箔 + - 箜 + - 箢 + - 箓 + - 毓 + - 僖 + - 儆 + - 僳 + - 僭 + - 劁 + - 僮 + - 魃 + - 魆 + - 睾 + - 艋 + - 鄱 + - 膈 + - 膑 + - 鲑 + - 鲔 + - 鲚 + - 鲛 + - 鲟 + - 獐 + - 觫 + - 雒 + - 夤 + - 馑 + - 銮 + - 塾 + - 麽 + - 瘌 + - 瘊 + - 瘘 + - 瘙 + - 廖 + - 韶 + - 旖 + - 膂 + - 阚 + - 鄯 + - 鲞 + - 粿 + - 粼 + - 粽 + - 糁 + - 槊 + - 鹚 + - 熘 + - 熥 + - 潢 + - 漕 + - 滹 + - 漯 + - 漶 + - 潋 + - 潴 + - 漪 + - 漉 + - 漳 + - 漩 + - 澉 + - 潍 + - 慵 + - 搴 + - 窨 + - 寤 + - 綮 + - 谮 + - 褡 + - 褙 + - 褓 + - 褛 + - 褊 + - 谯 + - 谰 + - 谲 + - 暨 + - 屣 + - 鹛 + - 嫣 + - 嫱 + - 嫖 + - 嫦 + - 嫚 + - 嫘 + - 嫡 + - 鼐 + - 翟 + - 瞀 + - 鹜 + - 骠 + - 缥 + - 缦 + - 缧 + - 缨 + - 骢 + - 缪 + - 缫 + - 耦 + - 耧 + - 瑾 + - 璜 + - 璀 + - 璎 + - 璁 + - 璋 + - 璇 + - 奭 + - 髯 + - 髫 + - 撷 + - 撅 + - 赭 + - 撸 + - 鋆 + - 撙 + - 撺 + - 墀 + - 聩 + - 觐 + - 鞑 + - 蕙 + - 鞒 + - 蕈 + - 蕨 + - 蕤 + - 蕞 + - 蕺 + - 瞢 + - 蕃 + - 蕲 + - 赜 + - 槿 + - 樯 + - 槭 + - 樗 + - 樘 + - 樊 + - 槲 + - 醌 + - 醅 + - 靥 + - 魇 + - 餍 + - 磔 + - 磙 + - 霈 + - 辘 + - 龉 + - 龊 + - 觑 + - 瞌 + - 瞋 + - 瞑 + - 嘭 + - 噎 + - 噶 + - 颙 + - 暹 + - 噘 + - 踔 + - 踝 + - 踟 + - 踒 + - 踬 + - 踮 + - 踯 + - 踺 + - 踞 + - 蝽 + - 蝾 + - 蝻 + - 蝰 + - 蝮 + - 螋 + - 蝓 + - 蝣 + - 蝼 + - 噗 + - 嘬 + - 颚 + - 噍 + - 噢 + - 噙 + - 噜 + - 噌 + - 噔 + - 颛 + - 幞 + - 幡 + - 嶙 + - 嶝 + - 骺 + - 骼 + - 骸 + - 镊 + - 镉 + - 镌 + - 镍 + - 镏 + - 镒 + - 镓 + - 镔 + - 稷 + - 箴 + - 篑 + - 篁 + - 篌 + - 篆 + - 牖 + - 儋 + - 徵 + - 磐 + - 虢 + - 鹞 + - 膘 + - 滕 + - 鲠 + - 鲡 + - 鲢 + - 鲣 + - 鲥 + - 鲧 + - 鲩 + - 獗 + - 獠 + - 觯 + - 馓 + - 馔 + - 麾 + - 廛 + - 瘛 + - 瘼 + - 瘢 + - 瘠 + - 齑 + - 羯 + - 羰 + - 𥻗 + - 遴 + - 糌 + - 糍 + - 糅 + - 熜 + - 熵 + - 熠 + - 澍 + - 澌 + - 潸 + - 潦 + - 潲 + - 鋈 + - 潟 + - 潼 + - 潺 + - 憬 + - 憧 + - 寮 + - 窳 + - 谳 + - 褴 + - 褟 + - 褫 + - 谵 + - 熨 + - 屦 + - 嬉 + - 勰 + - 戮 + - 蝥 + - 缬 + - 缮 + - 缯 + - 骣 + - 畿 + - 耩 + - 耨 + - 耪 + - 璞 + - 璟 + - 靛 + - 璠 + - 璘 + - 聱 + - 螯 + - 髻 + - 髭 + - 髹 + - 擀 + - 熹 + - 甏 + - 擞 + - 縠 + - 磬 + - 颞 + - 蕻 + - 鞘 + - 颟 + - 薤 + - 薨 + - 檠 + - 薏 + - 薮 + - 薜 + - 薅 + - 樾 + - 橛 + - 橇 + - 樵 + - 檎 + - 橹 + - 樽 + - 樨 + - 橼 + - 墼 + - 橐 + - 翮 + - 醛 + - 醐 + - 醍 + - 醚 + - 磲 + - 赝 + - 飙 + - 殪 + - 霖 + - 霏 + - 霓 + - 錾 + - 辚 + - 臻 + - 遽 + - 氅 + - 瞟 + - 瞠 + - 瞰 + - 嚄 + - 嚆 + - 噤 + - 暾 + - 蹀 + - 踹 + - 踵 + - 踽 + - 蹉 + - 蹁 + - 螨 + - 蟒 + - 螈 + - 螅 + - 螭 + - 螠 + - 螟 + - 噱 + - 噬 + - 噫 + - 噻 + - 噼 + - 罹 + - 圜 + - 䦃 + - 镖 + - 镗 + - 镘 + - 镚 + - 镛 + - 镝 + - 镞 + - 镠 + - 氇 + - 氆 + - 憩 + - 穑 + - 篝 + - 篥 + - 篦 + - 篪 + - 篙 + - 盥 + - 劓 + - 翱 + - 魉 + - 魈 + - 徼 + - 歙 + - 膳 + - 膦 + - 膙 + - 鲮 + - 鲱 + - 鲲 + - 鲳 + - 鲴 + - 鲵 + - 鲷 + - 鲻 + - 獴 + - 獭 + - 獬 + - 邂 + - 鹧 + - 廨 + - 赟 + - 瘰 + - 廪 + - 瘿 + - 瘵 + - 瘴 + - 癃 + - 瘳 + - 斓 + - 麇 + - 麈 + - 嬴 + - 壅 + - 羲 + - 糗 + - 瞥 + - 甑 + - 燎 + - 燠 + - 燔 + - 燧 + - 濑 + - 濉 + - 潞 + - 澧 + - 澹 + - 澥 + - 澶 + - 濂 + - 褰 + - 寰 + - 窸 + - 褶 + - 禧 + - 嬖 + - 犟 + - 隰 + - 嬗 + - 颡 + - 缱 + - 缲 + - 缳 + - 璨 + - 璩 + - 璐 + - 璪 + - 螫 + - 擤 + - 壕 + - 觳 + - 罄 + - 擢 + - 薹 + - 鞡 + - 鞬 + - 薷 + - 薰 + - 藓 + - 藁 + - 檄 + - 檩 + - 懋 + - 醢 + - 翳 + - 礅 + - 磴 + - 鹩 + - 龋 + - 龌 + - 豳 + - 壑 + - 黻 + - 嚏 + - 嚅 + - 蹑 + - 蹒 + - 蹊 + - 蟥 + - 螬 + - 螵 + - 疃 + - 螳 + - 蟑 + - 嚓 + - 羁 + - 罽 + - 罾 + - 嶷 + - 黜 + - 黝 + - 髁 + - 髀 + - 镡 + - 镢 + - 镣 + - 镦 + - 镧 + - 镩 + - 镪 + - 镫 + - 罅 + - 黏 + - 簌 + - 篾 + - 篼 + - 簖 + - 簋 + - 鼢 + - 黛 + - 儡 + - 鹪 + - 鼾 + - 皤 + - 魍 + - 龠 + - 繇 + - 貘 + - 邈 + - 貔 + - 臌 + - 膻 + - 臆 + - 臃 + - 鲼 + - 鲽 + - 鳀 + - 鳃 + - 鳅 + - 鳇 + - 鳊 + - 螽 + - 燮 + - 鹫 + - 襄 + - 糜 + - 縻 + - 膺 + - 癍 + - 麋 + - 懑 + - 濡 + - 濮 + - 濞 + - 濠 + - 濯 + - 蹇 + - 謇 + - 邃 + - 襁 + - 檗 + - 擘 + - 孺 + - 隳 + - 嬷 + - 蟊 + - 鹬 + - 鍪 + - 鏊 + - 鳌 + - 鬈 + - 鬃 + - 瞽 + - 鞯 + - 鞨 + - 鞫 + - 鞧 + - 鞣 + - 藜 + - 藠 + - 藩 + - 醪 + - 蹙 + - 礓 + - 燹 + - 餮 + - 瞿 + - 曛 + - 颢 + - 曜 + - 躇 + - 蹚 + - 鹭 + - 蟛 + - 蟪 + - 蟠 + - 蟮 + - 鹮 + - 黠 + - 黟 + - 髅 + - 髂 + - 镬 + - 镭 + - 镯 + - 馥 + - 簟 + - 簪 + - 鼬 + - 雠 + - 艟 + - 鳎 + - 鳏 + - 鳐 + - 癞 + - 癔 + - 癜 + - 癖 + - 糨 + - 蹩 + - 鎏 + - 懵 + - 彝 + - 邋 + - 鬏 + - 攉 + - 攒 + - 鞲 + - 鞴 + - 藿 + - 蘧 + - 蘅 + - 麓 + - 醮 + - 醯 + - 酃 + - 霪 + - 霭 + - 霨 + - 黼 + - 嚯 + - 蹰 + - 蹶 + - 蹽 + - 蹼 + - 蹴 + - 蹾 + - 蹿 + - 蠖 + - 蠓 + - 蟾 + - 蠊 + - 黢 + - 髋 + - 髌 + - 镲 + - 籀 + - 籁 + - 齁 + - 魑 + - 艨 + - 鳓 + - 鳔 + - 鳕 + - 鳗 + - 鳙 + - 麒 + - 鏖 + - 羸 + - 㸆 + - 瀚 + - 瀣 + - 瀛 + - 襦 + - 谶 + - 襞 + - 骥 + - 缵 + - 瓒 + - 攘 + - 蘩 + - 蘖 + - 醴 + - 霰 + - 酆 + - 矍 + - 曦 + - 躅 + - 鼍 + - 巉 + - 黩 + - 黥 + - 黪 + - 镳 + - 镴 + - 黧 + - 纂 + - 璺 + - 鼯 + - 臜 + - 鳜 + - 鳝 + - 鳟 + - 獾 + - 孀 + - 骧 + - 瓘 + - 鼙 + - 醺 + - 礴 + - 颦 + - 曩 + - 鳢 + - 癫 + - 麝 + - 夔 + - 爝 + - 灏 + - 禳 + - 鐾 + - 羼 + - 蠡 + - 耱 + - 懿 + - 蘸 + - 鹳 + - 霾 + - 氍 + - 饕 + - 躐 + - 髑 + - 镵 + - 穰 + - 饔 + - 鬻 + - 鬟 + - 趱 + - 攫 + - 攥 + - 颧 + - 躜 + - 鼹 + - 癯 + - 麟 + - 蠲 + - 蠹 + - 躞 + - 衢 + - 鑫 + - 灞 + - 襻 + - 纛 + - 鬣 + - 攮 + - 囔 + - 馕 + - 戆 + - 爨 + - 齉 + - 亍 + - 尢 + - 彳 + - 卬 + - 殳 + - 𠙶 + - 毌 + - 邘 + - 戋 + - 圢 + - 氕 + - 伋 + - 仝 + - 冮 + - 氿 + - 汈 + - 氾 + - 忉 + - 宄 + - 讱 + - 扞 + - 圲 + - 圫 + - 芏 + - 芃 + - 朳 + - 朸 + - 𨙸 + - 邨 + - 吒 + - 吖 + - 屼 + - 屾 + - 辿 + - 钆 + - 仳 + - 伣 + - 伈 + - 癿 + - 甪 + - 邠 + - 犴 + - 冱 + - 邡 + - 闫 + - 汋 + - 䜣 + - 讻 + - 孖 + - 纩 + - 玒 + - 玓 + - 玘 + - 玚 + - 刬 + - 坜 + - 坉 + - 扽 + - 坋 + - 扺 + - 㧑 + - 毐 + - 芰 + - 芣 + - 苊 + - 苉 + - 芘 + - 芴 + - 芠 + - 芤 + - 杕 + - 杙 + - 杄 + - 杧 + - 杩 + - 尪 + - 尨 + - 轪 + - 坒 + - 芈 + - 旴 + - 旵 + - 呙 + - 㕮 + - 岍 + - 岠 + - 岜 + - 呇 + - 冏 + - 觃 + - 岙 + - 伾 + - 㑇 + - 伭 + - 佖 + - 伲 + - 佁 + - 飏 + - 狃 + - 闶 + - 汧 + - 汫 + - 𣲘 + - 𣲗 + - 沄 + - 沘 + - 汭 + - 㳇 + - 沇 + - 忮 + - 忳 + - 忺 + - 祃 + - 诇 + - 邲 + - 诎 + - 诐 + - 屃 + - 岊 + - 阽 + - 䢺 + - 阼 + - 妧 + - 妘 + - 𨚕 + - 纮 + - 驲 + - 纻 + - 纼 + - 玤 + - 玞 + - 玱 + - 玟 + - 邽 + - 邿 + - 坥 + - 坰 + - 坬 + - 坽 + - 弆 + - 耵 + - 䢼 + - 𦭜 + - 茋 + - 苧 + - 苾 + - 苠 + - 枅 + - 㭎 + - 枘 + - 枍 + - 矼 + - 矻 + - 匼 + - 旿 + - 昇 + - 昄 + - 昒 + - 昈 + - 咉 + - 咇 + - 咍 + - 岵 + - 岽 + - 岨 + - 岞 + - 峂 + - 㟃 + - 囷 + - 钐 + - 钔 + - 钖 + - 牥 + - 佴 + - 垈 + - 侁 + - 侹 + - 佸 + - 佺 + - 隹 + - 㑊 + - 侂 + - 佽 + - 侘 + - 郈 + - 舠 + - 郐 + - 郃 + - 攽 + - 肭 + - 肸 + - 肷 + - 狉 + - 狝 + - 饳 + - 忞 + - 於 + - 炌 + - 炆 + - 泙 + - 沺 + - 泂 + - 泜 + - 泃 + - 泇 + - 怊 + - 峃 + - 穸 + - 祋 + - 祊 + - 鸤 + - 弢 + - 弨 + - 陑 + - 陎 + - 卺 + - 乸 + - 妭 + - 姈 + - 迳 + - 叕 + - 驵 + - 䌹 + - 驺 + - 绋 + - 绐 + - 砉 + - 耔 + - 㛃 + - 玶 + - 珇 + - 珅 + - 珋 + - 玹 + - 珌 + - 玿 + - 韨 + - 垚 + - 垯 + - 垙 + - 垲 + - 埏 + - 垍 + - 耇 + - 垎 + - 垴 + - 垟 + - 垞 + - 挓 + - 垵 + - 垏 + - 拶 + - 荖 + - 荁 + - 荙 + - 荛 + - 茈 + - 茽 + - 荄 + - 茺 + - 荓 + - 茳 + - 𦰡 + - 茛 + - 荭 + - 㭕 + - 柷 + - 柃 + - 柊 + - 枹 + - 栐 + - 柖 + - 郚 + - 剅 + - 䴓 + - 迺 + - 厖 + - 砆 + - 砑 + - 砄 + - 耏 + - 奓 + - 䶮 + - 轵 + - 轷 + - 轹 + - 轺 + - 昺 + - 昽 + - 盷 + - 咡 + - 咺 + - 昳 + - 昣 + - 哒 + - 昤 + - 昫 + - 昡 + - 咥 + - 昪 + - 虷 + - 虸 + - 哃 + - 峘 + - 耑 + - 峛 + - 峗 + - 峧 + - 帡 + - 钘 + - 钜 + - 钪 + - 钬 + - 钭 + - 矧 + - 秬 + - 俫 + - 舁 + - 俜 + - 俙 + - 俍 + - 垕 + - 衎 + - 舣 + - 弇 + - 侴 + - 鸧 + - 䏡 + - 胠 + - 𦙶 + - 胈 + - 胩 + - 胣 + - 朏 + - 飐 + - 訄 + - 饻 + - 庤 + - 疢 + - 炣 + - 炟 + - 㶲 + - 洭 + - 洘 + - 洓 + - 洿 + - 㳚 + - 泚 + - 浈 + - 浉 + - 洸 + - 洑 + - 洢 + - 洈 + - 洚 + - 洺 + - 洨 + - 浐 + - 㳘 + - 洴 + - 洣 + - 恔 + - 宬 + - 窀 + - 扂 + - 袆 + - 祏 + - 祐 + - 祕 + - 叚 + - 陧 + - 陞 + - 娀 + - 姞 + - 姱 + - 姤 + - 姶 + - 姽 + - 枲 + - 绖 + - 骃 + - 彖 + - 骉 + - 恝 + - 珪 + - 珛 + - 珹 + - 琊 + - 玼 + - 珖 + - 珽 + - 珦 + - 珫 + - 珒 + - 珢 + - 珕 + - 珝 + - 埗 + - 垾 + - 垺 + - 埆 + - 垿 + - 埌 + - 埇 + - 莰 + - 茝 + - 鄀 + - 莶 + - 莝 + - 䓖 + - 莙 + - 栻 + - 桠 + - 桄 + - 梠 + - 栴 + - 梴 + - 栒 + - 酎 + - 酏 + - 砵 + - 砠 + - 砫 + - 砬 + - 硁 + - 恧 + - 翃 + - 郪 + - 𨐈 + - 辀 + - 辁 + - 剕 + - 赀 + - 哢 + - 晅 + - 晊 + - 唝 + - 哳 + - 哱 + - 冔 + - 晔 + - 晐 + - 晖 + - 畖 + - 蚄 + - 蚆 + - 帱 + - 崁 + - 峿 + - 崄 + - 帨 + - 崀 + - 赆 + - 钷 + - 眚 + - 甡 + - 笫 + - 倻 + - 倴 + - 脩 + - 倮 + - 倕 + - 倞 + - 倓 + - 倧 + - 衃 + - 虒 + - 舭 + - 舯 + - 舥 + - 瓞 + - 鬯 + - 鸰 + - 脎 + - 朓 + - 胲 + - 虓 + - 鱽 + - 狴 + - 峱 + - 狻 + - 眢 + - 勍 + - 痄 + - 疰 + - 痃 + - 竘 + - 羖 + - 羓 + - 桊 + - 敉 + - 烠 + - 烔 + - 烶 + - 烻 + - 涍 + - 浡 + - 浭 + - 浬 + - 涄 + - 涢 + - 涐 + - 浰 + - 浟 + - 浛 + - 浼 + - 浲 + - 涘 + - 悈 + - 悃 + - 悢 + - 宧 + - 窅 + - 窊 + - 窎 + - 扅 + - 扆 + - 袪 + - 袗 + - 袯 + - 祧 + - 隺 + - 堲 + - 疍 + - 𨺙 + - 陴 + - 烝 + - 砮 + - 㛚 + - 哿 + - 翀 + - 翂 + - 剟 + - 绤 + - 骍 + - 䂮 + - 琎 + - 珸 + - 珵 + - 琄 + - 琈 + - 琀 + - 珺 + - 掭 + - 堎 + - 堐 + - 埼 + - 掎 + - 埫 + - 堌 + - 晢 + - 掞 + - 埪 + - 壸 + - 㙍 + - 聍 + - 菝 + - 萚 + - 菥 + - 莿 + - 䓫 + - 勚 + - 䓬 + - 萆 + - 菂 + - 菍 + - 菼 + - 萣 + - 䓨 + - 菉 + - 䓛 + - 梼 + - 梽 + - 桲 + - 梾 + - 桯 + - 梣 + - 梌 + - 桹 + - 敔 + - 厣 + - 硔 + - 硙 + - 硚 + - 硊 + - 硍 + - 勔 + - 䴕 + - 龁 + - 逴 + - 唪 + - 啫 + - 翈 + - 㫰 + - 晙 + - 畤 + - 趼 + - 跂 + - 蛃 + - 蚲 + - 蚺 + - 啴 + - 䎃 + - 崧 + - 崟 + - 崞 + - 崒 + - 崌 + - 崡 + - 铏 + - 铕 + - 铖 + - 铘 + - 铚 + - 铞 + - 铥 + - 铴 + - 牻 + - 牿 + - 稆 + - 笱 + - 笯 + - 偰 + - 偡 + - 鸺 + - 偭 + - 偲 + - 偁 + - 㿠 + - 鄅 + - 偓 + - 徛 + - 衒 + - 舳 + - 舲 + - 鸼 + - 悆 + - 鄃 + - 瓻 + - 䝙 + - 脶 + - 脞 + - 脟 + - 䏲 + - 鱾 + - 猇 + - 猊 + - 猄 + - 觖 + - 𠅤 + - 庱 + - 庼 + - 庳 + - 痓 + - 䴔 + - 竫 + - 堃 + - 阌 + - 羝 + - 羕 + - 焆 + - 烺 + - 焌 + - 淏 + - 淟 + - 淜 + - 淴 + - 淯 + - 湴 + - 涴 + - 㥄 + - 惛 + - 惔 + - 悰 + - 惙 + - 寁 + - 逭 + - 袼 + - 裈 + - 祲 + - 谞 + - 艴 + - 弸 + - 弶 + - 隃 + - 婞 + - 娵 + - 婼 + - 媖 + - 婳 + - 婍 + - 婌 + - 婫 + - 婤 + - 婘 + - 婠 + - 绹 + - 骕 + - 絜 + - 珷 + - 琲 + - 琡 + - 琟 + - 琔 + - 琭 + - 堾 + - 堼 + - 揕 + - 㙘 + - 堧 + - 喆 + - 堨 + - 塅 + - 堠 + - 絷 + - 𡎚 + - 葜 + - 惎 + - 萳 + - 葙 + - 靬 + - 葴 + - 蒇 + - 蒈 + - 鄚 + - 蒉 + - 蓇 + - 萩 + - 蒐 + - 葰 + - 葎 + - 鄑 + - 蒎 + - 葖 + - 蒄 + - 萹 + - 棤 + - 棽 + - 棫 + - 椓 + - 椑 + - 鹀 + - 椆 + - 棓 + - 棬 + - 棪 + - 椀 + - 楗 + - 甦 + - 酦 + - 觌 + - 奡 + - 皕 + - 硪 + - 欹 + - 詟 + - 辌 + - 棐 + - 龂 + - 黹 + - 牚 + - 睎 + - 晫 + - 晪 + - 晱 + - 𧿹 + - 蛑 + - 畯 + - 斝 + - 喤 + - 崶 + - 嵁 + - 崾 + - 嵅 + - 崿 + - 嵚 + - 翙 + - 圌 + - 圐 + - 赑 + - 淼 + - 赒 + - 铹 + - 铽 + - 𨱇 + - 锊 + - 锍 + - 锎 + - 锓 + - 犇 + - 颋 + - 稌 + - 筀 + - 筘 + - 筜 + - 筥 + - 筅 + - 傃 + - 傉 + - 翛 + - 傒 + - 傕 + - 舾 + - 畬 + - 脿 + - 腘 + - 䐃 + - 腙 + - 腒 + - 鲃 + - 猰 + - 猯 + - 㺄 + - 馉 + - 鄗 + - 廋 + - 廆 + - 鄌 + - 粢 + - 遆 + - 旐 + - 焞 + - 欻 + - 𣸣 + - 溚 + - 溁 + - 湝 + - 渰 + - 湓 + - 㴔 + - 渟 + - 溠 + - 渼 + - 溇 + - 湣 + - 湑 + - 溞 + - 愐 + - 愃 + - 敩 + - 甯 + - 棨 + - 扊 + - 裣 + - 祼 + - 婻 + - 媆 + - 媞 + - 㛹 + - 媓 + - 媂 + - 媄 + - 毵 + - 矞 + - 缊 + - 缐 + - 骙 + - 瑃 + - 瑓 + - 瑅 + - 瑆 + - 䴖 + - 瑖 + - 瑝 + - 瑔 + - 瑀 + - 𤧛 + - 瑳 + - 瑂 + - 嶅 + - 瑑 + - 遘 + - 髢 + - 塥 + - 堽 + - 赪 + - 摛 + - 塝 + - 搒 + - 搌 + - 蒱 + - 蒨 + - 蓏 + - 蔀 + - 蓢 + - 蓂 + - 蒻 + - 蓣 + - 椹 + - 楪 + - 榃 + - 榅 + - 楒 + - 楞 + - 楩 + - 榇 + - 椸 + - 楙 + - 歅 + - 碃 + - 碏 + - 碈 + - 䃅 + - 硿 + - 鄠 + - 辒 + - 龆 + - 觜 + - 䣘 + - 暕 + - 鹍 + - 㬊 + - 暅 + - 跱 + - 蜐 + - 蜎 + - 嵲 + - 赗 + - 骱 + - 锖 + - 锘 + - 锳 + - 锧 + - 锪 + - 锫 + - 锬 + - 稑 + - 稙 + - 䅟 + - 筻 + - 筼 + - 筶 + - 筦 + - 筤 + - 傺 + - 鹎 + - 僇 + - 艅 + - 艉 + - 谼 + - 貆 + - 腽 + - 腨 + - 腯 + - 鲉 + - 鲊 + - 鲌 + - 䲟 + - 鲏 + - 雊 + - 猺 + - 飔 + - 觟 + - 𦝼 + - 馌 + - 裛 + - 廒 + - 瘀 + - 瘅 + - 鄘 + - 鹒 + - 鄜 + - 麀 + - 鄣 + - 阘 + - 煁 + - 煃 + - 煴 + - 煋 + - 煟 + - 煓 + - 滠 + - 溍 + - 溹 + - 滆 + - 滉 + - 溦 + - 溵 + - 漷 + - 滧 + - 滘 + - 滍 + - 愭 + - 慥 + - 慆 + - 塱 + - 裼 + - 禋 + - 禔 + - 禘 + - 禒 + - 谫 + - 鹔 + - 愍 + - 嫄 + - 媱 + - 戤 + - 戣 + - 缞 + - 耤 + - 瑧 + - 瑨 + - 瑱 + - 瑷 + - 瑢 + - 斠 + - 摏 + - 墕 + - 墈 + - 墐 + - 墘 + - 摴 + - 銎 + - 𡐓 + - 墚 + - 撖 + - 靽 + - 鞁 + - 蔌 + - 蔈 + - 蓰 + - 蔹 + - 蔊 + - 嘏 + - 榰 + - 榑 + - 槚 + - 𣗋 + - 槜 + - 榍 + - 疐 + - 酺 + - 酾 + - 酲 + - 酴 + - 碶 + - 䃎 + - 碨 + - 𥔲 + - 碹 + - 碥 + - 劂 + - 䴗 + - 夥 + - 瞍 + - 鹖 + - 㬎 + - 跽 + - 蜾 + - 幖 + - 嶍 + - 圙 + - 𨱏 + - 锺 + - 锼 + - 锽 + - 锾 + - 锿 + - 镃 + - 镄 + - 镅 + - 馝 + - 鹙 + - 箨 + - 箖 + - 劄 + - 僬 + - 僦 + - 僔 + - 僎 + - 槃 + - 㙦 + - 鲒 + - 鲕 + - 鲖 + - 鲗 + - 鲘 + - 鲙 + - 𩽾 + - 夐 + - 獍 + - 飗 + - 凘 + - 廑 + - 廙 + - 瘗 + - 瘥 + - 瘕 + - 鲝 + - 鄫 + - 熇 + - 漹 + - 漖 + - 潆 + - 漤 + - 潩 + - 漼 + - 漴 + - 㽏 + - 漈 + - 漋 + - 漻 + - 慬 + - 窬 + - 窭 + - 㮾 + - 褕 + - 禛 + - 禚 + - 隩 + - 嫕 + - 嫭 + - 嫜 + - 嫪 + - 㻬 + - 麹 + - 璆 + - 漦 + - 叇 + - 墣 + - 墦 + - 墡 + - 劐 + - 薁 + - 蕰 + - 蔃 + - 鼒 + - 槱 + - 鹝 + - 磏 + - 磉 + - 殣 + - 慭 + - 霅 + - 暵 + - 暲 + - 暶 + - 踦 + - 踣 + - 䗖 + - 蝘 + - 蝲 + - 蝤 + - 噇 + - 噂 + - 噀 + - 罶 + - 嶲 + - 嶓 + - 㠇 + - 嶟 + - 嶒 + - 镆 + - 镈 + - 镋 + - 镎 + - 镕 + - 稹 + - 儇 + - 皞 + - 皛 + - 䴘 + - 艎 + - 艏 + - 鹟 + - 𩾃 + - 鲦 + - 鲪 + - 鲬 + - 橥 + - 觭 + - 鹠 + - 鹡 + - 糇 + - 糈 + - 翦 + - 鹢 + - 鹣 + - 熛 + - 潖 + - 潵 + - 㵐 + - 澂 + - 澛 + - 瑬 + - 潽 + - 潾 + - 潏 + - 憭 + - 憕 + - 戭 + - 褯 + - 禤 + - 嫽 + - 遹 + - 璥 + - 璲 + - 璒 + - 憙 + - 擐 + - 鄹 + - 薳 + - 鞔 + - 黇 + - 蕗 + - 薢 + - 蕹 + - 橞 + - 橑 + - 橦 + - 醑 + - 觱 + - 磡 + - 𥕢 + - 磜 + - 豮 + - 鹾 + - 虤 + - 暿 + - 曌 + - 曈 + - 㬚 + - 蹅 + - 踶 + - 䗛 + - 螗 + - 疁 + - 㠓 + - 幪 + - 嶦 + - 𨱑 + - 馞 + - 穄 + - 篚 + - 篯 + - 簉 + - 鼽 + - 衠 + - 盦 + - 螣 + - 縢 + - 鲭 + - 鲯 + - 鲰 + - 鲺 + - 鲹 + - 亸 + - 癀 + - 瘭 + - 羱 + - 糒 + - 燋 + - 熻 + - 燊 + - 燚 + - 燏 + - 濩 + - 濋 + - 澪 + - 澽 + - 澴 + - 澭 + - 澼 + - 憷 + - 憺 + - 懔 + - 黉 + - 嬛 + - 鹨 + - 翯 + - 璱 + - 𤩽 + - 璬 + - 璮 + - 髽 + - 擿 + - 薿 + - 薸 + - 檑 + - 櫆 + - 檞 + - 醨 + - 繄 + - 磹 + - 磻 + - 瞫 + - 瞵 + - 蹐 + - 蟏 + - 㘎 + - 镤 + - 镥 + - 镨 + - 𨱔 + - 矰 + - 穙 + - 穜 + - 穟 + - 簕 + - 簃 + - 簏 + - 儦 + - 魋 + - 斶 + - 艚 + - 谿 + - 䲠 + - 鲾 + - 鲿 + - 鳁 + - 鳂 + - 鳈 + - 鳉 + - 獯 + - 䗪 + - 馘 + - 襕 + - 襚 + - 螱 + - 甓 + - 嬬 + - 嬥 + - 𦈡 + - 瓀 + - 釐 + - 鬶 + - 爇 + - 鞳 + - 鞮 + - 藟 + - 藦 + - 藨 + - 鹲 + - 檫 + - 黡 + - 礞 + - 礌 + - 𥖨 + - 蹢 + - 蹜 + - 蟫 + - 䗴 + - 嚚 + - 髃 + - 镮 + - 镱 + - 酂 + - 馧 + - 簠 + - 簝 + - 簰 + - 鼫 + - 鼩 + - 皦 + - 臑 + - 䲢 + - 鳑 + - 鳒 + - 鹱 + - 鹯 + - 癗 + - 𦒍 + - 旞 + - 翷 + - 冁 + - 䎖 + - 瀔 + - 瀍 + - 瀌 + - 襜 + - 䴙 + - 嚭 + - 㰀 + - 鬷 + - 醭 + - 蹯 + - 蠋 + - 翾 + - 鳘 + - 儳 + - 儴 + - 鼗 + - 𩾌 + - 鳚 + - 鳛 + - 麑 + - 麖 + - 蠃 + - 彟 + - 嬿 + - 鬒 + - 蘘 + - 欂 + - 醵 + - 颥 + - 甗 + - 𨟠 + - 巇 + - 酅 + - 髎 + - 犨 + - 𨭉 + - 㸌 + - 爔 + - 瀱 + - 瀹 + - 瀼 + - 瀵 + - 襫 + - 孅 + - 骦 + - 耰 + - 𤫉 + - 瓖 + - 鬘 + - 趯 + - 罍 + - 鼱 + - 鳠 + - 鳡 + - 鳣 + - 爟 + - 爚 + - 灈 + - 韂 + - 糵 + - 蘼 + - 礵 + - 鹴 + - 躔 + - 皭 + - 龢 + - 鳤 + - 亹 + - 籥 + - 鼷 + - 玃 + - 醾 + - 齇 + - 觿 + - 蠼 + - 𬣙 + - 𬇕 + - 𬣞 + - 𬘓 + - 𫭟 + - 𫭢 + - 𫇭 + - 𫐄 + - 𫵷 + - 𬇙 + - 𬣡 + - 𫸩 + - 𫘜 + - 𬘘 + - 𫘝 + - 𬨂 + - 𬀩 + - 𬀪 + - 𬬩 + - 𫍣 + - 𬣳 + - 𬩽 + - 𬮿 + - 𬯀 + - 𫰛 + - 𬳵 + - 𬳶 + - 𫠊 + - 𬍛 + - 鿍 + - 𬜬 + - 𪾢 + - 𪨰 + - 𫓧 + - 𬬮 + - 𬬱 + - 𬬭 + - 𬘡 + - 𬳽 + - 𬘩 + - 𫄧 + - 𪟝 + - 𬍤 + - 𫭼 + - 𬜯 + - 𬂩 + - 𫠆 + - 𬌗 + - 𫑡 + - 𪨶 + - 𬬸 + - 𬬻 + - 𬬹 + - 𬬿 + - 𬭁 + - 𫢸 + - 𫗧 + - 𬊈 + - 𬒈 + - 𬳿 + - 𫄨 + - 𬘫 + - 𫮃 + - 鿎 + - 𬱖 + - 𬟽 + - 𫓯 + - 𫟹 + - 𫟼 + - 𬇹 + - 𬍡 + - 𬤇 + - 𫍯 + - 𬤊 + - 𫍲 + - 𬯎 + - 𬘬 + - 𬘭 + - 𬴂 + - 𫘦 + - 𫟅 + - 𬘯 + - 𫘧 + - 𪣻 + - 𬃊 + - 𬷕 + - 𫐐 + - 𬹼 + - 𫶇 + - 𫖮 + - 鿏 + - 𬭊 + - 𫓶 + - 𬭎 + - 𫖯 + - 𬱟 + - 𫛭 + - 𫷷 + - 𬮱 + - 𬊤 + - 𬴃 + - 𫘨 + - 𬪩 + - 𬒔 + - 𬨎 + - 𫐓 + - 𫫇 + - 𫓹 + - 𬭚 + - 𬭛 + - 𬕂 + - 𬶋 + - 𬶍 + - 𫔶 + - 𫌀 + - 𫖳 + - 𫘪 + - 𫘬 + - 𫞩 + - 𪤗 + - 𬸘 + - 𬒗 + - 𫚖 + - 𬭤 + - 𫚕 + - 𬶐 + - 𬶏 + - 𬸚 + - 𬤝 + - 𬙂 + - 𬭩 + - 𬸣 + - 𫍽 + - 𬴊 + - 𬞟 + - 𫟦 + - 𬺈 + - 𫠜 + - 𪩘 + - 𬭬 + - 𬭯 + - 𫗴 + - 𬸦 + - 𫄷 + - 𬭳 + - 𬭶 + - 𫔍 + - 𬭸 + - 𬭼 + - 𫔎 + - 𬸪 + - 𬶟 + - 𬶠 + - 𬶨 + - 𫄸 + - 𬟁 + - 𬙊 + - 𬶭 + - 𬶮 + - 𬙋 + - 𬺓 + - 𫚭 + - 廠 + - 蔔 + - 兒 + - 幾 + - 幹 + - 虧 + - 纔 + - 與 + - 萬 + - 韆 + - 億 + - 個 + - 廣 + - 門 + - 義 + - 衛 + - 飛 + - 習 + - 馬 + - 鄉 + - 豐 + - 開 + - 無 + - 雲 + - 專 + - 藝 + - 廳 + - 區 + - 歷 + - 曆 + - 車 + - 貝 + - 岡 + - 見 + - 氣 + - 長 + - 僕 + - 幣 + - 僅 + - 從 + - 侖 + - 倉 + - 風 + - 烏 + - 鳳 + - 爲 + - 鬥 + - 憶 + - 計 + - 訂 + - 認 + - 譏 + - 醜 + - 隊 + - 辦 + - 鄧 + - 勸 + - 雙 + - 書 + - 擊 + - 撲 + - 節 + - 術 + - 厲 + - 龍 + - 滅 + - 軋 + - 東 + - 盧 + - 業 + - 舊 + - 帥 + - 歸 + - 葉 + - 電 + - 號 + - 衹 + - 隻 + - 嘰 + - 嘆 + - 們 + - 儀 + - 叢 + - 爾 + - 樂 + - 處 + - 鼕 + - 鳥 + - 務 + - 飢 + - 饑 + - 馮 + - 閃 + - 蘭 + - 匯 + - 彙 + - 頭 + - 漢 + - 寧 + - 討 + - 寫 + - 讓 + - 禮 + - 訓 + - 議 + - 訊 + - 記 + - 齣 + - 遼 + - 邊 + - 發 + - 髮 + - 聖 + - 對 + - 臺 + - 颱 + - 檯 + - 糾 + - 絲 + - 動 + - 鞏 + - 執 + - 擴 + - 掃 + - 場 + - 揚 + - 亞 + - 樸 + - 機 + - 權 + - 過 + - 協 + - 壓 + - 厭 + - 頁 + - 誇 + - 奪 + - 達 + - 夾 + - 軌 + - 堯 + - 劃 + - 邁 + - 畢 + - 貞 + - 師 + - 塵 + - 當 + - 噹 + - 籲 + - 嚇 + - 蟲 + - 麯 + - 團 + - 糰 + - 嗎 + - 嶼 + - 歲 + - 迴 + - 豈 + - 則 + - 剛 + - 網 + - 硃 + - 遷 + - 喬 + - 偉 + - 傳 + - 優 + - 傷 + - 價 + - 倫 + - 華 + - 僞 + - 嚮 + - 後 + - 會 + - 殺 + - 閤 + - 衆 + - 爺 + - 傘 + - 創 + - 雜 + - 負 + - 壯 + - 衝 + - 妝 + - 莊 + - 慶 + - 劉 + - 齊 + - 産 + - 閉 + - 問 + - 闖 + - 關 + - 燈 + - 湯 + - 興 + - 講 + - 諱 + - 軍 + - 訝 + - 許 + - 訛 + - 論 + - 訟 + - 農 + - 諷 + - 設 + - 訪 + - 訣 + - 尋 + - 盡 + - 儘 + - 導 + - 孫 + - 陣 + - 陽 + - 階 + - 陰 + - 婦 + - 媽 + - 戲 + - 觀 + - 歡 + - 買 + - 紅 + - 馱 + - 纖 + - 縴 + - 馴 + - 約 + - 級 + - 紀 + - 馳 + - 紉 + - 壽 + - 麥 + - 瑪 + - 進 + - 遠 + - 違 + - 韌 + - 運 + - 撫 + - 壇 + - 罎 + - 壞 + - 摳 + - 擾 + - 貢 + - 垻 + - 壩 + - 摺 + - 掄 + - 搶 + - 墳 + - 護 + - 殻 + - 塊 + - 聲 + - 報 + - 擬 + - 蕪 + - 葦 + - 蒼 + - 嚴 + - 蘆 + - 勞 + - 蘇 + - 囌 + - 極 + - 楊 + - 兩 + - 麗 + - 醫 + - 勵 + - 還 + - 殲 + - 來 + - 連 + - 軒 + - 鹵 + - 滷 + - 堅 + - 時 + - 縣 + - 裏 + - 嘔 + - 園 + - 曠 + - 圍 + - 噸 + - 郵 + - 睏 + - 員 + - 聽 + - 嗆 + - 嗚 + - 彆 + - 嶇 + - 崗 + - 帳 + - 財 + - 針 + - 釘 + - 亂 + - 體 + - 傭 + - 徹 + - 餘 + - 穀 + - 鄰 + - 腸 + - 龜 + - 猶 + - 狽 + - 條 + - 島 + - 飯 + - 飲 + - 係 + - 繫 + - 凍 + - 狀 + - 畝 + - 庫 + - 療 + - 應 + - 這 + - 廬 + - 閏 + - 閑 + - 間 + - 悶 + - 竈 + - 燦 + - 瀝 + - 淪 + - 滄 + - 溝 + - 滬 + - 瀋 + - 懷 + - 憂 + - 窮 + - 證 + - 啓 + - 評 + - 補 + - 識 + - 詐 + - 訴 + - 診 + - 詞 + - 譯 + - 靈 + - 層 + - 遲 + - 張 + - 際 + - 陸 + - 陳 + - 墜 + - 勁 + - 鷄 + - 緯 + - 驅 + - 純 + - 紗 + - 綱 + - 納 + - 駁 + - 縱 + - 紛 + - 紙 + - 紋 + - 紡 + - 驢 + - 紐 + - 環 + - 責 + - 現 + - 錶 + - 規 + - 攏 + - 揀 + - 擔 + - 頂 + - 擁 + - 勢 + - 攔 + - 擰 + - 撥 + - 擇 + - 蘋 + - 範 + - 莖 + - 樞 + - 櫃 + - 闆 + - 鬆 + - 槍 + - 楓 + - 構 + - 喪 + - 畫 + - 棗 + - 賣 + - 鬱 + - 礬 + - 礦 + - 碼 + - 厠 + - 奮 + - 態 + - 歐 + - 毆 + - 壟 + - 轟 + - 頃 + - 轉 + - 斬 + - 輪 + - 軟 + - 齒 + - 虜 + - 腎 + - 賢 + - 國 + - 暢 + - 嚨 + - 鳴 + - 羅 + - 幟 + - 嶺 + - 凱 + - 敗 + - 賬 + - 販 + - 貶 + - 購 + - 貯 + - 圖 + - 釣 + - 製 + - 颳 + - 俠 + - 僥 + - 偵 + - 側 + - 憑 + - 僑 + - 貨 + - 質 + - 徑 + - 捨 + - 覓 + - 貪 + - 貧 + - 膚 + - 腫 + - 脹 + - 骯 + - 脅 + - 魚 + - 獰 + - 備 + - 飾 + - 飽 + - 飼 + - 變 + - 龐 + - 廟 + - 瘧 + - 劑 + - 廢 + - 閘 + - 鬧 + - 鄭 + - 捲 + - 單 + - 爐 + - 淺 + - 濘 + - 瀉 + - 潑 + - 澤 + - 憐 + - 學 + - 寶 + - 寵 + - 審 + - 簾 + - 實 + - 試 + - 詩 + - 誠 + - 襯 + - 視 + - 話 + - 誕 + - 詭 + - 詢 + - 該 + - 詳 + - 肅 + - 録 + - 隸 + - 彌 + - 瀰 + - 陝 + - 駕 + - 參 + - 艱 + - 綫 + - 練 + - 組 + - 紳 + - 細 + - 駛 + - 織 + - 駒 + - 終 + - 駐 + - 絆 + - 駝 + - 紹 + - 繹 + - 經 + - 貫 + - 貳 + - 幫 + - 項 + - 挾 + - 撓 + - 趙 + - 擋 + - 墊 + - 擠 + - 揮 + - 薦 + - 帶 + - 繭 + - 蕩 + - 榮 + - 葷 + - 熒 + - 鬍 + - 蔭 + - 藥 + - 標 + - 棧 + - 棟 + - 欄 + - 檸 + - 樹 + - 鹹 + - 磚 + - 硯 + - 麵 + - 牽 + - 鷗 + - 殘 + - 軸 + - 輕 + - 鴉 + - 戰 + - 點 + - 臨 + - 覽 + - 竪 + - 嘗 + - 啞 + - 顯 + - 貴 + - 蝦 + - 蟻 + - 螞 + - 雖 + - 駡 + - 勛 + - 嘩 + - 響 + - 喲 + - 峽 + - 罰 + - 賤 + - 貼 + - 貽 + - 鈣 + - 鈍 + - 鈔 + - 鍾 + - 鐘 + - 鋼 + - 鈉 + - 鑰 + - 欽 + - 鈞 + - 鈎 + - 鈕 + - 氈 + - 氫 + - 選 + - 適 + - 種 + - 鞦 + - 復 + - 複 + - 倆 + - 貸 + - 順 + - 儉 + - 須 + - 鬚 + - 劍 + - 朧 + - 膽 + - 勝 + - 狹 + - 獅 + - 獨 + - 獄 + - 貿 + - 餌 + - 饒 + - 蝕 + - 餃 + - 餅 + - 巒 + - 彎 + - 將 + - 奬 + - 瘡 + - 瘋 + - 親 + - 閨 + - 聞 + - 閩 + - 閥 + - 閣 + - 養 + - 薑 + - 類 + - 婁 + - 總 + - 煉 + - 爍 + - 爛 + - 窪 + - 潔 + - 灑 + - 澆 + - 濁 + - 測 + - 瀏 + - 濟 + - 渾 + - 濃 + - 惱 + - 舉 + - 覺 + - 憲 + - 竊 + - 誡 + - 誣 + - 語 + - 襖 + - 誤 + - 誘 + - 誨 + - 説 + - 誦 + - 墾 + - 晝 + - 費 + - 遜 + - 隕 + - 險 + - 嬌 + - 賀 + - 壘 + - 綁 + - 絨 + - 結 + - 繞 + - 驕 + - 繪 + - 給 + - 絢 + - 駱 + - 絡 + - 絶 + - 絞 + - 駭 + - 統 + - 艷 + - 蠶 + - 頑 + - 盞 + - 撈 + - 載 + - 趕 + - 鹽 + - 損 + - 撿 + - 摯 + - 剝 + - 熱 + - 搗 + - 壺 + - 聶 + - 萊 + - 蓮 + - 獲 + - 穫 + - 惡 + - 噁 + - 瑩 + - 鶯 + - 檔 + - 橋 + - 樺 + - 樁 + - 樣 + - 賈 + - 礫 + - 礎 + - 顧 + - 轎 + - 較 + - 頓 + - 斃 + - 緻 + - 慮 + - 監 + - 緊 + - 黨 + - 曬 + - 曉 + - 嘮 + - 鴨 + - 暈 + - 鴦 + - 罷 + - 圓 + - 賊 + - 賄 + - 賂 + - 贜 + - 錢 + - 鉗 + - 鑽 + - 鉀 + - 鐵 + - 鈴 + - 鉛 + - 犧 + - 敵 + - 積 + - 稱 + - 筆 + - 債 + - 傾 + - 賃 + - 艦 + - 艙 + - 聳 + - 愛 + - 頒 + - 頌 + - 臟 + - 髒 + - 臍 + - 膠 + - 腦 + - 膿 + - 鴕 + - 鴛 + - 皺 + - 餓 + - 餒 + - 戀 + - 槳 + - 漿 + - 準 + - 癥 + - 齋 + - 離 + - 資 + - 競 + - 閲 + - 煩 + - 燒 + - 燭 + - 遞 + - 濤 + - 澇 + - 渦 + - 塗 + - 滌 + - 潤 + - 澗 + - 漲 + - 燙 + - 澀 + - 憫 + - 寬 + - 傢 + - 賓 + - 竅 + - 請 + - 諸 + - 諾 + - 讀 + - 誹 + - 襪 + - 課 + - 誰 + - 調 + - 諒 + - 諄 + - 談 + - 誼 + - 懇 + - 劇 + - 難 + - 預 + - 絹 + - 綉 + - 驗 + - 繼 + - 駿 + - 瑣 + - 擲 + - 據 + - 摻 + - 職 + - 蘿 + - 螢 + - 營 + - 蕭 + - 薩 + - 夢 + - 檢 + - 醖 + - 碩 + - 聾 + - 襲 + - 輔 + - 輛 + - 顱 + - 懸 + - 躍 + - 纍 + - 囉 + - 嘯 + - 嶄 + - 邏 + - 嬰 + - 銬 + - 鐺 + - 鋁 + - 銅 + - 銘 + - 鏟 + - 銀 + - 矯 + - 穢 + - 籠 + - 償 + - 軀 + - 釁 + - 銜 + - 盤 + - 鴿 + - 斂 + - 領 + - 臉 + - 獵 + - 餡 + - 館 + - 癢 + - 鏇 + - 閻 + - 闡 + - 蓋 + - 斷 + - 獸 + - 鴻 + - 漸 + - 淵 + - 漁 + - 澱 + - 滲 + - 慚 + - 懼 + - 驚 + - 慘 + - 慣 + - 謀 + - 諜 + - 謊 + - 諧 + - 禱 + - 禍 + - 謂 + - 諺 + - 謎 + - 彈 + - 墮 + - 隨 + - 隱 + - 嬸 + - 頗 + - 頸 + - 績 + - 緒 + - 續 + - 騎 + - 綽 + - 繩 + - 維 + - 綿 + - 綳 + - 綢 + - 綜 + - 綻 + - 緑 + - 綴 + - 瓊 + - 趨 + - 攬 + - 攙 + - 擱 + - 摟 + - 攪 + - 聯 + - 蔣 + - 韓 + - 橢 + - 確 + - 頰 + - 靂 + - 暫 + - 翹 + - 輩 + - 鑿 + - 輝 + - 賞 + - 睞 + - 噴 + - 疇 + - 踐 + - 遺 + - 鵑 + - 賦 + - 賭 + - 贖 + - 賜 + - 賠 + - 鑄 + - 鋪 + - 鏈 + - 銷 + - 鎖 + - 鋤 + - 鍋 + - 銹 + - 鋒 + - 鋅 + - 鋭 + - 鵝 + - 築 + - 篩 + - 儲 + - 懲 + - 禦 + - 釋 + - 臘 + - 魯 + - 憊 + - 饋 + - 饞 + - 裝 + - 蠻 + - 闊 + - 糞 + - 滯 + - 濕 + - 潰 + - 濺 + - 灣 + - 憤 + - 竄 + - 窩 + - 褲 + - 禪 + - 謝 + - 謡 + - 謗 + - 謙 + - 屬 + - 屢 + - 緬 + - 纜 + - 緝 + - 緞 + - 緩 + - 締 + - 縷 + - 騙 + - 編 + - 騷 + - 緣 + - 鵡 + - 攝 + - 擺 + - 襬 + - 攤 + - 鵲 + - 藍 + - 濛 + - 懞 + - 矇 + - 獻 + - 欖 + - 樓 + - 賴 + - 礙 + - 尷 + - 霧 + - 輻 + - 輯 + - 輸 + - 頻 + - 齡 + - 鑒 + - 蹺 + - 蝸 + - 錯 + - 錨 + - 錫 + - 鑼 + - 錘 + - 錐 + - 錦 + - 鍵 + - 鋸 + - 錳 + - 辭 + - 頽 + - 籌 + - 簽 + - 籤 + - 簡 + - 膩 + - 鵬 + - 騰 + - 鮑 + - 穎 + - 觸 + - 雛 + - 饃 + - 餾 + - 醬 + - 謄 + - 糧 + - 數 + - 滿 + - 濾 + - 濫 + - 灕 + - 濱 + - 灘 + - 譽 + - 窺 + - 寢 + - 謹 + - 謬 + - 闢 + - 縛 + - 縫 + - 纏 + - 繽 + - 贅 + - 墻 + - 衊 + - 藹 + - 檻 + - 釀 + - 願 + - 轄 + - 輾 + - 顆 + - 踴 + - 蠟 + - 蠅 + - 蟬 + - 賺 + - 鍬 + - 鍛 + - 鍍 + - 穩 + - 籮 + - 簫 + - 輿 + - 鮮 + - 饅 + - 瀟 + - 賽 + - 譚 + - 譜 + - 騾 + - 縮 + - 攆 + - 聰 + - 藴 + - 櫻 + - 飄 + - 黴 + - 瞞 + - 題 + - 囑 + - 鎮 + - 鎬 + - 鎊 + - 簍 + - 鯉 + - 鯽 + - 癟 + - 癱 + - 顔 + - 鯊 + - 瀾 + - 額 + - 譴 + - 鶴 + - 繚 + - 顛 + - 轍 + - 鸚 + - 贈 + - 鏡 + - 贊 + - 籃 + - 籬 + - 鯨 + - 癮 + - 辯 + - 瀕 + - 懶 + - 繮 + - 繳 + - 矚 + - 贍 + - 鰐 + - 辮 + - 贏 + - 驟 + - 囂 + - 鐮 + - 鰭 + - 鷹 + - 巔 + - 顫 + - 癬 + - 鱉 + - 鬢 + - 鱗 + - 躪 + - 贛 + - 鑲 + - 韋 + - 閂 + - 訃 + - 勱 + - 芻 + - 鄺 + - 訐 + - 訌 + - 訕 + - 訖 + - 馭 + - 璣 + - 壙 + - 捫 + - 薌 + - 厙 + - 釔 + - 傴 + - 倀 + - 傖 + - 獷 + - 獁 + - 鳬 + - 鄔 + - 餳 + - 懺 + - 謳 + - 詎 + - 訥 + - 紆 + - 紂 + - 紇 + - 紈 + - 璵 + - 摶 + - 塢 + - 㩳 + - 蕓 + - 藶 + - 莧 + - 萇 + - 蓯 + - 磯 + - 奩 + - 歟 + - 軔 + - 鄴 + - 嘸 + - 囈 + - 嚦 + - 暘 + - 唄 + - 幃 + - 峴 + - 嵐 + - 圇 + - 釗 + - 釙 + - 釕 + - 僉 + - 鳩 + - 鄒 + - 飩 + - 餼 + - 飪 + - 飫 + - 飭 + - 廡 + - 癤 + - 闈 + - 閎 + - 閔 + - 煬 + - 灃 + - 漚 + - 渢 + - 潙 + - 憮 + - 慪 + - 愾 + - 悵 + - 愴 + - 詁 + - 訶 + - 詛 + - 詆 + - 謅 + - 詔 + - 詒 + - 隴 + - 陘 + - 嫵 + - 嫗 + - 嬀 + - 剄 + - 紜 + - 紕 + - 紝 + - 綸 + - 紓 + - 瑋 + - 匭 + - 壚 + - 擓 + - 蘢 + - 蔦 + - 塋 + - 煢 + - 櫪 + - 梘 + - 棖 + - 樅 + - 碭 + - 甌 + - 郟 + - 軛 + - 鳶 + - 曇 + - 蟣 + - 黽 + - 嚀 + - 噝 + - 巋 + - 劌 + - 剴 + - 嶧 + - 釷 + - 釺 + - 釧 + - 釩 + - 釹 + - 釵 + - 儈 + - 儕 + - 儂 + - 劊 + - 慫 + - 糴 + - 戧 + - 膞 + - 邇 + - 梟 + - 餞 + - 飴 + - 癘 + - 瘍 + - 煒 + - 熰 + - 熗 + - 瀧 + - 瀘 + - 濼 + - 涇 + - 㥮 + - 懌 + - 誆 + - 誄 + - 詿 + - 詰 + - 詼 + - 鄆 + - 禕 + - 誅 + - 詵 + - 詬 + - 詮 + - 詣 + - 諍 + - 詫 + - 諢 + - 詡 + - 駑 + - 紺 + - 紲 + - 紱 + - 駟 + - 駙 + - 縐 + - 絀 + - 驛 + - 駘 + - 瓏 + - 頇 + - 埡 + - 撾 + - 撻 + - 賁 + - 壋 + - 撏 + - 莢 + - 貰 + - 蓽 + - 蕎 + - 薈 + - 薺 + - 堊 + - 滎 + - 犖 + - 蕁 + - 藎 + - 蓀 + - 蕒 + - 葤 + - 櫛 + - 櫳 + - 櫨 + - 櫟 + - 檉 + - 酈 + - 硨 + - 碸 + - 殤 + - 軲 + - 軻 + - 轤 + - 軼 + - 軫 + - 蠆 + - 覘 + - 瞘 + - 嘵 + - 嗶 + - 噦 + - 剮 + - 鄖 + - 噲 + - 噥 + - 嶢 + - 幀 + - 嶠 + - 貺 + - 鈈 + - 鈦 + - 鋇 + - 鈑 + - 鈐 + - 鎢 + - 鈁 + - 鈀 + - 篤 + - 儔 + - 儼 + - 儷 + - 腖 + - 臚 + - 脛 + - 鴇 + - 獪 + - 颮 + - 猻 + - 餉 + - 餄 + - 餎 + - 孿 + - 孌 + - 癧 + - 瘲 + - 颯 + - 闥 + - 閭 + - 闓 + - 閡 + - 熾 + - 烴 + - 浹 + - 澮 + - 滸 + - 潯 + - 濜 + - 慟 + - 懨 + - 愷 + - 惻 + - 惲 + - 誚 + - 禰 + - 誥 + - 誑 + - 鴆 + - 婭 + - 嬈 + - 懟 + - 絝 + - 驍 + - 驊 + - 絎 + - 絳 + - 駢 + - 頊 + - 璫 + - 琿 + - 塒 + - 塤 + - 堝 + - 贄 + - 蒔 + - 萵 + - 蕕 + - 鴣 + - 蒓 + - 橈 + - 楨 + - 榿 + - 檜 + - 邐 + - 礪 + - 礱 + - 軾 + - 輊 + - 輅 + - 鶇 + - 躉 + - 齔 + - 鸕 + - 矓 + - 嘜 + - 鴞 + - 蜆 + - 嗩 + - 嶗 + - 崍 + - 覬 + - 賅 + - 鈺 + - 鉦 + - 鈷 + - 鉢 + - 鈸 + - 鉞 + - 鉭 + - 鉬 + - 鈿 + - 鈾 + - 鉑 + - 鑠 + - 鉚 + - 鈰 + - 鉉 + - 鉈 + - 鉍 + - 鈮 + - 鈹 + - 鏺 + - 鐸 + - 氬 + - 筧 + - 頎 + - 徠 + - 膾 + - 鴟 + - 璽 + - 鴝 + - 獫 + - 裊 + - 餑 + - 欒 + - 攣 + - 癰 + - 痙 + - 頏 + - 閫 + - 鬮 + - 誾 + - 閬 + - 鄲 + - 燁 + - 燴 + - 燼 + - 淶 + - 漣 + - 潿 + - 慳 + - 諏 + - 諑 + - 禎 + - 諉 + - 諛 + - 諗 + - 諂 + - 誶 + - 媧 + - 嫻 + - 綆 + - 驪 + - 綃 + - 騁 + - 綏 + - 縧 + - 綈 + - 駸 + - 鷥 + - 燾 + - 璉 + - 麩 + - 擄 + - 摑 + - 鷙 + - 撣 + - 慤 + - 摜 + - 縈 + - 槤 + - 覡 + - 欞 + - 嗇 + - 匱 + - 硤 + - 磽 + - 鴯 + - 龔 + - 殞 + - 殮 + - 賚 + - 輒 + - 塹 + - 嘖 + - 囀 + - 嚙 + - 蹌 + - 蠣 + - 蠱 + - 蟶 + - 幘 + - 幗 + - 賕 + - 賑 + - 賒 + - 銠 + - 鉺 + - 鋏 + - 鐃 + - 銦 + - 鎧 + - 鍘 + - 銖 + - 銑 + - 鋌 + - 鏵 + - 銓 + - 鎩 + - 鉿 + - 銚 + - 鉻 + - 錚 + - 銫 + - 鉸 + - 銥 + - 銃 + - 銨 + - 銣 + - 鴰 + - 穠 + - 箋 + - 籩 + - 僨 + - 僂 + - 皚 + - 鴴 + - 艫 + - 龕 + - 玀 + - 獼 + - 餜 + - 餛 + - 鸞 + - 闍 + - 閾 + - 閹 + - 閶 + - 鬩 + - 閽 + - 閼 + - 羥 + - 糲 + - 燜 + - 漬 + - 瀆 + - 澠 + - 愜 + - 憚 + - 諶 + - 諫 + - 皸 + - 謔 + - 襠 + - 謁 + - 諤 + - 諭 + - 諼 + - 讒 + - 諳 + - 諦 + - 諞 + - 糶 + - 嬋 + - 綾 + - 騏 + - 綺 + - 緋 + - 緔 + - 騍 + - 緄 + - 騅 + - 綬 + - 綹 + - 綣 + - 綰 + - 驂 + - 緇 + - 靚 + - 輦 + - 黿 + - 頡 + - 撳 + - 蟄 + - 壪 + - 蔞 + - 櫝 + - 欏 + - 賫 + - 鵓 + - 鸝 + - 殫 + - 輥 + - 輞 + - 槧 + - 輟 + - 輜 + - 瞼 + - 躒 + - 蛺 + - 蟯 + - 螄 + - 蠐 + - 嘍 + - 嶸 + - 嶁 + - 賧 + - 鋙 + - 錸 + - 鏗 + - 鋥 + - 鋰 + - 鋯 + - 鋨 + - 銼 + - 鐧 + - 銻 + - 鋃 + - 鋦 + - 錒 + - 犢 + - 鵠 + - 篳 + - 牘 + - 儻 + - 儐 + - 儺 + - 嬃 + - 頜 + - 鵒 + - 魷 + - 魨 + - 魴 + - 潁 + - 颶 + - 觴 + - 熲 + - 餷 + - 餿 + - 褻 + - 臠 + - 癆 + - 癇 + - 賡 + - 頦 + - 鷳 + - 闌 + - 闃 + - 闋 + - 鵜 + - 憒 + - 嚳 + - 謨 + - 褳 + - 襇 + - 讜 + - 謖 + - 謚 + - 謐 + - 騭 + - 巰 + - 翬 + - 騖 + - 緙 + - 緗 + - 緘 + - 緹 + - 緲 + - 緦 + - 緱 + - 縋 + - 緡 + - 饗 + - 耮 + - 驁 + - 韞 + - 攄 + - 擯 + - 轂 + - 驀 + - 鶓 + - 薊 + - 蘺 + - 鎣 + - 頤 + - 櫚 + - 櫸 + - 磧 + - 磣 + - 鵪 + - 輳 + - 齟 + - 齙 + - 韙 + - 囁 + - 躂 + - 蹕 + - 躚 + - 躋 + - 噯 + - 鍺 + - 錛 + - 錡 + - 鍀 + - 錁 + - 錕 + - 錮 + - 鍁 + - 錈 + - 錠 + - 錙 + - 覦 + - 頷 + - 鮁 + - 鮃 + - 鮎 + - 鱸 + - 穌 + - 鮒 + - 鮐 + - 鵮 + - 颼 + - 饈 + - 鶉 + - 瘮 + - 闔 + - 闐 + - 闕 + - 灧 + - 瀅 + - 潷 + - 灤 + - 澦 + - 懾 + - 鱟 + - 騫 + - 竇 + - 謾 + - 謫 + - 嬡 + - 嬪 + - 縉 + - 縝 + - 縟 + - 轡 + - 騮 + - 縞 + - 縭 + - 縊 + - 縑 + - 騸 + - 覯 + - 韜 + - 靉 + - 攖 + - 薔 + - 藺 + - 鶘 + - 檳 + - 櫧 + - 釅 + - 殯 + - 霽 + - 轅 + - 齜 + - 齦 + - 瞜 + - 曖 + - 躊 + - 蟈 + - 鶚 + - 嚶 + - 羆 + - 賻 + - 罌 + - 鶻 + - 鍥 + - 鍇 + - 鍶 + - 鍔 + - 鍤 + - 鏘 + - 鎂 + - 鏤 + - 簀 + - 篋 + - 簞 + - 籙 + - 臏 + - 鮭 + - 鮪 + - 鱭 + - 鮫 + - 鱘 + - 饉 + - 鑾 + - 瘻 + - 闞 + - 鮝 + - 糝 + - 鷀 + - 瀲 + - 濰 + - 譖 + - 褸 + - 譙 + - 讕 + - 譎 + - 鶥 + - 嬙 + - 鶩 + - 驃 + - 縹 + - 縵 + - 縲 + - 纓 + - 驄 + - 繆 + - 繅 + - 耬 + - 瓔 + - 擷 + - 擼 + - 攛 + - 聵 + - 覲 + - 韃 + - 鞽 + - 蘄 + - 賾 + - 檣 + - 靨 + - 魘 + - 饜 + - 轆 + - 齬 + - 齪 + - 覷 + - 顒 + - 躓 + - 躑 + - 蠑 + - 螻 + - 顎 + - 嚕 + - 顓 + - 鑷 + - 鎘 + - 鎸 + - 鎳 + - 鎦 + - 鎰 + - 鎵 + - 鑌 + - 簣 + - 鷂 + - 鯁 + - 鱺 + - 鰱 + - 鰹 + - 鰣 + - 鯀 + - 鯇 + - 觶 + - 饊 + - 饌 + - 齏 + - 讞 + - 襤 + - 譫 + - 屨 + - 纈 + - 繕 + - 繒 + - 驏 + - 擻 + - 顳 + - 顢 + - 藪 + - 櫓 + - 櫞 + - 贋 + - 飆 + - 鏨 + - 轔 + - 蟎 + - 鐯 + - 鏢 + - 鏜 + - 鏝 + - 鏰 + - 鏞 + - 鏑 + - 鏃 + - 鏐 + - 氌 + - 穡 + - 魎 + - 鯪 + - 鯡 + - 鯤 + - 鯧 + - 鯝 + - 鯢 + - 鯛 + - 鯔 + - 獺 + - 鷓 + - 贇 + - 癭 + - 斕 + - 瀨 + - 顙 + - 繾 + - 繰 + - 繯 + - 蘚 + - 鷯 + - 齲 + - 齷 + - 躡 + - 蹣 + - 羈 + - 鐔 + - 鐝 + - 鐐 + - 鐓 + - 鑭 + - 鑹 + - 鏹 + - 鐙 + - 籪 + - 鷦 + - 鱝 + - 鰈 + - 鯷 + - 鰓 + - 鰍 + - 鰉 + - 鯿 + - 鷲 + - 懣 + - 鷸 + - 鰲 + - 韉 + - 顥 + - 鷺 + - 䴉 + - 髏 + - 鑊 + - 鐳 + - 鐲 + - 讎 + - 鰨 + - 鰥 + - 鰩 + - 癩 + - 攢 + - 靄 + - 躥 + - 髖 + - 髕 + - 鑔 + - 籟 + - 鰳 + - 鰾 + - 鱈 + - 鰻 + - 鱅 + - 讖 + - 驥 + - 纘 + - 瓚 + - 鼉 + - 黷 + - 黲 + - 鑣 + - 鑞 + - 臢 + - 鱖 + - 鱔 + - 鱒 + - 驤 + - 顰 + - 鱧 + - 癲 + - 灝 + - 鸛 + - 鑱 + - 趲 + - 顴 + - 躦 + - 饢 + - 戇 + - 戔 + - 訏 + - 訒 + - 釓 + - 俔 + - 閆 + - 澫 + - 訢 + - 訩 + - 詝 + - 紃 + - 纊 + - 瑒 + - 剗 + - 塸 + - 壢 + - 埨 + - 撝 + - 蔿 + - 榪 + - 軑 + - 軏 + - 咼 + - 㠣 + - 覎 + - 㑳 + - 颺 + - 閌 + - 潕 + - 湋 + - 澐 + - 浿 + - 諓 + - 禡 + - 詗 + - 詘 + - 詖 + - 屓 + - 彄 + - 紘 + - 馹 + - 馼 + - 紵 + - 紞 + - 駃 + - 紖 + - 瑲 + - 薴 + - 棡 + - 軝 + - 暐 + - 晛 + - 崬 + - 釴 + - 釤 + - 鍆 + - 鍚 + - 鄶 + - 獮 + - 飿 + - 嶨 + - 詷 + - 詪 + - 鄩 + - 鳲 + - 隑 + - 隮 + - 娙 + - 逕 + - 駓 + - 駔 + - 駉 + - 絅 + - 騶 + - 䮄 + - 紼 + - 紿 + - 瓅 + - 韍 + - 墶 + - 塏 + - 薘 + - 蕘 + - 蔄 + - 葒 + - 鳾 + - 龑 + - 軹 + - 軤 + - 轢 + - 軺 + - 睍 + - 曨 + - 噠 + - 鈃 + - 鈇 + - 鉅 + - 鋹 + - 釿 + - 錀 + - 鈧 + - 鈥 + - 鈄 + - 倈 + - 艤 + - 鶬 + - 颭 + - 餏 + - 湞 + - 溮 + - 滻 + - 褘 + - 絰 + - 駰 + - 絪 + - 駪 + - 綎 + - 綖 + - 驫 + - 勣 + - 璕 + - 𡑍 + - 䓣 + - 薟 + - 藭 + - 椏 + - 梜 + - 頍 + - 硜 + - 輄 + - 輈 + - 輇 + - 貲 + - 嗊 + - 曄 + - 暉 + - 鄳 + - 幬 + - 輋 + - 嶮 + - 贐 + - 鉥 + - 鉕 + - 鑪 + - 鉮 + - 鉊 + - 鉧 + - 僤 + - 鴒 + - 魛 + - 餗 + - 燖 + - 溳 + - 礐 + - 窵 + - 襏 + - 駼 + - 絺 + - 綌 + - 騂 + - 綄 + - 璡 + - 墠 + - 壼 + - 聹 + - 蘀 + - 勩 + - 罃 + - 檮 + - 棶 + - 厴 + - 䃮 + - 磑 + - 礄 + - 鴷 + - 齕 + - 頔 + - 廼 + - 凢 + - 亾 + - 枒 + - 屍 + - 匃 + - 匄 + - 紥 + - 紮 + - 疋 + - 殀 + - 讐 + - 觔 + - 兇 + - 宂 + - 㕥 + - 㠯 + - 栞 + - 佈 + - 佔 + - 呌 + - 敂 + - 冄 + - 坵 + - 僊 + - 怱 + - 悤 + - 冊 + - 夘 + - 戼 + - 牠 + - 妳 + - 嬭 + - 摃 + - 釦 + - 攷 + - 託 + - 衺 + - 衕 + - 弔 + - 喫 + - 囙 + - 㠶 + - 颿 + - 秊 + - 倣 + - 髣 + - 佀 + - 朶 + - 氷 + - 決 + - 併 + - 並 + - 竝 + - 汙 + - 汚 + - 異 + - 姦 + - 廵 + - 挵 + - 衖 + - 搤 + - 阯 + - 撦 + - 埳 + - 阬 + - 誌 + - 㕁 + - 卻 + - 刦 + - 刧 + - 刼 + - 芲 + - 蘤 + - 桿 + - 槓 + - 荳 + - 獃 + - 唫 + - 脗 + - 皁 + - 彿 + - 髴 + - 疘 + - 刪 + - 鉋 + - 鑤 + - 況 + - 牀 + - 恡 + - 棄 + - 洶 + - 汎 + - 災 + - 烖 + - 菑 + - 禩 + - 侷 + - 跼 + - 坿 + - 玅 + - 姉 + - 妬 + - 翫 + - 搨 + - 柺 + - 拕 + - 牴 + - 觝 + - 倖 + - 抝 + - 盃 + - 桮 + - 傑 + - 逩 + - 肎 + - 菓 + - 崐 + - 崑 + - 呪 + - 虖 + - 嘑 + - 謼 + - 詠 + - 㟁 + - 嵒 + - 巗 + - 巖 + - 雰 + - 稈 + - 咊 + - 嶽 + - 妷 + - 姪 + - 廹 + - 徃 + - 餚 + - 採 + - 寀 + - 唸 + - 週 + - 昬 + - 兎 + - 兔 + - 亯 + - 亱 + - 䘚 + - 淨 + - 劵 + - 匟 + - 㳒 + - 灋 + - 洩 + - 霑 + - 淚 + - 註 + - 恠 + - 箒 + - 屆 + - 絃 + - 圅 + - 旾 + - 珎 + - 掛 + - 垜 + - 艸 + - 茘 + - 査 + - 栢 + - 柵 + - 栁 + - 桺 + - 柹 + - 韮 + - 揹 + - 昰 + - 閧 + - 鬨 + - 冐 + - 暎 + - 嚥 + - 倃 + - 𠴰 + - 偺 + - 喒 + - 齩 + - 欬 + - 榘 + - 㑺 + - 儁 + - 敍 + - 敘 + - 肧 + - 脈 + - 䘑 + - 衇 + - 跡 + - 蹟 + - 砲 + - 礮 + - 薙 + - 鬀 + - 恆 + - 怳 + - 卹 + - 䘏 + - 賉 + - 婣 + - 畊 + - 揑 + - 綑 + - 輓 + - 恥 + - 躭 + - 晉 + - 棲 + - 覈 + - 慄 + - 翄 + - 脣 + - 槕 + - 㨪 + - 螡 + - 蟁 + - 㤙 + - 陗 + - 峩 + - 峯 + - 乗 + - 椉 + - 咲 + - 筍 + - 俛 + - 頫 + - 勌 + - 䠶 + - 躳 + - 慇 + - 拏 + - 㧱 + - 挐 + - 脃 + - 胷 + - 肐 + - 貍 + - 㽞 + - 畱 + - 淒 + - 悽 + - 蓆 + - 効 + - 傚 + - 涼 + - 缾 + - 菸 + - 煙 + - 淛 + - 湧 + - 誖 + - 猂 + - 醼 + - 讌 + - 㝠 + - 寃 + - 孃 + - 桒 + - 毬 + - 瑠 + - 璢 + - 瑯 + - 㨗 + - 搥 + - 搯 + - 蔆 + - 惏 + - 楳 + - 槑 + - 捄 + - 廂 + - 慽 + - 慼 + - 瞇 + - 埜 + - 畧 + - 虵 + - 稭 + - 棃 + - 犂 + - 迻 + - 媮 + - 兠 + - 舩 + - 慾 + - 綵 + - 腳 + - 𩓐 + - 夠 + - 豬 + - 貓 + - 湊 + - 減 + - 庻 + - 蔴 + - 菴 + - 朢 + - 睠 + - 觕 + - 麤 + - 釬 + - 銲 + - 痳 + - 殽 + - 婬 + - 滛 + - 湻 + - 㴱 + - 樑 + - 顇 + - 㝛 + - 窰 + - 窯 + - 琹 + - 欵 + - 墖 + - 趂 + - 隄 + - 愽 + - 揷 + - 揫 + - 煑 + - 朞 + - 㪚 + - 塟 + - 蔥 + - 蔕 + - 稜 + - 棊 + - 碁 + - 椶 + - 偪 + - 㕑 + - 廚 + - 廈 + - 鴈 + - 冣 + - 㝡 + - 晳 + - 鼃 + - 餧 + - 餵 + - 嗁 + - 諠 + - 㡌 + - 賸 + - 筴 + - 筞 + - 筩 + - 栰 + - 暠 + - 皜 + - 踰 + - 蝟 + - 㪟 + - 燄 + - 遊 + - 媿 + - 嘅 + - 庽 + - 窓 + - 牎 + - 牕 + - 窻 + - 徧 + - 僱 + - 帬 + - 裠 + - 強 + - 彊 + - 疎 + - 壻 + - 瓌 + - 䰟 + - 皷 + - 擕 + - 㩗 + - 㩦 + - 攜 + - 懃 + - 鞾 + - 幙 + - 㮣 + - 酧 + - 詶 + - 醻 + - 掽 + - 踫 + - 㼝 + - 盌 + - 磟 + - 覩 + - 倸 + - 㬉 + - 煗 + - 煖 + - 晻 + - 闇 + - 炤 + - 跥 + - 䗬 + - 蠭 + - 寘 + - 辠 + - 稺 + - 穉 + - 燬 + - 譭 + - 瘉 + - 癒 + - 顋 + - 骽 + - 猨 + - 蝯 + - 稟 + - 痺 + - 癡 + - 亷 + - 㢘 + - 韻 + - 泝 + - 遡 + - 昚 + - 躶 + - 臝 + - 羣 + - 㬪 + - 曡 + - 疊 + - 勦 + - 琍 + - 瓈 + - 𤋮 + - 熈 + - 牓 + - 搾 + - 謌 + - 堿 + - 鹻 + - 鹼 + - 矁 + - 燻 + - 髈 + - 𤺥 + - 辢 + - 旂 + - 𡚁 + - 潄 + - 砦 + - 詧 + - 嫰 + - 櫈 + - 撐 + - 墪 + - 譔 + - 鞵 + - 鞌 + - 蕋 + - 橤 + - 蘂 + - 醕 + - 譆 + - 跴 + - 蹤 + - 蜨 + - 蠍 + - 稾 + - 殭 + - 惪 + - 厀 + - 襃 + - 癅 + - 䊀 + - 餬 + - 潛 + - 癄 + - 顦 + - 鷰 + - 藷 + - 櫥 + - 螎 + - 蹏 + - 蟇 + - 譟 + - 簒 + - 彫 + - 琱 + - 鵰 + - 餹 + - 餻 + - 簷 + - 粦 + - 燐 + - 緐 + - 幑 + - 蹧 + - 粇 + - 穅 + - 臋 + - 籐 + - 繙 + - 飜 + - 孼 + - 蠏 + - 燿 + - 蝡 + - 稬 + - 穤 + - 惷 + - 覇 + - 鑵 + - 戹 + - 阨 + - 剳 + - 帀 + - 巵 + - 亙 + - 佇 + - 竚 + - 穽 + - 岅 + - 虯 + - 𦍑 + - 羗 + - 啎 + - 姙 + - 㘭 + - 袟 + - 袠 + - 逈 + - 㒺 + - 犛 + - 氂 + - 偘 + - 甕 + - 罋 + - 冺 + - 姍 + - 蝨 + - 琺 + - 瑇 + - 尅 + - 梔 + - 斮 + - 斲 + - 斵 + - 暱 + - 毘 + - 蝱 + - 吚 + - 哶 + - 峝 + - 粃 + - 竢 + - 狥 + - 秈 + - 烱 + - 㳄 + - 袵 + - 盇 + - 涖 + - 蒞 + - 碪 + - 蠔 + - 唕 + - 倐 + - 儵 + - 雋 + - 皐 + - 臯 + - 衂 + - 䶊 + - 臙 + - 獧 + - 痾 + - 皰 + - 湼 + - 澣 + - 濬 + - 塚 + - 襢 + - 娿 + - 勅 + - 勑 + - 戞 + - 廐 + - 廄 + - 眥 + - 覜 + - 勗 + - 啗 + - 噉 + - 傯 + - 挱 + - 㥫 + - 惥 + - 慂 + - 陻 + - 蕚 + - 萲 + - 蕿 + - 蘐 + - 藼 + - 櫂 + - 箠 + - 槨 + - 啑 + - 蹠 + - 蚘 + - 痐 + - 蛕 + - 蜖 + - 瘖 + - 遯 + - 醃 + - 飱 + - 冪 + - 簑 + - 枏 + - 柟 + - 檝 + - 楥 + - 矴 + - 椗 + - 嘷 + - 獋 + - 粺 + - 䈰 + - 諐 + - 齶 + - 堘 + - 疿 + - 雝 + - 秔 + - 稉 + - 槀 + - 搉 + - 廝 + - 叡 + - 嘠 + - 蜋 + - 筯 + - 篛 + - 麞 + - 糉 + - 緥 + - 璿 + - 髥 + - 臕 + - 餈 + - 剹 + - 橜 + - 罇 + - 蜺 + - 矙 + - 憇 + - 翺 + - 饍 + - 瞖 + - 羴 + - 羶 + - 爕 + - 繦 + - 騌 + - 鬉 + - 騣 + - 蔾 + - 䠀 + - 簮 + - 躕 + - 蹵 + - 䝔 + - 貛 + - 鼴 + - 麐 + - 塡 + - あ + - い + - う + - え + - お + - か + - き + - く + - け + - こ + - さ + - し + - す + - せ + - そ + - た + - ち + - つ + - て + - と + - な + - に + - ぬ + - ね + - の + - は + - ひ + - ふ + - へ + - ほ + - ま + - み + - む + - め + - も + - や + - ゆ + - よ + - ら + - り + - る + - れ + - ろ + - わ + - を + - ん + - が + - ぎ + - ぐ + - げ + - ご + - ざ + - じ + - ず + - ぜ + - ぞ + - だ + - ぢ + - づ + - で + - ど + - ば + - び + - ぶ + - べ + - ぼ + - ぱ + - ぴ + - ぷ + - ぺ + - ぽ + - ぁ + - ぃ + - ぅ + - ぇ + - ぉ + - っ + - ゃ + - ゅ + - ょ + - ゎ + - ゕ + - ゖ + - ア + - イ + - ウ + - エ + - オ + - カ + - キ + - ク + - ケ + - コ + - サ + - シ + - ス + - セ + - ソ + - タ + - チ + - ツ + - テ + - ト + - ナ + - ニ + - ヌ + - ネ + - ノ + - ハ + - ヒ + - フ + - ヘ + - ホ + - マ + - ミ + - ム + - メ + - モ + - ヤ + - ユ + - ヨ + - ラ + - リ + - ル + - レ + - ロ + - ワ + - ヲ + - ン + - ガ + - ギ + - グ + - ゲ + - ゴ + - ザ + - ジ + - ズ + - ゼ + - ゾ + - ダ + - ヂ + - ヅ + - デ + - ド + - バ + - ビ + - ブ + - ベ + - ボ + - パ + - ピ + - プ + - ペ + - ポ + - ァ + - ィ + - ゥ + - ェ + - ォ + - ッ + - ャ + - ュ + - ョ + - ヮ + - ヵ + - ヶ + - ヷ + - ヸ + - ヹ + - ヺ + - ・ + - ー + - ヽ + - ヾ + - ヿ + - ｱ + - ｲ + - ｳ + - ｴ + - ｵ + - ｶ + - ｷ + - ｸ + - ｹ + - ｺ + - ｻ + - ｼ + - ｽ + - ｾ + - ｿ + - ﾀ + - ﾁ + - ﾂ + - ﾃ + - ﾄ + - ﾅ + - ﾆ + - ﾇ + - ﾈ + - ﾉ + - ﾊ + - ﾋ + - ﾌ + - ﾍ + - ﾎ + - ﾏ + - ﾐ + - ﾑ + - ﾒ + - ﾓ + - ﾔ + - ﾕ + - ﾖ + - ﾗ + - ﾘ + - ﾙ + - ﾚ + - ﾛ + - ﾜ + - ｦ + - ﾝ + - ﾞ + - ﾟ + - ｧ + - ｨ + - ｩ + - ｪ + - ｫ + - ｯ + - ｬ + - ｭ + - ｮ + - 円 + - 気 + - 糸 + - 絵 + - 楽 + - 帰 + - 戸 + - 広 + - 黒 + - 図 + - 線 + - 読 + - 売 + - 歩 + - 毎 + - 亜 + - 悪 + - 圧 + - 扱 + - 囲 + - 為 + - 壱 + - 隠 + - 栄 + - 営 + - 駅 + - 塩 + - 縁 + - 艶 + - 応 + - 桜 + - 穏 + - 仮 + - 価 + - 箇 + - ゑ + - ゝ + - ゞ + - ヰ + - ヴ + - ㈱ + - 両 + - 丼 + - 丿 + - 亀 + - 仏 + - 伝 + - 侶 + - 俤 + - 値 + - 倶 + - 倹 + - 偐 + - 偽 + - 働 + - 儛 + - 兌 + - 児 + - 冑 + - 冨 + - 凞 + - 処 + - 凪 + - 別 + - 剣 + - 剤 + - 剰 + - 劔 + - 労 + - 勧 + - 勲 + - 匁 + - 匂 + - 匲 + - 卍 + - 単 + - 厳 + - 収 + - 呂 + - 呉 + - 呑 + - 呰 + - 唖 + - 喚 + - 喩 + - 喰 + - 噛 + - 噺 + - 嚢 + - 囃 + - 団 + - 圀 + - 圏 + - 堀 + - 堺 + - 塀 + - 塁 + - 塙 + - 増 + - 墺 + - 壊 + - 壌 + - 壷 + - 変 + - 奨 + - 姫 + - 娯 + - 嫐 + - 嬢 + - 嬾 + - 孁 + - 宍 + - 実 + - 宮 + - 寔 + - 寛 + - 対 + - 専 + - 尭 + - 峠 + - 崋 + - 嶋 + - 巀 + - 巌 + - 巣 + - 巻 + - 帯 + - 幇 + - 庁 + - 廃 + - 廻 + - 弉 + - 弌 + - 弐 + - 弖 + - 弾 + - 従 + - 徳 + - 徴 + - 忯 + - 恵 + - 悩 + - 惣 + - 懐 + - 懽 + - 戦 + - 戯 + - 戻 + - 払 + - 抜 + - 択 + - 拝 + - 拠 + - 拡 + - 拵 + - 挙 + - 挿 + - 捗 + - 捜 + - 掟 + - 掲 + - 掻 + - 揃 + - 換 + - 揺 + - 摂 + - 撃 + - 撹 + - 斉 + - 斎 + - 旛 + - 旡 + - 晧 + - 晩 + - 暁 + - 暦 + - 曽 + - 杁 + - 杢 + - 杣 + - 杮 + - 枓 + - 枠 + - 枡 + - 柾 + - 栂 + - 栃 + - 桝 + - 桟 + - 桾 + - 梛 + - 梱 + - 梲 + - 梶 + - 椙 + - 検 + - 椥 + - 楕 + - 楡 + - 楢 + - 榊 + - 榎 + - 槇 + - 様 + - 槙 + - 槻 + - 樋 + - 権 + - 樫 + - 橿 + - 檥 + - 欅 + - 歎 + - 歓 + - 歯 + - 歳 + - 歴 + - 毀 + - 沖 + - 沢 + - 浄 + - 涙 + - 済 + - 渉 + - 渋 + - 渓 + - 渕 + - 満 + - 滝 + - 漑 + - 潅 + - 澁 + - 瀞 + - 瀬 + - 焔 + - 焼 + - 煇 + - 煕 + - 煥 + - 燗 + - 爼 + - 犠 + - 狛 + - 猟 + - 獏 + - 獣 + - 珊 + - 瑤 + - 甞 + - 畑 + - 畠 + - 畳 + - 畷 + - 畺 + - 痩 + - 癪 + - 発 + - 県 + - 眞 + - 砕 + - 碕 + - 礒 + - 禖 + - 禿 + - 稲 + - 穂 + - 穣 + - 竃 + - 竜 + - 竴 + - 笹 + - 筈 + - 筬 + - 筰 + - 箆 + - 箏 + - 箙 + - 篠 + - 篭 + - 簺 + - 籾 + - 粂 + - 粋 + - 粛 + - 粧 + - 糺 + - 紬 + - 絁 + - 経 + - 絖 + - 絣 + - 絽 + - 継 + - 続 + - 綟 + - 総 + - 縄 + - 縅 + - 縒 + - 縦 + - 繊 + - 繋 + - 繍 + - 繝 + - 繧 + - 纐 + - 纒 + - 罠 + - 罧 + - 罵 + - 羂 + - 羇 + - 羨 + - 聟 + - 聡 + - 聨 + - 聴 + - 脇 + - 脳 + - 膣 + - 膵 + - 臈 + - 臓 + - 臥 + - 舎 + - 舖 + - 舗 + - 舘 + - 芿 + - 苅 + - 茲 + - 荊 + - 荘 + - 莬 + - 莵 + - 菫 + - 萠 + - 蔵 + - 薗 + - 薫 + - 薬 + - 薭 + - 蘊 + - 蛍 + - 蝋 + - 蝿 + - 蟷 + - 衞 + - 衵 + - 袙 + - 袞 + - 袰 + - 袴 + - 袿 + - 裃 + - 裡 + - 裲 + - 褄 + - 褌 + - 襴 + - 襷 + - 覗 + - 覚 + - 覧 + - 観 + - 訳 + - 証 + - 諌 + - 諚 + - 諟 + - 諡 + - 諮 + - 譛 + - 譲 + - 讃 + - 豅 + - 豊 + - 豎 + - 賎 + - 賛 + - 贔 + - 躙 + - 躰 + - 転 + - 軽 + - 輌 + - 辥 + - 辺 + - 辻 + - 込 + - 逓 + - 遅 + - 遙 + - 邉 + - 郷 + - 酔 + - 醗 + - 醤 + - 醸 + - 釈 + - 鉄 + - 鉇 + - 鉤 + - 鉱 + - 鉾 + - 銈 + - 銕 + - 銭 + - 鋲 + - 鋳 + - 鋺 + - 錆 + - 錍 + - 錣 + - 錬 + - 錵 + - 鍑 + - 鍮 + - 鍼 + - 鎌 + - 鎗 + - 鎚 + - 鎹 + - 鐇 + - 鐚 + - 鐡 + - 鑁 + - 鑑 + - 鑚 + - 鑢 + - 閇 + - 関 + - 閦 + - 闘 + - 陥 + - 険 + - 隣 + - 隷 + - 雑 + - 雫 + - 霊 + - 靜 + - 靫 + - 靭 + - 靱 + - 鞄 + - 鞆 + - 頚 + - 頬 + - 頴 + - 頼 + - 顕 + - 顗 + - 餝 + - 饂 + - 駄 + - 駆 + - 駈 + - 騒 + - 験 + - 騨 + - 髄 + - 髙 + - 髪 + - 髷 + - 鯖 + - 鯰 + - 鯱 + - 鰒 + - 鰯 + - 鰰 + - 鳰 + - 鴎 + - 鴫 + - 鵄 + - 鵞 + - 鵺 + - 鶏 + - 鹸 + - 麁 + - 麺 + - 麿 + - 黌 + - 黙 + - 鼈 + - 齢 + - 龗 + - 縯 + - 蟅 + - 坖 + - 祂 + - 鼂 + - 鱚 + - 蛻 + - 屌 + - 呾 + - 煔 + - 吶 + - 扥 + - 蚖 + - 銂 + - 尃 + - 夋 + - 鵼 + - 徬 + - 寳 + - 彡 + - 舨 + - 湳 + - 麼 + - 鍈 + - 崈 + - 鱣 + - 盺 + - 拺 + - 瑥 + - 茷 + - 焻 + - 奀 + - 驎 + - 鱰 + - 砢 + - 痟 + - 廱 + - 僜 + - 瘺 + - 鱊 + - 擥 + - 嶰 + - 淓 + - 跅 + - 浵 + - 媗 + - 璦 + - 煠 + - 檊 + - 媃 + - 峅 + - 躄 + - 鉟 + - 塽 + - 蟴 + - 鯮 + - 弍 + - 烒 + - 鵵 + - 妑 + - 孋 + - 蚡 + - 恊 + - 輭 + - 廞 + - 產 + - 曅 + - 盜 + - 騤 + - 囪 + - 鱀 + - 茇 + - 葊 + - 逹 + - 狓 + - 崢 + - 趖 + - 凃 + - 羙 + - 鮸 + - 昞 + - 楿 + - 渽 + - 圗 + - 麪 + - 屇 + - 鍉 + - 葝 + - 沯 + - 爭 + - 幵 + - 筭 + - 寊 + - 銋 + - 貮 + - 鎭 + - 熺 + - 昜 + - 鍱 + - 墬 + - 愒 + - 磺 + - 嚈 + - 稘 + - 珮 + - 釆 + - 殑 + - 鍩 + - 䲁 + - 蕷 + - 鐿 + - 僡 + - 佹 + - 輶 + - 冴 + - 襶 + - 賔 + - 猙 + - 辧 + - 絛 + - 磾 + - 韁 + - 螔 + - 譳 + - 礑 + - 鋱 + - 魩 + - 嚗 + - 棆 + - 牆 + - 敟 + - 柶 + - 瓛 + - 魣 + - 巎 + - 轘 + - 襌 + - 枼 + - 鸌 + - 逺 + - 錏 + - 縡 + - 帢 + - 騄 + - 媼 + - 埅 + - 鄤 + - 萐 + - 祙 + - 旼 + - 詥 + - 鶲 + - 燉 + - 卲 + - 銱 + - 庲 + - 伱 + - 氽 + - 嵿 + - 挻 + - 煵 + - 窋 + - 鐤 + - 鮊 + - 鱬 + - 鰧 + - 嬤 + - 譞 + - 諲 + - 脭 + - 悳 + - 崘 + - 阭 + - 內 + - 袾 + - 冚 + - 壐 + - 咗 + - 礠 + - 孮 + - 痲 + - 埈 + - 肹 + - 鰮 + - 鮓 + - 濊 + - 塜 + - 凜 + - 蒢 + - 噰 + - 桼 + - 峍 + - 焴 + - 鶒 + - 鋮 + - 綠 + - 鶹 + - 熿 + - 毴 + - 咟 + - 嘥 + - 睺 + - 繡 + - 郎 + - 瘞 + - 鉶 + - 蔎 + - 秠 + - 緤 + - 蝀 + - 躝 + - 蟜 + - 繃 + - 囮 + - 墫 + - 乭 + - 胊 + - 濙 + - 瘓 + - 榣 + - 鑛 + - 鐫 + - 嶴 + - 甹 + - 坮 + - 銾 + - 蒭 + - 睜 + - 俋 + - 餠 + - 榢 + - 蓳 + - 盋 + - 堷 + - 鍏 + - 苝 + - 巛 + - 蚵 + - 暏 + - 熤 + - 嬨 + - 墎 + - 鏽 + - 戶 + - 菺 + - 膮 + - 熖 + - 睪 + - 栜 + - 捱 + - 榗 + - 鍷 + - 曧 + - 犽 + - 韑 + - 袓 + - 䖝 + - 焄 + - 喦 + - 髲 + - 疌 + - 㴪 + - 侊 + - 貐 + - 蕅 + - 禠 + - 蕑 + - 囯 + - 暊 + - 儞 + - 佋 + - 柎 + - 㐱 + - 鰤 + - 苳 + - 鱥 + - 謤 + - 遶 + - 眀 + - 鑀 + - 羋 + - 顏 + - 陜 + - 銩 + - 黶 + - 苼 + - 蒤 + - 棛 + - 儫 + - 咁 + - 抦 + - 衚 + - 棩 + - 焿 + - 脫 + - 麅 + - 玏 + - 埧 + - 淸 + - 黁 + - 淽 + - 彠 + - 鮨 + - 沜 + - 糀 + - 厓 + - 楧 + - 嶌 + - 簹 + - 檵 + - 鱇 + - 嶬 + - 廸 + - 卽 + - 樀 + - 贌 + - 酼 + - 籛 + - 沒 + - 晸 + - 諪 + - 蕡 + - 妏 + - 鄋 + - 蒍 + - 奧 + - 抇 + - 蓨 + - 薆 + - 鱷 + - 巘 + - 䝉 + - 亰 + - 寈 + - 槩 + - 誒 + - 麴 + - 蕟 + - 溎 + - 蘗 + - 榦 + - 斿 + - 暟 + - 炲 + - 拚 + - 娖 + - 繖 + - 橚 + - 寜 + - 爀 + - 饟 + - 悅 + - 鯏 + - 彜 + - 眾 + - 葯 + - 嬝 + - 埮 + - 獇 + - 馛 + - 溙 + - 瀦 + - 熼 + - 硓 + - 鈢 + - 樆 + - 輬 + - 鰜 + - 蔘 + - 渙 + - 澔 + - 嗮 + - 旉 + - 籜 + - 媊 + - 燘 + - 儚 + - 頹 + - 缽 + - 俽 + - 逨 + - 鱓 + - 郞 + - 歊 + - 杴 + - 珡 + - 杋 + - 醁 + - 鰏 + - 鵾 + - 鐽 + - 鮋 + - 巶 + - 荅 + - 薾 + - 囓 + - 蹻 + - 獎 + - 禑 + - 鎓 + - 榲 + - 僴 + - 綞 + - 尓 + - 敭 + - 曔 + - 褔 + - 鬅 + - 亊 + - 鏦 + - 蓘 + - 裬 + - 鱲 + - 薡 + - 鰗 + - 箑 + - 鬪 + - 縂 + - 璸 + - 甙 + - 茮 + - 辵 + - 岻 + - 覿 + - 滈 + - 鯶 + - 鑂 + - 囶 + - 舺 + - 溋 + - 拋 + - 菾 + - 敾 + - 虨 + - 綝 + - 蝍 + - 醂 + - 禨 + - 賹 + - 廧 + - 絕 + - 槗 + - 徫 + - 鎔 + - 曮 + - 蠂 + - 捒 + - 堈 + - 莕 + - 蓪 + - 敎 + - 禃 + - 櫱 + - 綧 + - 瀶 + - 逌 + - 浤 + - 碻 + - 刄 + - 逤 + - 剏 + - 氹 + - 菈 + - 娫 + - 蜛 + - 嵗 + - 糎 + - 螶 + - 譓 + - 鏳 + - 嵙 + - 瑊 + - 隲 + - 檨 + - 緈 + - 畵 + - 砯 + - 簗 + - 彅 + - 鰺 + - 騋 + - 窶 + - 嚒 + - 嵻 + - 尙 + - 頵 + - 槰 + - 虉 + - 醞 + - 巂 + - 彔 + - 偊 + - 畇 + - 鱨 + - 妸 + - 塲 + - 畐 + - 鈫 + - 錟 + - 磪 + - 摠 + - 彥 + - 璙 + - 囝 + - 寗 + - 耎 + - 鮡 + - 蘓 + - 弅 + - 焃 + - 飥 + - 戙 + - 塰 + - 儱 + - 槺 + - 噏 + - 魟 + - 禵 + - 佧 + - 咘 + - 盪 + - 瑈 + - 鉲 + - 睭 + - 鏌 + - 鼇 + - 郋 + - 魮 + - 朖 + - 滽 + - 渃 + - 滙 + - 熯 + - 醿 + - 鎅 + - 褀 + - 鬬 + - 巄 + - 螥 + - 眜 + - 釚 + - 柉 + - 壎 + - 峇 + - 姸 + - 唭 + - 鮜 + - 鈖 + - 嫈 + - 壄 + - 洤 + - 黃 + - 伕 + - 堦 + - 嶔 + - 鮰 + - 鞞 + - 漎 + - 鉓 + - 鮗 + - 壴 + - 阝 + - 妀 + - 矽 + - 獢 + - 倗 + - 銪 + - 鴓 + - 橒 + - 凈 + - 哖 + - 屚 + - 偍 + - 瑺 + - 媯 + - 淍 + - 驌 + - 椇 + - 赬 + - 薐 + - 糹 + - 碽 + - 濲 + - 釭 + - 晭 + - 纕 + - 寖 + - 閞 + - 歿 + - 呎 + - 鶆 + - 屄 + - 櫿 + - 犎 + - 旲 + - 㙟 + - 龎 + - 翜 + - 螾 + - 說 + - 衜 + - 泆 + - 軎 + - 鵂 + - 荎 + - 嚧 + - 硂 + - 桖 + - 褭 + - 筊 + - 鰷 + - 秳 + - 戩 + - 轀 + - 鬹 + - 飬 + - 卋 + - 暸 + - 狦 + - 搢 + - 娋 + - 鏴 + - 溫 + - 毉 + - 淰 + - 謩 + - 餺 + - 鵙 + - 鳽 + - 鮀 + - 狶 + - 氻 + - 轝 + - 妺 + - 袛 + - 蓭 + - 梂 + - 娛 + - 牼 + - 稅 + - 兿 + - 玾 + - 煚 + - 僩 + - 鶿 + - 鬄 + - 崠 + - 鉆 + - 鯓 + - 蚢 + - 庀 + - 鵟 + - 坣 + - 殼 + - 悞 + - 熅 + - 敻 + - 鍠 + - 曶 + - 愼 + - 搳 + - 姃 + - 砳 + - 槼 + - 臞 + - 韾 + - 靑 + - 鸊 + - 薲 + - 虛 + - 蠄 + - 啟 + - 鶺 + - 苺 + - 滾 + - 褞 + - 仺 + - 胇 + - 憻 + - 郳 + - 烉 + - 驩 + - 冇 + - 枖 + - 夌 + - 搵 + - 匸 + - 盨 + - 櫾 + - 霤 + - 麊 + - 貒 + - 噓 + - 嗢 + - 笩 + - 晈 + - 冂 + - 銳 + - 毿 + - 慜 + - 囧 + - 閜 + - 娸 + - 庢 + - 壆 + - 馯 + - 桱 + - 兗 + - 葃 + - 侅 + - 煐 + - 鐦 + - 藸 + - 鷎 + - 嵰 + - 逎 + - 弒 + - 匋 + - 鐭 + - 廔 + - 砩 + - 孆 + - 灴 + - 伷 + - 兪 + - 鴗 + - 澯 + - 幚 + - 旙 + - 勻 + - 礽 + - 婑 + - 鱮 + - 娍 + - 銶 + - 吳 + - 鍟 + - 仼 + - 鳧 + - 彞 + - 娽 + - 昛 + - 鰼 + - 剎 + - 佉 + - 鉏 + - 偸 + - 鰆 + - 讙 + - 橪 + - 啱 + - 岀 + - 孻 + - 釪 + - 乹 + - 鈳 + - 漇 + - 檦 + - 埻 + - 祿 + - 爌 + - 禇 + - 鱵 + - 㸃 + - 梉 + - 燝 + - 霙 + - 炁 + - 飮 + - 蠙 + - 勷 + - 鵎 + - 儥 + - 鐠 + - 唻 + - 廰 + - 嚿 + - 嵕 + - 墱 + - 紑 + - 搖 + - 瘜 + - 皝 + - 鸑 + - 瀁 + - 粵 + - 撚 + - 巑 + - 梀 + - 啯 + - 眛 + - 諴 + - 夊 + - 僙 + - 鍝 + - 裖 + - 鮣 + - 凬 + - 飡 + - 灊 + - 橓 + - 嫳 + - 筳 + - 咑 + - 粍 + - 瓑 + - 璌 + - 伃 + - 閰 + - 傜 + - 黐 + - 謢 + - 驒 + - 橫 + - 蛯 + - 寕 + - 蠵 + - 瞓 + - 旳 + - 翏 + - 硏 + - 寯 + - 韡 + - 楤 + - 鰃 + - 朿 + - 侞 + - 鵯 + - 愨 + - 祹 + - 厔 + - 丌 + - 盩 + - 謏 + - 魕 + - 啣 + - 閱 + - 曺 + - 枛 + - 罉 + - 卐 + - 樻 + - 鷉 + - 鯒 + - 鋡 + - 磱 + - 枱 + - 攴 + - 蠷 + - 穈 + - 嚟 + - 檽 + - 趐 + - 奐 + - 鋐 + - 檇 + - 薀 + - 峼 + - 咭 + - 訔 + - 韠 + - 鑴 + - 鸐 + - 唃 + - 捦 + - 鸜 + - 誴 + - 罳 + - 璄 + - 暃 + - 夀 + - 賨 + - 鞥 + - 鈊 + - 灡 + - 鮍 + - 懮 + - 籣 + - 昐 + - 陁 + - 襾 + - 鮠 + - 鈏 + - 囍 + - 婯 + - 艔 + - 貭 + - 䰾 + - 姁 + - 禼 + - 堖 + - 鋶 + - 仛 + - 鏷 + - 謜 + - 鑅 + - 忬 + - 蘶 + - 謠 + - 觙 + - 奫 + - 狟 + - 泩 + - 桙 + - 飈 + - 垰 + - 啍 + - 嚞 + - 鯕 + - 蒧 + - 榞 + - 徸 + - 璹 + - 揔 + - 欉 + - 魞 + - 菶 + - 玧 + - 鳯 + - 廍 + - 侚 + - 岰 + - 岧 + - 鋕 + - 凵 + - 彣 + - 崱 + - 媜 + - 倢 + - 鵐 + - 砋 + - 鷚 + - 鱠 + - 鮻 + - 繻 + - 摵 + - 贓 + - 磵 + - 錻 + - 痠 + - 粩 + - 胅 + - 奣 + - 塨 + - 瀠 + - 鸘 + - 啚 + - 娳 + - 霶 + - 壔 + - 峚 + - 甂 + - 廁 + - 覌 + - 鰂 + - 猳 + - 鱻 + - 盫 + - 裿 + - 杬 + - 歛 + - 澋 + - 蘞 + - 嵜 + - 尐 + - 旽 + - 鉌 + - 鎛 + - 豿 + - 凖 + - 榤 + - 禓 + - 龝 + - 悧 + - 鷟 + - 鮟 + - 吋 + - 喢 + - 岪 + - 吥 + - 漵 + - 頠 + - 豔 + - 巿 + - 鑨 + - 醣 + - 熳 + - 懍 + - 湥 + - 檡 + - 韺 + - 戱 + - 緖 + - 鐈 + - 凉 + - 緃 + - 鮹 + - 媐 + - 爯 + - 巆 + - 褍 + - 鐬 + - 昍 + - 扙 + - 鍳 + - 芛 + - 蟳 + - 嬅 + - 糬 + - 吔 + - 塭 + - 譿 + - 冧 + - 鏓 + - 嶪 + - 嗹 + - 椵 + - 姀 + - 閿 + - 褧 + - 錞 + - 玆 + - 笘 + - 篔 + - 萡 + - 鶡 + - 螐 + - 鮄 + - 鰟 + - 脷 + - 啲 + - 杤 + - 蓚 + - 尗 + - 娎 + - 殟 + - 淥 + - 蝚 + - 蓧 + - 彐 + - 嚤 + - 銍 + - 囒 + - 坶 + - 淩 + - 鶼 + - 鱂 + - 喼 + - 燫 + - 肏 + - 姵 + - 廌 + - 禟 + - 籝 + - 迵 + - 嵨 + - 堮 + - 蟌 + - 憍 + - 廕 + - 蜑 + - 緁 + - 唘 + - 竩 + - 崙 + - 璚 + - 粄 + - 栨 + - 罈 + - 梫 + - 貤 + - 藔 + - 蜯 + - 訁 + - 斖 + - 煶 + - 馦 + - 妠 + - 閟 + - 疕 + - 夆 + - 鎪 + - 膥 + - 澻 + - 嘢 + - 嚐 + - 靁 + - 鎻 + - 鰛 + - 穵 + - 烋 + - 縕 + - 褎 + - 疒 + - 壠 + - 溼 + - 圂 + - 咅 + - 鯭 + - 鯙 + - 磘 + - 玨 + - 珤 + - 朊 + - 蚼 + - 濶 + - 薞 + - 嚩 + - 丟 + - 嫺 + - 鯻 + - 椲 + - 鰕 + - 刂 + - 蠘 + - 踎 + - 瀴 + - 琁 + - 鰶 + - 瑴 + - 肜 + - 㐂 + - 欥 + - 媺 + - 竻 + - 讚 + - 𣇉 + - 裵 + - 緜 + - 廩 + - 齧 + - 叄 + - 俌 + - 厰 + - 滀 + - 錄 + - 鷫 + - 鯗 + - 攞 + - 姌 + - 蔝 + - 幷 + - 縤 + - 屻 + - 鯃 + - 雞 + - 纁 + - 嫲 + - 嵮 + - 屭 + - 嶃 + - 跩 + - 鋗 + - 蕢 + - 篊 + - 俬 + - 淎 + - 暻 + - 鏻 + - 憓 + - 玗 + - 溈 + - 笭 + - 糢 + - 勳 + - 閒 + - 沍 + - 咾 + - 鉷 + - 蘵 + - 俁 + - 崵 + - 毸 + - 苪 + - 掙 + - 鴡 + - 萭 + - 俴 + - 屜 + - 蒾 + - 艹 + - 剷 + - 慍 + - 朮 + - 枴 + - 氳 + - 猓 + - 甽 + - 箝 + - 譁 + - 贗 + - 迆 + - 鈽 + - 鍊 + - 鍰 + - 鏍 + - 靦 + - 餽 + - 丮 + - 丱 + - 仜 + - 仩 + - 伬 + - 伔 + - 仱 + - 伀 + - 伻 + - 佢 + - 佒 + - 侀 + - 侇 + - 佷 + - 佌 + - 佪 + - 侐 + - 侜 + - 俓 + - 侲 + - 俉 + - 侻 + - 侳 + - 俇 + - 倅 + - 倇 + - 倰 + - 倛 + - 倳 + - 倷 + - 俷 + - 倠 + - 偯 + - 偞 + - 偠 + - 偋 + - 偝 + - 偛 + - 偢 + - 偅 + - 偟 + - 偩 + - 偫 + - 傛 + - 傔 + - 傞 + - 傋 + - 傌 + - 傎 + - 傝 + - 偨 + - 傂 + - 傽 + - 傿 + - 僆 + - 傮 + - 僄 + - 僈 + - 傰 + - 僁 + - 傱 + - 僋 + - 僗 + - 僛 + - 僪 + - 僝 + - 僓 + - 僿 + - 儃 + - 儰 + - 僸 + - 僶 + - 僾 + - 儌 + - 僽 + - 儜 + - 儓 + - 儗 + - 儑 + - 儢 + - 儤 + - 儠 + - 儸 + - 儹 + - 儽 + - 冓 + - 冘 + - 冞 + - 凊 + - 凅 + - 凔 + - 刌 + - 刉 + - 刓 + - 刜 + - 刞 + - 刵 + - 刲 + - 剆 + - 刱 + - 剉 + - 剚 + - 剒 + - 剫 + - 剭 + - 剬 + - 剺 + - 剸 + - 剻 + - 剼 + - 劀 + - 劋 + - 劖 + - 劘 + - 劗 + - 劙 + - 劦 + - 勴 + - 匊 + - 匢 + - 匰 + - 匴 + - 匷 + - 匽 + - 卌 + - 卼 + - 厎 + - 厒 + - 厗 + - 厞 + - 厜 + - 厤 + - 厬 + - 厹 + - 吰 + - 吷 + - 吪 + - 呿 + - 咈 + - 呫 + - 呺 + - 呥 + - 呬 + - 呴 + - 茍 + - 咷 + - 咮 + - 咶 + - 哅 + - 咠 + - 咢 + - 唦 + - 唗 + - 唒 + - 哤 + - 唚 + - 唈 + - 哫 + - 唅 + - 唴 + - 啢 + - 唶 + - 啒 + - 啅 + - 唌 + - 唲 + - 喨 + - 喥 + - 喭 + - 噅 + - 喓 + - 喣 + - 啽 + - 喌 + - 嗃 + - 嗛 + - 嗋 + - 嗀 + - 喿 + - 喍 + - 嗏 + - 嗕 + - 嗈 + - 嘕 + - 嘒 + - 嗼 + - 嘐 + - 嘓 + - 嘂 + - 嗺 + - 嘝 + - 嘄 + - 嗿 + - 噈 + - 噊 + - 噆 + - 噚 + - 嘳 + - 嘽 + - 嘾 + - 噮 + - 噳 + - 噣 + - 噭 + - 噞 + - 嚌 + - 嚍 + - 嚃 + - 嚘 + - 嚜 + - 嚫 + - 嚪 + - 嚬 + - 嚲 + - 嚵 + - 嚽 + - 嚾 + - 囆 + - 囅 + - 囋 + - 囗 + - 圁 + - 圞 + - 圠 + - 坁 + - 坅 + - 坲 + - 坱 + - 垀 + - 坴 + - 垗 + - 垝 + - 垔 + - 垘 + - 垽 + - 垼 + - 埢 + - 埶 + - 堩 + - 堣 + - 塈 + - 堥 + - 塓 + - 塉 + - 塯 + - 塕 + - 塼 + - 墆 + - 塿 + - 塴 + - 墋 + - 塺 + - 墝 + - 墯 + - 壈 + - 墽 + - 壖 + - 壝 + - 壛 + - 壾 + - 壿 + - 夃 + - 夎 + - 夒 + - 夗 + - 奅 + - 奊 + - 奰 + - 奲 + - 奼 + - 妦 + - 妎 + - 妢 + - 妐 + - 妵 + - 姏 + - 姎 + - 㚷 + - 姡 + - 姺 + - 姼 + - 娭 + - 婐 + - 婟 + - 婥 + - 婓 + - 婗 + - 媔 + - 媟 + - 媢 + - 婸 + - 媦 + - 媥 + - 媬 + - 媕 + - 娷 + - 嫇 + - 嫋 + - 媰 + - 媻 + - 嫮 + - 嫥 + - 嫢 + - 嫛 + - 嫿 + - 嫴 + - 嫷 + - 嫶 + - 嬎 + - 嬓 + - 嬐 + - 嬲 + - 嬽 + - 孈 + - 屘 + - 孲 + - 孷 + - 宎 + - 宨 + - 寪 + - 寍 + - 寋 + - 寑 + - 寙 + - 寠 + - 寱 + - 尌 + - 尒 + - 尟 + - 尰 + - 尳 + - 屖 + - 屔 + - 屝 + - 屧 + - 屩 + - 屮 + - 屴 + - 岏 + - 岋 + - 岉 + - 岒 + - 岮 + - 岤 + - 岯 + - 岟 + - 岝 + - 峐 + - 峌 + - 峞 + - 峉 + - 峊 + - 峬 + - 峮 + - 峷 + - 崝 + - 崨 + - 崥 + - 崏 + - 崰 + - 崣 + - 崷 + - 嵃 + - 嵑 + - 崳 + - 崺 + - 嵂 + - 嵱 + - 嵣 + - 嵥 + - 嵞 + - 嶀 + - 嵽 + - 嶆 + - 嵺 + - 嵷 + - 嶊 + - 嶉 + - 嶈 + - 嵾 + - 嶕 + - 嶜 + - 嶡 + - 嶚 + - 嶞 + - 嶱 + - 嶩 + - 嶵 + - 嶭 + - 巃 + - 巏 + - 巕 + - 巟 + - 巹 + - 帊 + - 帗 + - 帟 + - 帣 + - 帠 + - 帤 + - 帩 + - 帾 + - 帴 + - 幏 + - 幎 + - 幓 + - 幩 + - 幝 + - 幠 + - 幧 + - 幨 + - 幦 + - 幭 + - 幰 + - 庂 + - 庉 + - 庌 + - 庈 + - 庰 + - 庛 + - 庣 + - 庨 + - 庮 + - 庪 + - 庬 + - 庴 + - 廅 + - 廇 + - 廘 + - 廗 + - 廎 + - 廜 + - 緳 + - 廦 + - 廥 + - 廮 + - 廯 + - 蠯 + - 廾 + - 弚 + - 弝 + - 弣 + - 弤 + - 弮 + - 弳 + - 彃 + - 彉 + - 彋 + - 彏 + - 彯 + - 彴 + - 彸 + - 彾 + - 徦 + - 徥 + - 徯 + - 徲 + - 徾 + - 徿 + - 忀 + - 忁 + - 忔 + - 忕 + - 忨 + - 忣 + - 忷 + - 忥 + - 怭 + - 怲 + - 怋 + - 怴 + - 怗 + - 怚 + - 怞 + - 怬 + - 怢 + - 怐 + - 怮 + - 怓 + - 怷 + - 怹 + - 恲 + - 恞 + - 恅 + - 恇 + - 恉 + - 恛 + - 恌 + - 恀 + - 恟 + - 悀 + - 悁 + - 悕 + - 悗 + - 悇 + - 悊 + - 悐 + - 悾 + - 悺 + - 惓 + - 惤 + - 惈 + - 悷 + - 惉 + - 悹 + - 惌 + - 惢 + - 惄 + - 愊 + - 愖 + - 愅 + - 惵 + - 愓 + - 惸 + - 惼 + - 惾 + - 慉 + - 慅 + - 愶 + - 愲 + - 愮 + - 愯 + - 愬 + - 慁 + - 慞 + - 慱 + - 慒 + - 慓 + - 慲 + - 憀 + - 慴 + - 慔 + - 慺 + - 慛 + - 憃 + - 慹 + - 憱 + - 憰 + - 憢 + - 憉 + - 憛 + - 憯 + - 憟 + - 憪 + - 憡 + - 憝 + - 憖 + - 懅 + - 憴 + - 懆 + - 懁 + - 憿 + - 憸 + - 憵 + - 憼 + - 懧 + - 懠 + - 懥 + - 懤 + - 懘 + - 懭 + - 懱 + - 懪 + - 懰 + - 懫 + - 懻 + - 戁 + - 戃 + - 戄 + - 戉 + - 戠 + - 酨 + - 戺 + - 扐 + - 扜 + - 扤 + - 扡 + - 扢 + - 抆 + - 抌 + - 抎 + - 抏 + - 扻 + - 抭 + - 抴 + - 拑 + - 抾 + - 抪 + - 抶 + - 抮 + - 挍 + - 挋 + - 挃 + - 拫 + - 拹 + - 挏 + - 挌 + - 拸 + - 挀 + - 拲 + - 捖 + - 挬 + - 挶 + - 揤 + - 捊 + - 挼 + - 挩 + - 捁 + - 挴 + - 捘 + - 捔 + - 捥 + - 掝 + - 掗 + - 掫 + - 掯 + - 捵 + - 掜 + - 捼 + - 掤 + - 掔 + - 掱 + - 揎 + - 揥 + - 揨 + - 揯 + - 揊 + - 揲 + - 揵 + - 摡 + - 揟 + - 揝 + - 揜 + - 揘 + - 揅 + - 揱 + - 搆 + - 搟 + - 搕 + - 搘 + - 搹 + - 搷 + - 搣 + - 搰 + - 搊 + - 搚 + - 摀 + - 搧 + - 搫 + - 摍 + - 摝 + - 摲 + - 摦 + - 摎 + - 摋 + - 摓 + - 摐 + - 摿 + - 摮 + - 摰 + - 撢 + - 撠 + - 撗 + - 撜 + - 撋 + - 撊 + - 撌 + - 撟 + - 擗 + - 擖 + - 擏 + - 擉 + - 撽 + - 擩 + - 擣 + - 擫 + - 擭 + - 擨 + - 擽 + - 擸 + - 攇 + - 攐 + - 攍 + - 攌 + - 攗 + - 攕 + - 攓 + - 攡 + - 攠 + - 攦 + - 攩 + - 攭 + - 攲 + - 攳 + - 敁 + - 敊 + - 敆 + - 敓 + - 敧 + - 敪 + - 敤 + - 敜 + - 敯 + - 敳 + - 敶 + - 敺 + - 敹 + - 敿 + - 斁 + - 斀 + - 斄 + - 斒 + - 斔 + - 斞 + - 斨 + - 斪 + - 斻 + - 旍 + - 旓 + - 旚 + - 旝 + - 旟 + - 昲 + - 昦 + - 昢 + - 晇 + - 晥 + - 晜 + - 晼 + - 晬 + - 暀 + - 暆 + - 暍 + - 暋 + - 暡 + - 暰 + - 暩 + - 曀 + - 曊 + - 曋 + - 曏 + - 曒 + - 曚 + - 曣 + - 曭 + - 朁 + - 朅 + - 朄 + - 朒 + - 朘 + - 朣 + - 朾 + - 朹 + - 朻 + - 朼 + - 杅 + - 杇 + - 杝 + - 杗 + - 枎 + - 杶 + - 枆 + - 枌 + - 柲 + - 枺 + - 枻 + - 柸 + - 柀 + - 柅 + - 柫 + - 柤 + - 柍 + - 柮 + - 柣 + - 柂 + - 柧 + - 栚 + - 桋 + - 桏 + - 栱 + - 栵 + - 栫 + - 栭 + - 栯 + - 栘 + - 栔 + - 梡 + - 梇 + - 梐 + - 桭 + - 梮 + - 楖 + - 梬 + - 梩 + - 桵 + - 梒 + - 椌 + - 椄 + - 棜 + - 棷 + - 棳 + - 棌 + - 椈 + - 楰 + - 棯 + - 椔 + - 棸 + - 楟 + - 楎 + - 楱 + - 楅 + - 楺 + - 楈 + - 楛 + - 楉 + - 楬 + - 椳 + - 楀 + - 楄 + - 楶 + - 楘 + - 榶 + - 槉 + - 榠 + - 榬 + - 榼 + - 榙 + - 榩 + - 榾 + - 榯 + - 槄 + - 榽 + - 榹 + - 槥 + - 槸 + - 樕 + - 樠 + - 槬 + - 槢 + - 樛 + - 樝 + - 槾 + - 樧 + - 槮 + - 樔 + - 槷 + - 橀 + - 樴 + - 橉 + - 橧 + - 樲 + - 橨 + - 橝 + - 橭 + - 橶 + - 樿 + - 橁 + - 檍 + - 檖 + - 檁 + - 檟 + - 橾 + - 檛 + - 檓 + - 檕 + - 檃 + - 櫅 + - 檹 + - 櫡 + - 櫠 + - 櫌 + - 櫑 + - 櫙 + - 櫋 + - 櫜 + - 櫐 + - 櫫 + - 櫬 + - 櫰 + - 櫹 + - 櫺 + - 櫼 + - 欃 + - 欋 + - 欈 + - 欐 + - 欑 + - 欘 + - 欨 + - 欴 + - 欯 + - 欭 + - 欱 + - 欶 + - 欳 + - 欷 + - 欿 + - 歂 + - 歈 + - 歍 + - 歋 + - 歕 + - 歔 + - 歜 + - 歠 + - 歭 + - 歾 + - 肂 + - 殈 + - 殏 + - 殔 + - 殗 + - 殙 + - 殠 + - 殥 + - 殢 + - 殦 + - 殧 + - 殰 + - 殶 + - 毃 + - 毄 + - 毈 + - 毇 + - 毊 + - 毚 + - 毞 + - 毦 + - 毤 + - 毨 + - 毣 + - 毰 + - 毲 + - 毻 + - 毼 + - 毾 + - 氁 + - 氀 + - 氄 + - 氠 + - 氶 + - 汃 + - 汒 + - 汏 + - 汍 + - 汸 + - 沋 + - 汱 + - 汯 + - 沕 + - 汦 + - 汳 + - 泬 + - 沶 + - 沬 + - 泧 + - 沷 + - 泭 + - 泲 + - 泒 + - 沴 + - 洟 + - 洊 + - 洀 + - 浺 + - 浶 + - 洍 + - 涒 + - 浘 + - 浢 + - 涊 + - 涆 + - 浧 + - 涗 + - 涳 + - 涬 + - 淢 + - 涷 + - 淔 + - 渀 + - 淈 + - 涾 + - 淊 + - 涽 + - 淭 + - 湆 + - 湇 + - 湅 + - 湢 + - 渿 + - 湁 + - 渜 + - 渳 + - 湀 + - 渻 + - 渮 + - 湨 + - 湡 + - 渱 + - 渨 + - 湠 + - 湱 + - 湩 + - 渹 + - 溛 + - 滖 + - 溓 + - 溔 + - 滒 + - 溰 + - 溾 + - 滜 + - 滵 + - 滱 + - 漃 + - 漥 + - 漮 + - 潎 + - 漙 + - 漧 + - 漘 + - 漒 + - 滭 + - 漊 + - 潳 + - 滮 + - 潀 + - 漰 + - 潃 + - 漅 + - 濆 + - 澒 + - 澅 + - 潚 + - 潠 + - 澖 + - 潶 + - 潬 + - 潒 + - 潐 + - 潗 + - 澓 + - 潝 + - 濇 + - 濎 + - 濈 + - 濄 + - 澞 + - 澨 + - 瀄 + - 濌 + - 澩 + - 濴 + - 濔 + - 濣 + - 濭 + - 濧 + - 濦 + - 瀇 + - 瀎 + - 濿 + - 瀀 + - 濻 + - 瀙 + - 瀖 + - 瀫 + - 瀡 + - 瀢 + - 瀩 + - 瀯 + - 瀷 + - 灂 + - 瀸 + - 瀿 + - 瀺 + - 灄 + - 灉 + - 灖 + - 灗 + - 灛 + - 灟 + - 灨 + - 灩 + - 灪 + - 炾 + - 炰 + - 烓 + - 烑 + - 缹 + - 焍 + - 烰 + - 焠 + - 焮 + - 焣 + - 煆 + - 煣 + - 煝 + - 熐 + - 熉 + - 熀 + - 熂 + - 熚 + - 燅 + - 燂 + - 熸 + - 燀 + - 燡 + - 爁 + - 爊 + - 爂 + - 爓 + - 爞 + - 爢 + - 爣 + - 牄 + - 牉 + - 牋 + - 牏 + - 牣 + - 牬 + - 牰 + - 牸 + - 牷 + - 犈 + - 犉 + - 犆 + - 犅 + - 犌 + - 犑 + - 犐 + - 犗 + - 犕 + - 犓 + - 犘 + - 犚 + - 犝 + - 犞 + - 犥 + - 犦 + - 犤 + - 犣 + - 犩 + - 犪 + - 犮 + - 犵 + - 犿 + - 狆 + - 狖 + - 狋 + - 狘 + - 狜 + - 狔 + - 狚 + - 狌 + - 狑 + - 狊 + - 狤 + - 狫 + - 狪 + - 狣 + - 猀 + - 狾 + - 猑 + - 猘 + - 猈 + - 狿 + - 猏 + - 猋 + - 猒 + - 猧 + - 猲 + - 猭 + - 猦 + - 猣 + - 猵 + - 猼 + - 獂 + - 獀 + - 獊 + - 獑 + - 獌 + - 獘 + - 獞 + - 獟 + - 獝 + - 獛 + - 獡 + - 獩 + - 獦 + - 獥 + - 獳 + - 獶 + - 獽 + - 獿 + - 玂 + - 玁 + - 玈 + - 玊 + - 玔 + - 珓 + - 珶 + - 琖 + - 瑵 + - 璊 + - 瑽 + - 璅 + - 瑿 + - 璗 + - 瓁 + - 瓋 + - 瓝 + - 瓟 + - 瓡 + - 瓥 + - 瓨 + - 瓬 + - 瓵 + - 瓾 + - 瓽 + - 甀 + - 甃 + - 甈 + - 甋 + - 甐 + - 甒 + - 甔 + - 甖 + - 甝 + - 甮 + - 甿 + - 畟 + - 畣 + - 畽 + - 疀 + - 疧 + - 痁 + - 疻 + - 痀 + - 痎 + - 痏 + - 痋 + - 痌 + - 痑 + - 痚 + - 痡 + - 痝 + - 痗 + - 痯 + - 瘏 + - 痷 + - 痸 + - 痻 + - 瘈 + - 瘑 + - 瘝 + - 瘣 + - 瘯 + - 瘱 + - 瘽 + - 癈 + - 癉 + - 癙 + - 癐 + - 癓 + - 癠 + - 癵 + - 癹 + - 皊 + - 皏 + - 皫 + - 皯 + - 皵 + - 皻 + - 皽 + - 皾 + - 盄 + - 盓 + - 盝 + - 盬 + - 盭 + - 盳 + - 眃 + - 眅 + - 盻 + - 眝 + - 眐 + - 眓 + - 眒 + - 眣 + - 眑 + - 眕 + - 眹 + - 眱 + - 眲 + - 眴 + - 眳 + - 眽 + - 睆 + - 睅 + - 睊 + - 睋 + - 睌 + - 睕 + - 睟 + - 睒 + - 睖 + - 睩 + - 睧 + - 睔 + - 瞁 + - 睼 + - 瞂 + - 睮 + - 睯 + - 瞏 + - 瞉 + - 瞚 + - 瞝 + - 瞡 + - 瞛 + - 瞲 + - 瞷 + - 瞶 + - 瞴 + - 矂 + - 矉 + - 矊 + - 矌 + - 矎 + - 矏 + - 矐 + - 矔 + - 矕 + - 矘 + - 矠 + - 矱 + - 矲 + - 矹 + - 矺 + - 砅 + - 砐 + - 砏 + - 砎 + - 砨 + - 硈 + - 硉 + - 硠 + - 硥 + - 硱 + - 硰 + - 硩 + - 碔 + - 碄 + - 碅 + - 碆 + - 硾 + - 碫 + - 碞 + - 磍 + - 磌 + - 磎 + - 磈 + - 磃 + - 磝 + - 磩 + - 磥 + - 磞 + - 磛 + - 磳 + - 磼 + - 磿 + - 礔 + - 礉 + - 礝 + - 礛 + - 礜 + - 礥 + - 礣 + - 礧 + - 礨 + - 礭 + - 礿 + - 祌 + - 祅 + - 祔 + - 祒 + - 祑 + - 祤 + - 祩 + - 祪 + - 祣 + - 祫 + - 祡 + - 祴 + - 祳 + - 禂 + - 禗 + - 禜 + - 禫 + - 禭 + - 禬 + - 禴 + - 禷 + - 禸 + - 歶 + - 秅 + - 秏 + - 秖 + - 秎 + - 秮 + - 秪 + - 秺 + - 秶 + - 稊 + - 稒 + - 稫 + - 穊 + - 稰 + - 稯 + - 穋 + - 穛 + - 穖 + - 穧 + - 穨 + - 穮 + - 穬 + - 穭 + - 穱 + - 穾 + - 窆 + - 窉 + - 窌 + - 窏 + - 窔 + - 窐 + - 窙 + - 窢 + - 窞 + - 窫 + - 窲 + - 窴 + - 窱 + - 窾 + - 竀 + - 竁 + - 竷 + - 笐 + - 笓 + - 笅 + - 笵 + - 笻 + - 笴 + - 笰 + - 笢 + - 笝 + - 笲 + - 筄 + - 筡 + - 箈 + - 箊 + - 箌 + - 箛 + - 箎 + - 箘 + - 箄 + - 箷 + - 箾 + - 篎 + - 箯 + - 箹 + - 篞 + - 篣 + - 篧 + - 篕 + - 篨 + - 篹 + - 簅 + - 篲 + - 篿 + - 篻 + - 簎 + - 篴 + - 簂 + - 簁 + - 篸 + - 篽 + - 簜 + - 簩 + - 簙 + - 簭 + - 簦 + - 簨 + - 簢 + - 簥 + - 簳 + - 簼 + - 簬 + - 簻 + - 籉 + - 籈 + - 籊 + - 籔 + - 籗 + - 籧 + - 籦 + - 籯 + - 籺 + - 籸 + - 籹 + - 粊 + - 粔 + - 粻 + - 糔 + - 糪 + - 糱 + - 糷 + - 紎 + - 紟 + - 紒 + - 紽 + - 紸 + - 紶 + - 紩 + - 絇 + - 紾 + - 絘 + - 絯 + - 絓 + - 絧 + - 絏 + - 絭 + - 絫 + - 綀 + - 綍 + - 絿 + - 綅 + - 絻 + - 絼 + - 綔 + - 綷 + - 緂 + - 綪 + - 緀 + - 緅 + - 緎 + - 緆 + - 緌 + - 綯 + - 綼 + - 緷 + - 緛 + - 緪 + - 緧 + - 縃 + - 緺 + - 緶 + - 緰 + - 縗 + - 縌 + - 縓 + - 縎 + - 縜 + - 縚 + - 縏 + - 縼 + - 繂 + - 縳 + - 顈 + - 繈 + - 縸 + - 縪 + - 繉 + - 繀 + - 縩 + - 緵 + - 縰 + - 縿 + - 縶 + - 繜 + - 繐 + - 繣 + - 繘 + - 繢 + - 繟 + - 繑 + - 繠 + - 繶 + - 繵 + - 繸 + - 繷 + - 繺 + - 繲 + - 繴 + - 纀 + - 纇 + - 纋 + - 纆 + - 纑 + - 纗 + - 纚 + - 缿 + - 罊 + - 罏 + - 罜 + - 罞 + - 罝 + - 罛 + - 罣 + - 罥 + - 罦 + - 罭 + - 罫 + - 罬 + - 罻 + - 罼 + - 罺 + - 罿 + - 羃 + - 羉 + - 羍 + - 羒 + - 羜 + - 羛 + - 羢 + - 羠 + - 羦 + - 羬 + - 羭 + - 羵 + - 羳 + - 羷 + - 羺 + - 羾 + - 翋 + - 翍 + - 翐 + - 翑 + - 翇 + - 翢 + - 翣 + - 翭 + - 翪 + - 翨 + - 翴 + - 翲 + - 翽 + - 翿 + - 耟 + - 耞 + - 耡 + - 耴 + - 耾 + - 耹 + - 聇 + - 聈 + - 聑 + - 聏 + - 聝 + - 肕 + - 肙 + - 肒 + - 肣 + - 肵 + - 胘 + - 胑 + - 胐 + - 胕 + - 胉 + - 胏 + - 胹 + - 胵 + - 脁 + - 胻 + - 脀 + - 胾 + - 胔 + - 脰 + - 脥 + - 脤 + - 脙 + - 脡 + - 脕 + - 脧 + - 腃 + - 腏 + - 腄 + - 腇 + - 脽 + - 腍 + - 腤 + - 腷 + - 腜 + - 腛 + - 腢 + - 腲 + - 朡 + - 腞 + - 腶 + - 膉 + - 膆 + - 膃 + - 膇 + - 膍 + - 膌 + - 膋 + - 膟 + - 膕 + - 膢 + - 膱 + - 膹 + - 膫 + - 膰 + - 膬 + - 膴 + - 膲 + - 臇 + - 膷 + - 臄 + - 臅 + - 臒 + - 臐 + - 臗 + - 臛 + - 臡 + - 臦 + - 臩 + - 臮 + - 臲 + - 臷 + - 臸 + - 臿 + - 舋 + - 舑 + - 舕 + - 舝 + - 舡 + - 舼 + - 舽 + - 艀 + - 艂 + - 艓 + - 艒 + - 艐 + - 艑 + - 艕 + - 艛 + - 艵 + - 艼 + - 芀 + - 芐 + - 芅 + - 芓 + - 芔 + - 苀 + - 芚 + - 芵 + - 芧 + - 芞 + - 芺 + - 苙 + - 苨 + - 苖 + - 苬 + - 苲 + - 苵 + - 苶 + - 茙 + - 茥 + - 茿 + - 茦 + - 茢 + - 荂 + - 茪 + - 荍 + - 茖 + - 茤 + - 茠 + - 茩 + - 茻 + - 莐 + - 莣 + - 莍 + - 荺 + - 莤 + - 荴 + - 莏 + - 莁 + - 荵 + - 莔 + - 莃 + - 莌 + - 莋 + - 荾 + - 莥 + - 菨 + - 萒 + - 菧 + - 菤 + - 菆 + - 菣 + - 菿 + - 菋 + - 菎 + - 菵 + - 萉 + - 菞 + - 菳 + - 菕 + - 蓱 + - 萿 + - 葹 + - 葥 + - 葀 + - 葧 + - 萰 + - 葍 + - 葽 + - 蔇 + - 葞 + - 萷 + - 萺 + - 萴 + - 葅 + - 菙 + - 葋 + - 萯 + - 葂 + - 葟 + - 葌 + - 蓎 + - 蒬 + - 蒮 + - 蒫 + - 蒪 + - 蒚 + - 蒝 + - 蓌 + - 蒛 + - 蒩 + - 蒘 + - 蒶 + - 蒠 + - 蔤 + - 蔏 + - 蔩 + - 蔉 + - 蔍 + - 蔧 + - 蔜 + - 蓻 + - 蓺 + - 蓴 + - 蔪 + - 蓲 + - 蓷 + - 蓫 + - 蔒 + - 蓩 + - 蔖 + - 蓾 + - 蔨 + - 蔮 + - 蔂 + - 蓶 + - 蔱 + - 蓹 + - 蔠 + - 蔰 + - 蕫 + - 蕍 + - 蕀 + - 蕆 + - 蕄 + - 蕇 + - 蕣 + - 蕛 + - 蕱 + - 蕵 + - 蕮 + - 蕧 + - 蕠 + - 蕦 + - 蕝 + - 薃 + - 薧 + - 薕 + - 薠 + - 薋 + - 薣 + - 薚 + - 蕼 + - 薉 + - 蕸 + - 薎 + - 薖 + - 薍 + - 薝 + - 薂 + - 藆 + - 藀 + - 藃 + - 藂 + - 薵 + - 薽 + - 藇 + - 藄 + - 藋 + - 藈 + - 藅 + - 薱 + - 薶 + - 藒 + - 藫 + - 藱 + - 藙 + - 藡 + - 藚 + - 藗 + - 藲 + - 藬 + - 藘 + - 藣 + - 藑 + - 藰 + - 蘁 + - 藾 + - 蘛 + - 蘉 + - 蘌 + - 蘪 + - 蘦 + - 蘟 + - 蘣 + - 蘜 + - 蘙 + - 蘮 + - 蘡 + - 蘠 + - 蘥 + - 蘴 + - 蘳 + - 蘬 + - 虀 + - 蘹 + - 蘱 + - 蘻 + - 蘾 + - 虃 + - 虆 + - 虇 + - 虈 + - 虌 + - 虋 + - 虙 + - 虡 + - 虣 + - 虩 + - 虪 + - 虰 + - 虭 + - 虴 + - 蚑 + - 蚞 + - 蚇 + - 蚗 + - 蚚 + - 蚅 + - 蚥 + - 蚙 + - 蚿 + - 蚷 + - 蛂 + - 蛁 + - 蛅 + - 蛈 + - 蚹 + - 蚳 + - 蚸 + - 蛌 + - 蚻 + - 蛢 + - 蛦 + - 蛓 + - 蛣 + - 蛚 + - 蛪 + - 蛝 + - 蛫 + - 蛜 + - 蛬 + - 蛗 + - 蜄 + - 蛷 + - 蜌 + - 蛖 + - 蛵 + - 蜁 + - 蛶 + - 蜳 + - 蝫 + - 蜙 + - 蝃 + - 蜬 + - 蝁 + - 蝆 + - 蜠 + - 蜲 + - 蜪 + - 蜭 + - 蜼 + - 蜵 + - 蝂 + - 蜦 + - 蜧 + - 蜸 + - 蜤 + - 蜰 + - 蝖 + - 蝷 + - 蟡 + - 蝳 + - 蝔 + - 蝛 + - 蝒 + - 蝑 + - 蝞 + - 蝭 + - 蝪 + - 蝐 + - 蝝 + - 蝬 + - 蝺 + - 蝜 + - 螛 + - 螏 + - 螓 + - 螒 + - 螁 + - 螖 + - 螘 + - 蝹 + - 螇 + - 螑 + - 螝 + - 螜 + - 螚 + - 螪 + - 螰 + - 螹 + - 螼 + - 螮 + - 蟉 + - 蟃 + - 蟂 + - 螷 + - 螴 + - 螿 + - 螸 + - 蟞 + - 蟧 + - 蟦 + - 蟢 + - 蟟 + - 蟤 + - 蟔 + - 蟓 + - 蟭 + - 蟘 + - 螤 + - 蟗 + - 蟙 + - 蠁 + - 蟨 + - 蠀 + - 蟺 + - 蠉 + - 蠌 + - 蟼 + - 蠈 + - 蟿 + - 蠗 + - 蠩 + - 蠝 + - 蠛 + - 蠠 + - 蠤 + - 蠜 + - 蠫 + - 蠬 + - 蠨 + - 蠦 + - 蠪 + - 蠥 + - 蠰 + - 蠮 + - 蠳 + - 蠸 + - 蠾 + - 蠽 + - 蠿 + - 衁 + - 衈 + - 衋 + - 衧 + - 衪 + - 衭 + - 衶 + - 袀 + - 衱 + - 衯 + - 袃 + - 袉 + - 袕 + - 袨 + - 袚 + - 袑 + - 袡 + - 袘 + - 袧 + - 袬 + - 袌 + - 袺 + - 裗 + - 袹 + - 袸 + - 裀 + - 袶 + - 袽 + - 袲 + - 裋 + - 裍 + - 裞 + - 裚 + - 裷 + - 裧 + - 裺 + - 裮 + - 裶 + - 裯 + - 裻 + - 褁 + - 褅 + - 褋 + - 褗 + - 褆 + - 褖 + - 褑 + - 褦 + - 褮 + - 褱 + - 褢 + - 褩 + - 褵 + - 褼 + - 褾 + - 襒 + - 褷 + - 襂 + - 褽 + - 襓 + - 襋 + - 襆 + - 襐 + - 襛 + - 襗 + - 襡 + - 襘 + - 襝 + - 襣 + - 襭 + - 襩 + - 襮 + - 襳 + - 襹 + - 襺 + - 覂 + - 覅 + - 覕 + - 覛 + - 覝 + - 覢 + - 覤 + - 覣 + - 覭 + - 覮 + - 覶 + - 觓 + - 觤 + - 觡 + - 觠 + - 觢 + - 觩 + - 觰 + - 觬 + - 觲 + - 觷 + - 觺 + - 觻 + - 觼 + - 觾 + - 訑 + - 訰 + - 訧 + - 訬 + - 訞 + - 詍 + - 訹 + - 詙 + - 詀 + - 詄 + - 詅 + - 訿 + - 誂 + - 詻 + - 誃 + - 誫 + - 誙 + - 誋 + - 諆 + - 誸 + - 諔 + - 諕 + - 誻 + - 諀 + - 諅 + - 諵 + - 諝 + - 諰 + - 諈 + - 謞 + - 謘 + - 謑 + - 謋 + - 謒 + - 謕 + - 謍 + - 謈 + - 謪 + - 謧 + - 謣 + - 謰 + - 謵 + - 譇 + - 謯 + - 謱 + - 謥 + - 謷 + - 謦 + - 譐 + - 譈 + - 譊 + - 譀 + - 譋 + - 譕 + - 譑 + - 譠 + - 譪 + - 譝 + - 譨 + - 譣 + - 譥 + - 譹 + - 譸 + - 譅 + - 譺 + - 譻 + - 譾 + - 讄 + - 讂 + - 讆 + - 讋 + - 讔 + - 讘 + - 讟 + - 谹 + - 谻 + - 谽 + - 谾 + - 豃 + - 豋 + - 豍 + - 豏 + - 豗 + - 豜 + - 豝 + - 豟 + - 豥 + - 豤 + - 豦 + - 豭 + - 豰 + - 豲 + - 豱 + - 豯 + - 豵 + - 豷 + - 豶 + - 豻 + - 豽 + - 貁 + - 貀 + - 貄 + - 貏 + - 貑 + - 貕 + - 貙 + - 貗 + - 貜 + - 貣 + - 貾 + - 賌 + - 賥 + - 賟 + - 賙 + - 賵 + - 賮 + - 贆 + - 贕 + - 贙 + - 赨 + - 赩 + - 赮 + - 赸 + - 趀 + - 趌 + - 趎 + - 趏 + - 趍 + - 趓 + - 趠 + - 趜 + - 趡 + - 趥 + - 趧 + - 趬 + - 趪 + - 趭 + - 趫 + - 趮 + - 趷 + - 趹 + - 跘 + - 跓 + - 跍 + - 跇 + - 跜 + - 跕 + - 跙 + - 跈 + - 跰 + - 跠 + - 跮 + - 跦 + - 跢 + - 跧 + - 跲 + - 跫 + - 踂 + - 跿 + - 踍 + - 踃 + - 踇 + - 踆 + - 跾 + - 踠 + - 踥 + - 踤 + - 踡 + - 踕 + - 踛 + - 踖 + - 踑 + - 踙 + - 踧 + - 踘 + - 踓 + - 踳 + - 踾 + - 踸 + - 踼 + - 蹎 + - 蹍 + - 蹓 + - 蹗 + - 蹖 + - 蹞 + - 蹥 + - 蹛 + - 蹡 + - 蹝 + - 蹔 + - 蹸 + - 蹳 + - 蹪 + - 躆 + - 躈 + - 躖 + - 躗 + - 躟 + - 躠 + - 躤 + - 躣 + - 躩 + - 躨 + - 躽 + - 軓 + - 軘 + - 軞 + - 軯 + - 軷 + - 軦 + - 軮 + - 軥 + - 軵 + - 軧 + - 軨 + - 軶 + - 軱 + - 軬 + - 輆 + - 軿 + - 輁 + - 輀 + - 輂 + - 輐 + - 輑 + - 輤 + - 輘 + - 輚 + - 輠 + - 輣 + - 輖 + - 輗 + - 輮 + - 輵 + - 輲 + - 輹 + - 輷 + - 輴 + - 轃 + - 轇 + - 轈 + - 轒 + - 轑 + - 轏 + - 轐 + - 轓 + - 轙 + - 轖 + - 轗 + - 轕 + - 轚 + - 轞 + - 轛 + - 轠 + - 辴 + - 迉 + - 迒 + - 迋 + - 迍 + - 迖 + - 迣 + - 迡 + - 迾 + - 迿 + - 逜 + - 逿 + - 遝 + - 遳 + - 遰 + - 遻 + - 邆 + - 邅 + - 遾 + - 邍 + - 邔 + - 邟 + - 邥 + - 邞 + - 邧 + - 郱 + - 郕 + - 郖 + - 郠 + - 郙 + - 郣 + - 郥 + - 郘 + - 郰 + - 郲 + - 郔 + - 鄬 + - 郼 + - 鄈 + - 郹 + - 郻 + - 鄁 + - 鄇 + - 郺 + - 鄐 + - 鄍 + - 鄏 + - 鄎 + - 鄟 + - 鄝 + - 鄡 + - 鄛 + - 鄨 + - 鄪 + - 鄦 + - 鄮 + - 鄵 + - 鄸 + - 鄻 + - 鄾 + - 酀 + - 酁 + - 酄 + - 酇 + - 酖 + - 酘 + - 酓 + - 酟 + - 酳 + - 醆 + - 醊 + - 醓 + - 醙 + - 醟 + - 醥 + - 醧 + - 醰 + - 醱 + - 醷 + - 醲 + - 醳 + - 醹 + - 醽 + - 釂 + - 釃 + - 釢 + - 釱 + - 釳 + - 釸 + - 鈚 + - 鈌 + - 鈒 + - 釽 + - 鈆 + - 鉒 + - 鉠 + - 鉯 + - 鈶 + - 鉼 + - 銤 + - 銛 + - 銔 + - 鉹 + - 銗 + - 鋄 + - 鋀 + - 鋟 + - 鋘 + - 鋩 + - 鋝 + - 鋂 + - 鋊 + - 錧 + - 錼 + - 錭 + - 錎 + - 鋋 + - 鎡 + - 鎃 + - 鎯 + - 鍖 + - 鍜 + - 鍐 + - 鍭 + - 鍌 + - 鎒 + - 鎷 + - 鎝 + - 鎉 + - 鎎 + - 鎞 + - 鏏 + - 鏂 + - 鏚 + - 鏬 + - 鏙 + - 鐋 + - 鐏 + - 鏾 + - 鐕 + - 鐨 + - 鐍 + - 鐀 + - 鐎 + - 鐖 + - 鐻 + - 鐶 + - 鑐 + - 鑋 + - 鑕 + - 鑮 + - 鑯 + - 钂 + - 钀 + - 钁 + - 钃 + - 镺 + - 镻 + - 镼 + - 镽 + - 閈 + - 閍 + - 閺 + - 閵 + - 闀 + - 闉 + - 闅 + - 閷 + - 闒 + - 闑 + - 闚 + - 闛 + - 闠 + - 闟 + - 闤 + - 阞 + - 阢 + - 阤 + - 阠 + - 阰 + - 阹 + - 阸 + - 阺 + - 陏 + - 陓 + - 陊 + - 陼 + - 陭 + - 陫 + - 隇 + - 陾 + - 隉 + - 隒 + - 隓 + - 隞 + - 隤 + - 隿 + - 雂 + - 雈 + - 雓 + - 雔 + - 雗 + - 雚 + - 雟 + - 雘 + - 雺 + - 雽 + - 雿 + - 霂 + - 霋 + - 霒 + - 霐 + - 霠 + - 霣 + - 霢 + - 霩 + - 霫 + - 霬 + - 霮 + - 霵 + - 霿 + - 靆 + - 靃 + - 靪 + - 靮 + - 靷 + - 靲 + - 靾 + - 鞃 + - 鞀 + - 鞂 + - 靻 + - 鞊 + - 鞎 + - 鞈 + - 鞙 + - 鞗 + - 鞚 + - 鞜 + - 鞤 + - 鞪 + - 鞷 + - 鞶 + - 鞹 + - 鞻 + - 鞿 + - 韄 + - 韅 + - 韇 + - 韎 + - 韐 + - 韏 + - 韕 + - 韔 + - 韗 + - 韝 + - 韟 + - 韣 + - 韥 + - 韰 + - 韱 + - 韹 + - 韽 + - 頄 + - 頖 + - 頞 + - 頝 + - 頩 + - 頨 + - 頯 + - 頲 + - 顁 + - 顄 + - 顊 + - 顉 + - 顅 + - 顐 + - 顑 + - 顜 + - 顝 + - 顠 + - 顣 + - 顟 + - 顤 + - 顪 + - 顩 + - 顲 + - 颬 + - 颲 + - 颸 + - 颽 + - 颻 + - 颾 + - 飁 + - 飂 + - 飉 + - 飋 + - 飌 + - 飣 + - 飶 + - 餂 + - 餀 + - 飺 + - 餔 + - 餖 + - 餕 + - 餤 + - 餟 + - 餥 + - 餫 + - 餪 + - 餲 + - 餯 + - 餭 + - 餱 + - 餰 + - 饁 + - 饇 + - 饐 + - 饎 + - 饙 + - 饘 + - 饛 + - 饡 + - 馣 + - 馲 + - 馰 + - 馵 + - 馻 + - 馺 + - 駂 + - 馽 + - 駜 + - 駍 + - 駏 + - 駎 + - 駖 + - 駮 + - 駬 + - 駥 + - 駤 + - 駣 + - 駩 + - 駺 + - 駴 + - 駷 + - 駹 + - 駶 + - 駻 + - 駽 + - 駾 + - 騃 + - 騉 + - 騑 + - 騊 + - 騇 + - 騚 + - 騕 + - 騥 + - 騝 + - 騛 + - 騢 + - 騠 + - 騧 + - 騞 + - 騜 + - 騵 + - 騲 + - 騴 + - 騱 + - 騬 + - 騪 + - 騩 + - 騹 + - 騽 + - 驆 + - 騺 + - 驓 + - 驔 + - 驈 + - 驉 + - 驖 + - 驞 + - 驠 + - 驦 + - 驨 + - 骭 + - 骫 + - 骹 + - 骿 + - 骴 + - 骾 + - 髇 + - 髊 + - 髆 + - 髍 + - 髐 + - 髟 + - 髧 + - 髬 + - 髳 + - 髶 + - 髺 + - 髾 + - 鬁 + - 髼 + - 鬋 + - 鬊 + - 鬎 + - 鬌 + - 鬐 + - 鬕 + - 鬗 + - 鬖 + - 鬙 + - 鬞 + - 鬠 + - 鬤 + - 鬫 + - 鬳 + - 鬵 + - 鬺 + - 鬾 + - 鬿 + - 魊 + - 魌 + - 魖 + - 魠 + - 魡 + - 魧 + - 魱 + - 魦 + - 魶 + - 魵 + - 鮅 + - 鮇 + - 魼 + - 魾 + - 魻 + - 鮂 + - 鮚 + - 鮞 + - 鮛 + - 鮦 + - 鮥 + - 鮤 + - 鮆 + - 鯆 + - 鮿 + - 鮵 + - 鯈 + - 鯫 + - 鯠 + - 鯞 + - 鯦 + - 鯬 + - 鰌 + - 鰋 + - 鰅 + - 鯸 + - 鰫 + - 鰝 + - 鰬 + - 鱆 + - 鰿 + - 鱄 + - 鱁 + - 鰴 + - 鱐 + - 鱍 + - 鱋 + - 鱕 + - 鱦 + - 鱢 + - 鱞 + - 鱴 + - 鱳 + - 鱹 + - 鳦 + - 鳪 + - 鳭 + - 鳱 + - 鳵 + - 鳼 + - 鳺 + - 鳿 + - 鳷 + - 鴀 + - 鳹 + - 鳻 + - 鴅 + - 鴃 + - 鴥 + - 鴠 + - 鴔 + - 鴩 + - 鴘 + - 鴢 + - 鴐 + - 鴳 + - 鵁 + - 鵧 + - 鴶 + - 鴮 + - 鴱 + - 鴸 + - 鵅 + - 鵃 + - 鴾 + - 鵀 + - 鴽 + - 鵏 + - 鵊 + - 鵛 + - 鵋 + - 鵖 + - 鵌 + - 鵗 + - 鵔 + - 鵷 + - 鶁 + - 鶊 + - 鶄 + - 鶈 + - 鵱 + - 鶀 + - 鵸 + - 鶋 + - 鶌 + - 鵽 + - 鵫 + - 鵴 + - 鵩 + - 鶅 + - 鵳 + - 鵻 + - 鶂 + - 鵹 + - 鶟 + - 鶙 + - 鶤 + - 鶝 + - 鶐 + - 鶛 + - 鶠 + - 鶔 + - 鶜 + - 鶪 + - 鶗 + - 鶢 + - 鶨 + - 鶞 + - 鶣 + - 鶖 + - 鶷 + - 鶶 + - 鷁 + - 鷇 + - 鷊 + - 鷏 + - 鶾 + - 鷅 + - 鷃 + - 鶵 + - 鷈 + - 鶱 + - 鶭 + - 鷛 + - 鷒 + - 鷞 + - 鷋 + - 鷐 + - 鷜 + - 鷑 + - 鷩 + - 鷘 + - 鷖 + - 鷵 + - 鷕 + - 鷻 + - 鷷 + - 鷣 + - 鷤 + - 鷶 + - 鷡 + - 鷮 + - 鷢 + - 鸂 + - 鷾 + - 鸇 + - 鸃 + - 鸆 + - 鸅 + - 鸀 + - 鸁 + - 鸉 + - 鷿 + - 鷽 + - 鸄 + - 鸋 + - 鸍 + - 鸏 + - 鸒 + - 鸔 + - 鸓 + - 鸗 + - 鸙 + - 鹺 + - 麃 + - 麆 + - 麉 + - 麎 + - 麌 + - 麔 + - 麙 + - 麛 + - 麚 + - 麜 + - 麠 + - 麡 + - 麧 + - 麮 + - 麰 + - 麶 + - 麷 + - 黀 + - 黂 + - 黈 + - 黓 + - 黕 + - 黖 + - 黚 + - 黤 + - 黫 + - 黮 + - 黭 + - 黰 + - 黳 + - 黵 + - 黺 + - 鼁 + - 鼀 + - 鼆 + - 鼊 + - 鼏 + - 鼖 + - 鼛 + - 鼘 + - 鼜 + - 鼤 + - 鼣 + - 鼥 + - 鼪 + - 鼨 + - 鼭 + - 鼰 + - 鼮 + - 鼵 + - 鼳 + - 鼲 + - 鼸 + - 鼶 + - 齀 + - 齂 + - 齃 + - 齌 + - 齍 + - 齎 + - 齖 + - 齗 + - 齘 + - 齛 + - 齠 + - 齞 + - 齝 + - 齥 + - 齤 + - 齫 + - 齱 + - 齰 + - 齮 + - 齯 + - 齴 + - 齵 + - 齸 + - 齻 + - 齺 + - 齹 + - 齾 + - 龒 + - 龤 + - 堔 + - 礂 + - 蒏 + - 蒆 + - 兙 + - 兛 + - 兞 + - 兝 + - 兡 + - 兣 + - 嗧 + - 瓩 + - 忼 + - 擡 + - 氊 + - 穇 + - 擧 + - 譌 + - '!' + - '"' + - '#' + - $ + - '%' + - '&' + - '''' + - ( + - ) + - '*' + - + + - ',' + - '-' + - . + - / + - '0' + - '1' + - '2' + - '3' + - '4' + - '5' + - '6' + - '7' + - '8' + - '9' + - ':' + - ; + - < + - '=' + - '>' + - '?' + - A + - B + - C + - D + - E + - F + - G + - H + - I + - J + - K + - L + - M + - N + - O + - P + - Q + - R + - S + - T + - U + - V + - W + - X + - Y + - Z + - '[' + - ']' + - _ + - '`' + - a + - b + - c + - d + - e + - f + - g + - h + - i + - j + - k + - l + - m + - n + - o + - p + - q + - r + - s + - t + - u + - v + - w + - x + - y + - z + - © + - ° + - ² + - ´ + - ½ + - Á + - Ä + - Å + - Ç + - È + - É + - Í + - Ó + - Ö + - × + - Ü + - ß + - à + - á + - â + - ã + - ä + - å + - æ + - ç + - è + - é + - ê + - ë + - í + - ð + - ñ + - ò + - ó + - ô + - õ + - ö + - ø + - ú + - û + - ü + - ý + - ā + - ă + - ą + - ć + - Č + - č + - đ + - ē + - ė + - ę + - ğ + - ī + - ı + - Ł + - ł + - ń + - ň + - ō + - ř + - Ş + - ş + - Š + - š + - ţ + - ū + - ż + - Ž + - ž + - Ș + - ș + - ț + - Δ + - α + - λ + - μ + - φ + - Г + - О + - а + - в + - л + - о + - р + - с + - т + - я + - ồ + - — + - ― + - ’ + - “ + - ” + - … + - ℃ + - → + - ∇ + - − + - ■ + - ☆ + - 、 + - 。 + - 々 + - 〆 + - 〈 + - 〉 + - 「 + - 」 + - 『 + - 』 + - 〔 + - 〕 + - 〜 + - ！ + - ＃ + - ％ + - ＆ + - （ + - ） + - ＋ + - ， + - － + - ． + - ／ + - ０ + - １ + - ２ + - ３ + - ４ + - ５ + - ６ + - ７ + - ８ + - ９ + - ： + - ； + - ＝ + - ？ + - ＠ + - Ａ + - Ｂ + - Ｃ + - Ｄ + - Ｅ + - Ｆ + - Ｇ + - Ｈ + - Ｉ + - Ｊ + - Ｋ + - Ｌ + - Ｍ + - Ｎ + - Ｏ + - Ｐ + - Ｒ + - Ｓ + - Ｔ + - Ｕ + - Ｖ + - Ｗ + - Ｘ + - Ｚ + - ａ + - ｂ + - ｃ + - ｄ + - ｅ + - ｆ + - ｇ + - ｈ + - ｉ + - ｊ + - ｋ + - ｌ + - ｍ + - ｎ + - ｏ + - ｐ + - ｑ + - ｒ + - ｓ + - ｔ + - ｕ + - ｖ + - ｗ + - ｘ + - ｙ + - ｚ + - ～ + - ･ + - ǎ + - ǒ + - ě + - ǐ + - ì + - ǔ + - ù + - ǖ + - ǘ + - ǚ + - ǜ + - 【 + - 】 + - 《 + - 》 + - ‥ + - '{' + - '}' + - \ + - '|' + - '@' + - ^ + - '~' + - ÷ + - ∕ + - ∙ + - ⋅ + - · + - ⊕ + - ⊖ + - ⊗ + - ⊘ + - ⊙ + - ± + - ∓ + - ∩ + - ∪ + - □ + - ⊎ + - ⊓ + - ⊔ + - ≠ + - ≈ + - ≡ + - ≤ + - ≥ + - ≪ + - ≫ + - ≲ + - ≳ + - ≶ + - ≷ + - ≺ + - ≻ + - ≼ + - ≽ + - ∈ + - ∉ + - ⊂ + - ⊃ + - ⊆ + - ⊇ + - ⊄ + - ⊅ + - ∅ + - ∖ + - ∁ + - ∆ + - ∧ + - ∨ + - ¬ + - ⊻ + - ⊼ + - ⊽ + - ← + - ↔ + - ⇒ + - ⇐ + - ⇔ + - ∀ + - ∃ + - ∄ + - ∴ + - ∵ + - ∝ + - ∞ + - ⊥ + - ∟ + - ∠ + - ∡ + - ∢ + - ′ + - ″ + - ∥ + - ⊾ + - ⊿ + - ∂ + - ∫ + - ∬ + - ∭ + - ∮ + - ∯ + - ∰ + - ∑ + - ∏ + - √ + - ∛ + - ∜ + - ∱ + - ∲ + - ∳ + - ∶ + - ∷ + - ∼ + - ® + - ≄ + - ≅ + - ≃ + - ≦ + - ≧ + - ⊈ + - ⊉ + - ⊢ + - ⊤ + - ⊨ + - ⊧ + - ℉ + - Ω + - ℧ + - Å + - ⌀ + - ℏ + - ⅀ + - ⍺ + - ⍵ + - ¢ + - € + - £ + - ¥ + - ￥ + - ₿ + - ↑ + - ↓ + - ↕ + - ↖ + - ↗ + - ↘ + - ↙ + - ↺ + - ↻ + - ↼ + - ↽ + - ↾ + - ↿ + - ⇀ + - ⇁ + - ⇂ + - ⇃ + - ⇋ + - ⇌ + - ª + - º + - ⁰ + - ¹ + - ³ + - ⁴ + - ⁵ + - ⁶ + - ⁷ + - ⁸ + - ⁹ + - ⁺ + - ⁻ + - ⁼ + - ⁽ + - ⁾ + - ⁿ + - ₀ + - ₁ + - ₂ + - ₃ + - ₄ + - ₅ + - ₆ + - ₇ + - ₈ + - ₉ + - ₊ + - ₋ + - ₌ + - ₍ + - ₎ + - Ⅰ + - Ⅱ + - Ⅲ + - Ⅳ + - Ⅴ + - Ⅵ + - Ⅶ + - Ⅷ + - Ⅸ + - Ⅹ + - Ⅺ + - Ⅻ + - ⅰ + - ⅱ + - ⅲ + - ⅳ + - ⅴ + - ⅵ + - ⅶ + - ⅷ + - ⅸ + - ⅹ + - ⅺ + - ⅻ + - ☰ + - ☱ + - ☲ + - ☳ + - ☴ + - ☵ + - ☶ + - ☷ + - ♀ + - ♂ + - ♳ + - ♴ + - ♵ + - ♶ + - ♷ + - ♸ + - ♹ + - ♺ + - ♩ + - ♪ + - ♫ + - ♬ + - ⚪ + - ⚫ + - ⚬ + - ✶ + - ✷ + - ✸ + - ➀ + - ➁ + - ➂ + - ➃ + - ➄ + - ➅ + - ➆ + - ➇ + - ➈ + - ➉ + - ➊ + - ➋ + - ➌ + - ➍ + - ➎ + - ➏ + - ➐ + - ➑ + - ➒ + - ➓ + - ⏀ + - ⏁ + - ⏂ + - ⏃ + - ⏄ + - ⏅ + - ⏆ + - ⏇ + - ⏈ + - ⏉ + - ⏊ + - ⏋ + - ⏌ + - ⏚ + - ⏴ + - ⏵ + - ⏶ + - ⏷ + - ⏸ + - ⏹ + - ⏺ + - ⏻ + - ⏼ + - Α + - Β + - Γ + - Ε + - Ζ + - Η + - Θ + - Ι + - Κ + - Λ + - Μ + - Ν + - Ξ + - Ο + - Π + - Ρ + - Σ + - Τ + - Υ + - Φ + - Χ + - Ψ + - β + - γ + - δ + - ε + - ζ + - η + - θ + - ι + - κ + - ν + - ξ + - ο + - π + - ρ + - σ + - τ + - υ + - χ + - ψ + - ω + - ϐ + - ϑ + - ϒ + - ϕ + - █ + - ϖ + - ϰ + - ϱ + - ϴ + - ϵ + - ϝ + - Ϟ + - ϟ + - Ϡ + - ϡ + - Ϣ + - ϣ + - Ϥ + - ϥ + - Ϧ + - ϧ + - Ϩ + - ϩ + - Ϫ + - ϫ + - Ϭ + - ϭ + - Ϯ + - ϯ + - ∸ + - ∹ + - ∺ + - ∻ + - ∽ + - ∾ + - ∿ + - ≀ + - ≁ + - ≂ + - ≆ + - ≇ + - ≉ + - ≊ + - ≋ + - ≌ + - ≍ + - ≎ + - ≏ + - ≐ + - ≑ + - ≒ + - ≓ + - ≔ + - ≕ + - ≖ + - ≗ + - ≘ + - ≙ + - ≚ + - ≛ + - ≜ + - ≝ + - ≞ + - ≟ + - ≢ + - ≣ + - ≨ + - ≩ + - ≬ + - ≭ + - ≮ + - ≯ + - ≰ + - ≱ + - ≴ + - ≵ + - ≸ + - ≹ + - ≾ + - ≿ + - ⊀ + - ⊁ + - ⊊ + - ⊋ + - ⊌ + - ⊍ + - ⊏ + - ⊐ + - ⊑ + - ⊒ + - ⊚ + - ⊛ + - ⊜ + - ⊝ + - ⊞ + - ⊟ + - ⊠ + - ⊡ + - ⊣ + - ⊦ + - ⊩ + - ⊪ + - ⊫ + - ⊬ + - ⊭ + - ⊮ + - ⊯ + - ⊰ + - ⊱ + - ⊲ + - ⊳ + - ⊴ + - ⊵ + - ⊶ + - ⊷ + - ⊸ + - ⊹ + - ⊺ + - ℎ + - ℘ + - ℜ + - ℑ + - ℵ + - ℶ + - ℷ + - ℸ + - ⌬ + - ⌭ + - ⌮ + - ⌯ + - ⎔ + - ¤ + - ₠ + - ₡ + - ₢ + - ₣ + - ₤ + - ₥ + - ₦ + - ₧ + - ₨ + - ₩ + - ₪ + - ₫ + - ₭ + - ₮ + - ₯ + - ₰ + - ₱ + - ₲ + - ₳ + - ₴ + - ₵ + - ₶ + - ₷ + - ₸ + - ₹ + - ₺ + - ₻ + - ₼ + - ₽ + - ₾ + - ↚ + - ↛ + - ↜ + - ↝ + - ↞ + - ↟ + - ↠ + - ↡ + - ↢ + - ↣ + - ↤ + - ↥ + - ↦ + - ↧ + - ↨ + - ↩ + - ↪ + - ↫ + - ↬ + - ↭ + - ↮ + - ↯ + - ↰ + - ↱ + - ↲ + - ↳ + - ↴ + - ↵ + - ↶ + - ↷ + - ↸ + - ↹ + - ⇄ + - ⇅ + - ⇆ + - ⇇ + - ⇈ + - ⇉ + - ⇊ + - ⇍ + - ⇎ + - ⇏ + - ⇑ + - ⇓ + - ⇕ + - ⇖ + - ⇗ + - ⇘ + - ⇙ + - ⇚ + - ⇛ + - ⇜ + - ⇝ + - ⇞ + - ⇟ + - ⇠ + - ⇡ + - ⇢ + - ⇣ + - ⇤ + - ⇥ + - ⇦ + - ⇧ + - ⇨ + - ⇩ + - ⇪ + - ⇫ + - ⇬ + - ⇭ + - ⇮ + - ⇯ + - ⇰ + - ⇱ + - ⇲ + - ⇳ + - ⇴ + - ⇵ + - ⇶ + - ⇷ + - ⇸ + - ⇹ + - ⇺ + - ⇻ + - ⇼ + - ⇽ + - ⇾ + - ⇿ + - ↀ + - ↁ + - ↂ + - ☀ + - ☁ + - ☂ + - ☃ + - ☄ + - ★ + - ☇ + - ☈ + - ☉ + - ☊ + - ☋ + - ☌ + - ☍ + - ☎ + - ☏ + - ☐ + - ☑ + - ☒ + - ☓ + - ☔ + - ☕ + - ☖ + - ☗ + - ☘ + - ☙ + - ☚ + - ☛ + - ☜ + - ☝ + - ☞ + - ☟ + - ☠ + - ☡ + - ☢ + - ☣ + - ☤ + - ☥ + - ☦ + - ☧ + - ☨ + - ☩ + - ☪ + - ☫ + - ☬ + - ☭ + - ☮ + - ☯ + - ☸ + - ☹ + - ☺ + - ☻ + - ☼ + - ☽ + - ☾ + - ☿ + - ♁ + - ♃ + - ♄ + - ♅ + - ♆ + - ♇ + - ♔ + - ♕ + - ♖ + - ♗ + - ♘ + - ♙ + - ♚ + - ♛ + - ♜ + - ♝ + - ♞ + - ♟ + - ♠ + - ♡ + - ♢ + - ♣ + - ♤ + - ♥ + - ♦ + - ♧ + - ♨ + - ♭ + - ♮ + - ♯ + - ♰ + - ♱ + - ♲ + - ♻ + - ♼ + - ♽ + - ♾ + - ⚀ + - ⚁ + - ⚂ + - ⚃ + - ⚄ + - ⚅ + - ⚆ + - ⚇ + - ⚈ + - ⚉ + - ⚊ + - ⚋ + - ⚌ + - ⚍ + - ⚎ + - ⚏ + - ⚐ + - ⚑ + - ⚒ + - ⚓ + - ⚔ + - ⚕ + - ⚖ + - ⚗ + - ⚘ + - ⚙ + - ⚚ + - ⚛ + - ⚜ + - ⚝ + - ⚞ + - ⚟ + - ⚠ + - ⚡ + - ⚢ + - ⚣ + - ⚤ + - ⚥ + - ⚦ + - ⚧ + - ⚨ + - ⚩ + - ⚭ + - ⚮ + - ⚯ + - ⚰ + - ⚱ + - ⚲ + - ⚳ + - ⚴ + - ⚵ + - ⚶ + - ⚷ + - ⚸ + - ⚹ + - ⚺ + - ⚻ + - ⚼ + - ⚿ + - ⛀ + - ⛁ + - ⛂ + - ⛃ + - ⛆ + - ⛇ + - ⛈ + - ⛉ + - ⛊ + - ⛋ + - ⛌ + - ⛍ + - ⛏ + - ⛐ + - ⛑ + - ⛒ + - ⛓ + - ⛕ + - ⛖ + - ⛗ + - ⛘ + - ⛙ + - ⛚ + - ⛛ + - ⛜ + - ⛝ + - ⛞ + - ⛠ + - ⛡ + - ⛢ + - ⛣ + - ⛤ + - ⛥ + - ⛦ + - ⛧ + - ⛨ + - ⛩ + - ⛪ + - ⛫ + - ⛬ + - ⛭ + - ⛮ + - ⛯ + - ⛶ + - ⛾ + - ⛿ + - ✆ + - ✇ + - ✈ + - ✉ + - ✌ + - ✍ + - ✎ + - ✏ + - ✐ + - ✑ + - ✒ + - ✓ + - ✔ + - ✕ + - ✙ + - ✚ + - ✛ + - ✜ + - ✝ + - ✞ + - ✟ + - ✠ + - ✡ + - ✢ + - ✣ + - ✤ + - ✥ + - ✦ + - ✧ + - ✩ + - ✪ + - ✫ + - ✬ + - ✭ + - ✮ + - ✯ + - ✰ + - ✱ + - ✲ + - ✳ + - ✴ + - ✵ + - ✹ + - ✺ + - ✻ + - ✼ + - ✽ + - ✾ + - ✿ + - ❀ + - ❁ + - ❂ + - ❃ + - ❄ + - ❅ + - ❆ + - ❇ + - ❈ + - ❉ + - ❊ + - ❋ + - ❍ + - ❏ + - ❐ + - ❑ + - ❒ + - ❖ + - ❘ + - ❙ + - ❚ + - ❛ + - ❜ + - ❝ + - ❞ + - ❡ + - ❢ + - ❣ + - ❤ + - ❥ + - ❦ + - ❧ + - ❨ + - ❩ + - ❪ + - ❫ + - ❬ + - ❭ + - ❮ + - ❯ + - ❰ + - ❱ + - ❲ + - ❳ + - ❴ + - ❵ + - ❶ + - ❷ + - ❸ + - ❹ + - ❺ + - ❻ + - ❼ + - ❽ + - ❾ + - ❿ + - ① + - ② + - ③ + - ④ + - ⑤ + - ⑥ + - ⑦ + - ⑧ + - ⑨ + - ⑩ + - ➔ + - ➕ + - ➖ + - ➗ + - ➘ + - ➙ + - ➚ + - ➛ + - ➜ + - ➝ + - ➞ + - ➟ + - ➠ + - ➡ + - ➢ + - ➣ + - ➤ + - ➥ + - ➦ + - ➧ + - ➨ + - ➩ + - ➪ + - ➫ + - ➬ + - ➭ + - ➮ + - ➯ + - ➰ + - ➱ + - ➲ + - ➳ + - ➴ + - ➵ + - ➶ + - ➷ + - ➸ + - ➹ + - ➺ + - ➻ + - ➼ + - ➽ + - ➾ + - ➿ + - ⌘ + - ⌥ + - ⌃ + - ⎋ + - ⌫ + - ⌦ + - ⏏ + - ⌤ + - ⌧ + - ⌨ + - ⎆ + - ⎇ + - ⎈ + - ⎉ + - ⎊ + - ⎌ + - ⎍ + - ⎎ + - ⎏ + - ⎐ + - ⎑ + - ⎒ + - ⎓ + - ⎕ + - ⎖ + - ⎗ + - ⎘ + - ⎙ + - ⎚ + - ⎛ + - ⎜ + - ⎝ + - ⎞ + - ⎟ + - ⎠ + - ⎡ + - ⎢ + - ⎣ + - ⎤ + - ⎥ + - ⎦ + - ⎧ + - ⎨ + - ⎩ + - ⎪ + - ⎫ + - ⎬ + - ⎭ + - ⎮ + - ⎯ + - ⎰ + - ⎱ + - ⎲ + - ⎳ + - ⎴ + - ⎵ + - ⎶ + - ⎷ + - ⎸ + - ⎹ + - ⎺ + - ⎻ + - ⎼ + - ⎽ + - ⎾ + - ⎿ + - ⏍ + - ⏎ + - ⏐ + - ⏑ + - ⏒ + - ⏓ + - ⏔ + - ⏕ + - ⏖ + - ⏗ + - ⏘ + - ⏙ + - ⏛ + - ⏜ + - ⏝ + - ⏞ + - ⏟ + - ⏠ + - ⏡ + - ⏢ + - ⏣ + - ⏤ + - ⏥ + - ⏦ + - ⏧ + - ⏨ + - ⏭ + - ⏮ + - ⏯ + - ⏱ + - ⏲ + - ▲ + - ▽ + - ◐ + - ⏽ + - ⏾ + - ⏿ + - ɐ + - ɑ + - ɒ + - ɓ + - ɔ + - ɕ + - ɖ + - ɗ + - ɘ + - ə + - ɚ + - ɛ + - ɜ + - ɝ + - ɞ + - ɟ + - ɠ + - ɡ + - ɢ + - ɣ + - ɤ + - ɥ + - ɦ + - ɧ + - ɨ + - ɩ + - ɪ + - ɫ + - ɬ + - ɭ + - ɮ + - ɯ + - ɰ + - ɱ + - ɲ + - ɳ + - ɴ + - ɵ + - ɶ + - ɷ + - ɸ + - ɹ + - ɺ + - ɻ + - ɼ + - ɽ + - ɾ + - ɿ + - ʀ + - ʁ + - ʂ + - ʃ + - ʄ + - ʅ + - ʆ + - ʇ + - ʈ + - ʉ + - ʊ + - ʋ + - ʌ + - ʍ + - ʎ + - ʏ + - ʐ + - ʑ + - ʒ + - ʓ + - ʔ + - ʕ + - ʖ + - ʗ + - ʘ + - ʙ + - ʚ + - ʛ + - ʜ + - ʝ + - ʞ + - ʟ + - ʠ + - ʡ + - ʢ + - ʣ + - ʤ + - ʥ + - ʦ + - ʧ + - ʨ + - ʩ + - ʪ + - ʫ + - ʬ + - ʭ + - ʮ + - ʯ + - ━ + - Ǝ + - Ã + - ● + - ▶ + - ｜ + - 𝑢 + - 〖 + - 〗 + - ︽ + - – + - ﹥ + - 𝜓 + - • + - ∋ + - ƒ + - ० + - ✘ + - Е + - ◉ + - 〒 + - 𝒱 + - 𝜆 + - ⟹ + - ﹪ + - ◊ + - ╆ + - 오 + - ˂ + - 〉 + - 𝝎 + - ▪ + - △ + - ▁ + - ◼ + - 〇 + - ▷ + - ▬ + - 𝒮 + - † + - ₒ + - ⼁ + - 〵 + - ⭐ + - ╳ + - ⟶ + - 으 + - ⬆ + - Ạ + - ◀ + -  + - ▫ + - 丄 + - ︾ + - ◥ + - ‖ + - 𝜌 + - ⅼ + - ▼ + - ⁎ + - ﹏ + - 😁 + - 😂 + - 😃 + - 😄 + - 😅 + - 😆 + - 😉 + - 😊 + - 😋 + - 😌 + - 😍 + - 😏 + - 😒 + - 😓 + - 😔 + - 😖 + - 😘 + - 😚 + - 😜 + - 😝 + - 😞 + - 😠 + - 😡 + - 😢 + - 😣 + - 😤 + - 😥 + - 😨 + - 😩 + - 😪 + - 😫 + - 😭 + - 😰 + - 😱 + - 😲 + - 😳 + - 😵 + - 😷 + - 😸 + - 😹 + - 😺 + - 😻 + - 😼 + - 😽 + - 😾 + - 😿 + - 🙀 + - 🙅 + - 🙆 + - 🙇 + - 🙈 + - 🙉 + - 🙊 + - 🙋 + - 🙌 + - 🙍 + - 🙎 + - 🙏 + - ✂ + - ✅ + - ✊ + - ✋ + - ✖ + - ✨ + - ❌ + - ❎ + - ❓ + - ❔ + - ❕ + - ❗ + - 🚀 + - 🚃 + - 🚄 + - 🚅 + - 🚇 + - 🚉 + - 🚌 + - 🚏 + - 🚑 + - 🚒 + - 🚓 + - 🚕 + - 🚗 + - 🚙 + - 🚚 + - 🚢 + - 🚤 + - 🚥 + - 🚧 + - 🚨 + - 🚩 + - 🚪 + - 🚫 + - 🚬 + - 🚭 + - 🚲 + - 🚶 + - 🚹 + - 🚺 + - 🚻 + - 🚼 + - 🚽 + - 🚾 + - 🛀 + - Ⓜ + - 🅰 + - 🅱 + - 🅾 + - 🅿 + - 🆎 + - 🆑 + - 🆒 + - 🆓 + - 🆔 + - 🆕 + - 🆖 + - 🆗 + - 🆘 + - 🆙 + - 🆚 + - 🇩🇪 + - 🇬🇧 + - 🇨🇳 + - 🇯🇵 + - 🇫🇷 + - 🇰🇷 + - 🇪🇸 + - 🇮🇹 + - 🇷🇺 + - 🇺🇸 + - 🈁 + - ℹ + - ⌚ + - ⌛ + - ⏩ + - ⏪ + - ⏫ + - ⏬ + - ⏰ + - ⏳ + - ◻ + - ◽ + - ◾ + - ♈ + - ♉ + - ♊ + - ♋ + - ♌ + - ♍ + - ♎ + - ♏ + - ♐ + - ♑ + - ♒ + - ♓ + - ♿ + - ⚽ + - ⚾ + - ⛄ + - ⛅ + - ⛎ + - ⛔ + - ⛲ + - ⛳ + - ⛵ + - ⛺ + - ⛽ + - ⤴ + - ⤵ + - ⬅ + - ⬇ + - ⬛ + - ⬜ + - ⭕ + - 〰 + - 〽 + - ㊗ + - ㊙ + - 🀄 + - 🃏 + - 🌀 + - 🌁 + - 🌂 + - 🌃 + - 🌄 + - 🌅 + - 🌆 + - 🌇 + - 🌈 + - 🌉 + - 🌊 + - 🌋 + - 🌌 + - 🌏 + - 🌑 + - 🌓 + - 🌔 + - 🌕 + - 🌙 + - 🌛 + - 🌟 + - 🌠 + - 🌰 + - 🌱 + - 🌴 + - 🌵 + - 🌷 + - 🌸 + - 🌹 + - 🌺 + - 🌻 + - 🌼 + - 🌽 + - 🌾 + - 🌿 + - 🍀 + - 🍁 + - 🍂 + - 🍃 + - 🍄 + - 🍅 + - 🍆 + - 🍇 + - 🍈 + - 🍉 + - 🍊 + - 🍌 + - 🍍 + - 🍎 + - 🍏 + - 🍑 + - 🍒 + - 🍓 + - 🍔 + - 🍕 + - 🍖 + - 🍗 + - 🍘 + - 🍙 + - 🍚 + - 🍛 + - 🍜 + - 🍝 + - 🍞 + - 🍟 + - 🍠 + - 🍡 + - 🍢 + - 🍣 + - 🍤 + - 🍥 + - 🍦 + - 🍧 + - 🍨 + - 🍩 + - 🍪 + - 🍫 + - 🍬 + - 🍭 + - 🍮 + - 🍯 + - 🍰 + - 🍱 + - 🍲 + - 🍳 + - 🍴 + - 🍵 + - 🍶 + - 🍷 + - 🍸 + - 🍹 + - 🍺 + - 🍻 + - 🎀 + - 🎁 + - 🎂 + - 🎃 + - 🎄 + - 🎅 + - 🎆 + - 🎇 + - 🎈 + - 🎉 + - 🎊 + - 🎋 + - 🎌 + - 🎍 + - 🎎 + - 🎏 + - 🎐 + - 🎑 + - 🎒 + - 🎓 + - 🎠 + - 🎡 + - 🎢 + - 🎣 + - 🎤 + - 🎥 + - 🎦 + - 🎧 + - 🎨 + - 🎩 + - 🎪 + - 🎫 + - 🎬 + - 🎭 + - 🎮 + - 🎯 + - 🎰 + - 🎱 + - 🎲 + - 🎳 + - 🎴 + - 🎵 + - 🎶 + - 🎷 + - 🎸 + - 🎹 + - 🎺 + - 🎻 + - 🎼 + - 🎽 + - 🎾 + - 🎿 + - 🏀 + - 🏁 + - 🏂 + - 🏃 + - 🏄 + - 🏆 + - 🏈 + - 🏊 + - 🏠 + - 🏡 + - 🏢 + - 🏣 + - 🏥 + - 🏦 + - 🏧 + - 🏨 + - 🏩 + - 🏪 + - 🏫 + - 🏬 + - 🏭 + - 🏮 + - 🏯 + - 🏰 + - 🐌 + - 🐍 + - 🐎 + - 🐑 + - 🐒 + - 🐔 + - 🐗 + - 🐘 + - 🐙 + - 🐚 + - 🐛 + - 🐜 + - 🐝 + - 🐞 + - 🐟 + - 🐠 + - 🐡 + - 🐢 + - 🐣 + - 🐤 + - 🐥 + - 🐦 + - 🐧 + - 🐨 + - 🐩 + - 🐫 + - 🐬 + - 🐭 + - 🐮 + - 🐯 + - 🐰 + - 🐱 + - 🐲 + - 🐳 + - 🐴 + - 🐵 + - 🐶 + - 🐷 + - 🐸 + - 🐹 + - 🐺 + - 🐻 + - 🐼 + - 🐽 + - 🐾 + - 👀 + - 👂 + - 👃 + - 👄 + - 👅 + - 👆 + - 👇 + - 👈 + - 👉 + - 👊 + - 👋 + - 👌 + - 👍 + - 👎 + - 👏 + - 👐 + - 👑 + - 👒 + - 👓 + - 👔 + - 👕 + - 👖 + - 👗 + - 👘 + - 👙 + - 👚 + - 👛 + - 👜 + - 👝 + - 👞 + - 👟 + - 👠 + - 👡 + - 👢 + - 👣 + - 👤 + - 👦 + - 👧 + - 👨 + - 👩 + - 👪 + - 👫 + - 👮 + - 👯 + - 👰 + - 👱 + - 👲 + - 👳 + - 👴 + - 👵 + - 👶 + - 👷 + - 👸 + - 👹 + - 👺 + - 👻 + - 👼 + - 👽 + - 👾 + - 👿 + - 💀 + - 💁 + - 💂 + - 💃 + - 💄 + - 💅 + - 💆 + - 💇 + - 💈 + - 💉 + - 💊 + - 💋 + - 💌 + - 💍 + - 💎 + - 💏 + - 💐 + - 💑 + - 💒 + - 💓 + - 💔 + - 💕 + - 💖 + - 💗 + - 💘 + - 💙 + - 💚 + - 💛 + - 💜 + - 💝 + - 💞 + - 💟 + - 💠 + - 💡 + - 💢 + - 💣 + - 💤 + - 💥 + - 💦 + - 💧 + - 💨 + - 💩 + - 💪 + - 💫 + - 💬 + - 💮 + - 💯 + - 💰 + - 💲 + - 💳 + - 💴 + - 💵 + - 💸 + - 💹 + - 💺 + - 💻 + - 💼 + - 💽 + - 💾 + - 💿 + - 📀 + - 📁 + - 📂 + - 📃 + - 📄 + - 📅 + - 📆 + - 📇 + - 📈 + - 📉 + - 📊 + - 📋 + - 📌 + - 📍 + - 📎 + - 📏 + - 📐 + - 📑 + - 📒 + - 📓 + - 📔 + - 📕 + - 📖 + - 📗 + - 📘 + - 📙 + - 📚 + - 📛 + - 📜 + - 📝 + - 📞 + - 📟 + - 📠 + - 📡 + - 📢 + - 📣 + - 📤 + - 📥 + - 📦 + - 📧 + - 📨 + - 📩 + - 📪 + - 📫 + - 📮 + - 📰 + - 📱 + - 📲 + - 📳 + - 📴 + - 📶 + - 📷 + - 📹 + - 📺 + - 📻 + - 📼 + - 🔃 + - 🔊 + - 🔋 + - 🔌 + - 🔍 + - 🔎 + - 🔏 + - 🔐 + - 🔑 + - 🔒 + - 🔓 + - 🔔 + - 🔖 + - 🔗 + - 🔘 + - 🔙 + - 🔚 + - 🔛 + - 🔜 + - 🔝 + - 🔞 + - 🔟 + - 🔠 + - 🔡 + - 🔢 + - 🔣 + - 🔤 + - 🔥 + - 🔦 + - 🔧 + - 🔨 + - 🔩 + - 🔪 + - 🔫 + - 🔮 + - 🔯 + - 🔰 + - 🔱 + - 🔲 + - 🔳 + - 🔴 + - 🔵 + - 🔶 + - 🔷 + - 🔸 + - 🔹 + - 🔺 + - 🔻 + - 🔼 + - 🔽 + - 🕐 + - 🕑 + - 🕒 + - 🕓 + - 🕔 + - 🕕 + - 🕖 + - 🕗 + - 🕘 + - 🕙 + - 🕚 + - 🕛 + - 🗻 + - 🗼 + - 🗽 + - 🗾 + - 🗿 + - 😀 + - 😇 + - 😈 + - 😎 + - 😐 + - 😑 + - 😕 + - 😗 + - 😙 + - 😛 + - 😟 + - 😦 + - 😧 + - 😬 + - 😮 + - 😯 + - 😴 + - 😶 + - 🚁 + - 🚂 + - 🚆 + - 🚈 + - 🚊 + - 🚍 + - 🚎 + - 🚐 + - 🚔 + - 🚖 + - 🚘 + - 🚛 + - 🚜 + - 🚝 + - 🚞 + - 🚟 + - 🚠 + - 🚡 + - 🚣 + - 🚦 + - 🚮 + - 🚯 + - 🚰 + - 🚱 + - 🚳 + - 🚴 + - 🚵 + - 🚷 + - 🚸 + - 🚿 + - 🛁 + - 🛂 + - 🛃 + - 🛄 + - 🛅 + - 🌍 + - 🌎 + - 🌐 + - 🌒 + - 🌖 + - 🌗 + - 🌘 + - 🌚 + - 🌜 + - 🌝 + - 🌞 + - 🌲 + - 🌳 + - 🍋 + - 🍐 + - 🍼 + - 🏇 + - 🏉 + - 🏤 + - 🐀 + - 🐁 + - 🐂 + - 🐃 + - 🐄 + - 🐅 + - 🐆 + - 🐇 + - 🐈 + - 🐉 + - 🐊 + - 🐋 + - 🐏 + - 🐐 + - 🐓 + - 🐕 + - 🐖 + - 🐪 + - 👥 + - 👬 + - 👭 + - 💭 + - 💶 + - 💷 + - 📬 + - 📭 + - 📯 + - 📵 + - 🔀 + - 🔁 + - 🔂 + - 🔄 + - 🔅 + - 🔆 + - 🔇 + - 🔉 + - 🔕 + - 🔬 + - 🔭 + - 🕜 + - 🕝 + - 🕞 + - 🕟 + - 🕠 + - 🕡 + - 🕢 + - 🕣 + - 🕤 + - 🕥 + - 🕦 + - 🕧 \ No newline at end of file diff --git a/robot_dog.service b/robot_dog.service new file mode 100644 index 0000000..80f12ef --- /dev/null +++ b/robot_dog.service @@ -0,0 +1,14 @@ +[Unit] +Description=Robot Dog Service +After=network.target + +[Service] +User=root +Group=root +WorkingDirectory=/root/robot_dog_project/kangda_robotic_dog/机器狗后台服务 +ExecStart=/root/robot_dog_project/kangda_robotic_dog/机器狗后台服务/start.sh +Restart=always +RestartSec=5s + +[Install] +WantedBy=multi-user.target \ No newline at end of file diff --git a/run.py b/run.py new file mode 100644 index 0000000..80a1688 --- /dev/null +++ b/run.py @@ -0,0 +1,14 @@ +import uvicorn + +if __name__ == "__main__": + # uvicorn.run( + # "app.main:app", + # host="10.0.0.202", + # port=12342 + # ) + + uvicorn.run( + "app.api.main:app", + host="0.0.0.0", + port=12345 + ) \ No newline at end of file diff --git a/start.sh b/start.sh new file mode 100644 index 0000000..a29f923 --- /dev/null +++ b/start.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +# 激活虚拟环境 +source /root/robot_dog_project/myvenv/bin/activate + +# 进入项目目录 +cd /root/robot_dog_project/kangda_robotic_dog/#U673a#U5668#U72d7#U540e#U53f0#U670d#U52a1 + + + +#!/bin/bash + +# 定义日志目录和带时间戳的日志文件名 +LOG_DIR="/root/robot_dog_project/kangda_robotic_dog/#U673a#U5668#U72d7#U540e#U53f0#U670d#U52a1/logs" +TIMESTAMP=$(date +'%Y%m%d_%H%M%S') +LOG_FILE="${LOG_DIR}/app_${TIMESTAMP}.log" + +# 创建日志目录（如果不存在） +mkdir -p "$LOG_DIR" + +# 激活Python虚拟环境 +source /root/robot_dog_project/myvenv/bin/activate + +# 切换到项目目录 +cd /root/robot_dog_project/kangda_robotic_dog/#U673a#U5668#U72d7#U540e#U53f0#U670d#U52a1 + +# 打印启动信息 +echo "启动应用程序，日志将保存到: $LOG_FILE" +echo "启动时间: $(date '+%Y-%m-%d %H:%M:%S')" | tee -a "$LOG_FILE" + +# 运行Python程序并将输出同时显示在控制台和保存到日志文件 +exec python run.py --env=dev 2>&1 | tee -a "$LOG_FILE" \ No newline at end of file diff --git a/test_base64_server.py b/test_base64_server.py new file mode 100644 index 0000000..3ab871d --- /dev/null +++ b/test_base64_server.py @@ -0,0 +1,110 @@ +import base64 +import requests +import json + +def image_to_base64(image_path): + """ + 将图片文件转换为base64编码 + """ + with open(image_path, "rb") as image_file: + encoded_string = base64.b64encode(image_file.read()).decode('utf-8') + return encoded_string + +def test_ocr_api(image_path, api_url="http://10.0.0.202:12342/api/v1/ocr_from_base64"): + """ + 测试OCR API接口 + """ + # 将图片转换为base64 + image_base64 = image_to_base64(image_path) + + with open("base64.txt", "w") as f: + f.write(repr(image_base64)) + + # 准备请求数据 + payload = { + "image_base64": image_base64, + "image_type": "jpg" # 根据实际图片类型修改 + } + + # 发送POST请求 + headers = { + "Content-Type": "application/json" + } + + try: + response = requests.post(api_url, data=json.dumps(payload), headers=headers) + if response.status_code == 200: + result = response.json() + print("OCR识别结果:") + print(json.dumps(result, ensure_ascii=False, indent=2)) + return result + else: + print(f"请求失败，状态码: {response.status_code}") + print(response.text) + return None + except Exception as e: + print(f"请求异常: {str(e)}") + return None + +def test_detect(image_path: str, api_url:str = "http://10.0.0.202:12342/api/v1/detect_from_base64_0"): + """ + 测试yolov8消防区域侵占接口 + """ + image_base64 = image_to_base64(image_path) + # 准备请求数据 + payload = { + "image_base64": image_base64, + "image_type": "jpg" # 根据实际图片类型修改 + } + + # 发送POST请求 + headers = { + "Content-Type": "application/json" + } + + try: + response = requests.post(api_url, data=json.dumps(payload), headers=headers) + if response.status_code == 200: + result = response.json() + print("detect识别结果:") + print(json.dumps(result, ensure_ascii=False, indent=2)) + return result + else: + print(f"请求失败，状态码: {response.status_code}") + print(response.text) + return None + except Exception as e: + print(f"请求异常: {str(e)}") + return None + + +if __name__ == "__main__": + # 测试图片路径，请根据实际情况修改 + # test_image_path = "/home/admin-root/haotian/康达瑞贝斯机器狗/data_image/001读表图片/2c7cc83019e7388a7041101da92c9829_frame_000000.jpg" + + #---------------------------------------测试ocr----------------------------------------- + test_image_path = "images/AiCheck_20251016114138.jpg" + + # api_url="http://10.0.0.202:12342/api/v1/ocr_onnx_from_base64" + # api_url="http://192.168.30.195:12345/api/v1/ocr_onnx_from_base64" + # # 调用测试函数 + # test_ocr_api(test_image_path, api_url) + #---------------------------------------测试ocrender----------------------------------------- + +# # -----------------------------------------测试yolov8 侵占消防区域检测----------------------------------------- +# test_image_path = "/home/admin-root/haotian/康达瑞贝斯机器狗/YoloV8Obj/dataset_20250819/train/images/1e4c75b76e531606e2adc491a8f09ae8_frame_000000.jpg" +# # test_image_path = "/home/admin-root/haotian/康达瑞贝斯机器狗/YoloV8Obj/dataset_20250819/train/images/1e4c75b76e531606e2adc491a8f09ae8_frame_000720.jpg" + # api_url = "http://10.0.0.202:12342/api/v1/detect_onnx_from_base64_0" + # api_url = "http://192.168.30.195:12345/api/v1/detect_onnx_from_base64_0" + # test_detect(test_image_path, api_url) +# #-----------------------------------------测试yolov8 侵占消防区域检测 end----------------------------------------- + + + # #-----------------------------------------测试yolov8 灭火器检测----------------------------------------- + # test_image_path = "/home/admin-root/haotian/康达瑞贝斯机器狗/YoloV8Obj/dataset_20250819/train/images/ce81420a27cdaff14fe42f967eaa49a3_frame_001060.jpg" + # # test_image_path = "/home/admin-root/haotian/康达瑞贝斯机器狗/YoloV8Obj/dataset_20250819/train/images/1e4c75b76e531606e2adc491a8f09ae8_frame_000120.jpg" + # # test_image_path = "/home/admin-root/haotian/康达瑞贝斯机器狗/YoloV8Obj/dataset_20250819/train/images/1e4c75b76e531606e2adc491a8f09ae8_frame_000120.jpg" + # api_url = "http://10.0.0.202:12342/api/v1/detect_from_base64_1" + api_url = "http://192.168.30.195:12345/api/v1/detect_from_base64_1" + test_detect(test_image_path, api_url=api_url) + # #-----------------------------------------测试yolov8 灭火器检测 end----------------------------------------- \ No newline at end of file diff --git a/test_generic.py b/test_generic.py new file mode 100644 index 0000000..8eafe5f --- /dev/null +++ b/test_generic.py @@ -0,0 +1,27 @@ +from typing import Generic, TypeVar, Dict +from typing import Optional + +K = TypeVar("K") # 键类型 +V = TypeVar("V") # 值类型 + +class GenericCache(Generic[K, V]): + def __init__(self): + self._store: Dict[K, V] = {} + + def set(self, key: K, value: V) -> None: + self._store[key] = value + + def get(self, key: K) -> Optional[V]: + return self._store.get(key) + +# 使用示例 +cache = GenericCache[str, int]() # 键为 str，值为 int +cache.set("count", 100) +value: Optional[int] = cache.get("count") # 返回 100 + +cache.set(112, "123") + + +for key in cache._store.keys(): + + print(type(cache.get(key))) \ No newline at end of file diff --git a/test_ocr.py b/test_ocr.py new file mode 100644 index 0000000..bdba31d --- /dev/null +++ b/test_ocr.py @@ -0,0 +1,7 @@ +from app.util.baiduOCR import BaiduOCR + + +if __name__ == '__main__': + ocr = BaiduOCR() + result = ocr.ocr('tmp/ocr_images/c723d5d8-697b-41e5-8cf4-d4644ce89a77.jpg') + print(result) \ No newline at end of file diff --git a/test_requests.py b/test_requests.py new file mode 100644 index 0000000..e3ffc93 --- /dev/null +++ b/test_requests.py @@ -0,0 +1,87 @@ +import requests +from requests import Response +from typing import List, TypeVar, Dict, Any, Optional +import logging + +# 设置日志 +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +T = TypeVar('T') # 泛型类型声明 + +REQUEST_URL = "http://aijinan.biaofun.com.cn/app/query/shandong" # 替换为实际API地址 + +def main(): + cities = ["济南市", "青岛市", "临沂市", "菏泽市", "威海市", "东营市"] + + # 修正：每次请求创建新的参数对象，避免累积 + for city in cities: + params = {"city": city} + + # 发起RPC请求 + response_list = rpc_get(REQUEST_URL, params, False) + + # 处理响应 + if not response_list: + logger.warning(f"Empty response for city: {city}") + continue + + # 设置城市名称并处理后续逻辑 (根据实际Response类调整) + response_list[0]['name'] = city # 这里假定response_list是字典列表 + after(response_list) + +def rpc_get(url: str, params: Dict[str, Any], right_or_wrong: bool) -> Optional[List[T]]: + """ + RPC请求封装 + :param url: 请求URL + :param params: 请求参数 + :param right_or_wrong: 未使用的标志（保留原Java参数） + :return: 响应对象列表 + """ + logger.info(f"Request URL: {url}") + + try: + # 发起POST请求 + response: Response = requests.post(url, data=params) + + # 检查响应状态 + if response.status_code != 200: + logger.error(f"Request failed, Status Code: {response.status_code}, URL: {url}") + return None + + response_text = response.text + logger.debug(f"Response: {response_text}") + + # 解析响应（需要根据实际API响应格式实现） + return parse_response(response_text) + + except Exception as e: + logger.exception(f"RPC request failed: {str(e)}") + return None + +def parse_response(response_text: str) -> List[T]: + """ + 解析API响应 (需要根据实际API响应格式实现) + 示例实现 - 替换为实际解析逻辑 + """ + # 这里需要根据实际API返回格式实现解析 + # 示例：解析为JSON对象 + import json + try: + data = json.loads(response_text) + # 根据实际数据结构返回列表 + return [data] if isinstance(data, dict) else data + except json.JSONDecodeError: + logger.error("Invalid JSON response") + return [] + +def after(response_list: List[Any]): + """ + 后续处理逻辑 (根据实际需求实现) + """ + # 示例实现 + print(f"Processing response for: {response_list[0].get('name')}") + # 实际业务逻辑... + +if __name__ == "__main__": + main() \ No newline at end of file