Showing preview only (549K chars total). Download the full file or copy to clipboard to get everything.
Repository: jianchang512/ChatTTS-ui
Branch: main
Commit: c9c1b5b79392
Files: 80
Total size: 523.4 KB
Directory structure:
gitextract_cimg12e7/
├── .github/
│ └── FUNDING.yml
├── .gitignore
├── ChatTTS/
│ ├── __init__.py
│ ├── config/
│ │ ├── __init__.py
│ │ └── config.py
│ ├── core.py
│ ├── experimental/
│ │ └── llm.py
│ ├── infer/
│ │ └── api.py
│ ├── model/
│ │ ├── __init__.py
│ │ ├── cuda/
│ │ │ ├── __init__.py
│ │ │ ├── patch.py
│ │ │ └── te_llama.py
│ │ ├── dvae.py
│ │ ├── gpt.py
│ │ ├── processors.py
│ │ └── tokenizer.py
│ ├── norm.py
│ ├── res/
│ │ ├── __init__.py
│ │ ├── homophones_map.json
│ │ └── sha256_map.json
│ └── utils/
│ ├── __init__.py
│ ├── dl.py
│ ├── download.py
│ ├── gpu.py
│ ├── gpu_utils.py
│ ├── infer_utils.py
│ ├── io.py
│ ├── io_utils.py
│ └── log.py
├── Dockerfile.cpu
├── Dockerfile.gpu
├── LICENSE
├── README.md
├── README_EN.md
├── app.py
├── asset/
│ └── 模型下载说明.txt
├── cover-pt.py
├── docker-compose.cpu.yaml
├── docker-compose.gpu.yaml
├── faq.md
├── ffmpeg/
│ └── ffmpeg下载.txt
├── pyproject.toml
├── requirements.txt
├── run.bat
├── run.py
├── runtest.bat
├── start.bat
├── static/
│ └── js/
│ └── layer/
│ ├── layer.js
│ ├── mobile/
│ │ ├── layer.js
│ │ └── need/
│ │ └── layer.css
│ └── theme/
│ └── default/
│ └── layer.css
├── templates/
│ ├── index.html
│ └── indexen.html
├── test.py
├── tools/
│ ├── __init__.py
│ ├── audio/
│ │ ├── __init__.py
│ │ └── np.py
│ ├── checksum/
│ │ ├── main.go
│ │ └── tmpl.go
│ ├── llm/
│ │ ├── __init__.py
│ │ └── llm.py
│ ├── logger/
│ │ ├── __init__.py
│ │ └── log.py
│ ├── normalizer/
│ │ ├── __init__.py
│ │ ├── en.py
│ │ └── zh.py
│ └── seeder/
│ ├── __init__.py
│ └── ctx.py
└── uilib/
├── __init__.py
├── cfg.py
├── utils.py
└── zh_normalization/
├── README.md
├── __init__.py
├── char_convert.py
├── chronology.py
├── constants.py
├── num.py
├── phonecode.py
├── quantifier.py
└── text_normlization.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms
custom: https://ko-fi.com/jianchang512
================================================
FILE: .gitignore
================================================
*.log
*.srt
.idea
models/*
dev
venv
dist
source
build
__pycache__
*.spec
*.ui
*.bak
*.aac
*.pt
# *.wav
pack.bat
gitcmd.bat
logs
poetry.lock
docs
static/wavs/*
examples
ffmpeg/ffmpeg.exe
asset/*.pt
================================================
FILE: ChatTTS/__init__.py
================================================
from .core import Chat
================================================
FILE: ChatTTS/config/__init__.py
================================================
from .config import Config
================================================
FILE: ChatTTS/config/config.py
================================================
from dataclasses import dataclass
@dataclass(repr=False, eq=False)
class Path:
vocos_ckpt_path: str = "asset/Vocos.pt"
dvae_ckpt_path: str = "asset/DVAE_full.pt"
gpt_ckpt_path: str = "asset/GPT.pt"
decoder_ckpt_path: str = "asset/Decoder.pt"
tokenizer_path: str = "asset/tokenizer.pt"
@dataclass(repr=False, eq=False)
class Decoder:
idim: int = 384
odim: int = 384
hidden: int = 512
n_layer: int = 12
bn_dim: int = 128
@dataclass(repr=False, eq=False)
class VQ:
dim: int = 1024
levels: tuple = (5, 5, 5, 5)
G: int = 2
R: int = 2
@dataclass(repr=False, eq=False)
class DVAE:
encoder: Decoder = Decoder(
idim=512,
odim=1024,
hidden=256,
n_layer=12,
bn_dim=128,
)
decoder: Decoder = Decoder(
idim=512,
odim=512,
hidden=256,
n_layer=12,
bn_dim=128,
)
vq: VQ = VQ()
@dataclass(repr=False, eq=False)
class GPT:
hidden_size: int = 768
intermediate_size: int = 3072
num_attention_heads: int = 12
num_hidden_layers: int = 20
use_cache: bool = False
max_position_embeddings: int = 4096
spk_emb_dim: int = 192
spk_KL: bool = False
num_audio_tokens: int = 626
num_vq: int = 4
@dataclass(repr=False, eq=False)
class FeatureExtractorInitArgs:
sample_rate: int = 24000
n_fft: int = 1024
hop_length: int = 256
n_mels: int = 100
padding: str = "center"
@dataclass(repr=False, eq=False)
class FeatureExtractor:
class_path: str = "vocos.feature_extractors.MelSpectrogramFeatures"
init_args: FeatureExtractorInitArgs = FeatureExtractorInitArgs()
@dataclass(repr=False, eq=False)
class BackboneInitArgs:
input_channels: int = 100
dim: int = 512
intermediate_dim: int = 1536
num_layers: int = 8
@dataclass(repr=False, eq=False)
class Backbone:
class_path: str = "vocos.models.VocosBackbone"
init_args: BackboneInitArgs = BackboneInitArgs()
@dataclass(repr=False, eq=False)
class FourierHeadInitArgs:
dim: int = 512
n_fft: int = 1024
hop_length: int = 256
padding: str = "center"
@dataclass(repr=False, eq=False)
class FourierHead:
class_path: str = "vocos.heads.ISTFTHead"
init_args: FourierHeadInitArgs = FourierHeadInitArgs()
@dataclass(repr=False, eq=False)
class Vocos:
feature_extractor: FeatureExtractor = FeatureExtractor()
backbone: Backbone = Backbone()
head: FourierHead = FourierHead()
@dataclass(repr=False, eq=False)
class Config:
path: Path = Path()
decoder: Decoder = Decoder()
dvae: DVAE = DVAE()
gpt: GPT = GPT()
vocos: Vocos = Vocos()
================================================
FILE: ChatTTS/core.py
================================================
import os
import logging
import tempfile
from dataclasses import dataclass, asdict
from typing import Literal, Optional, List, Tuple, Dict, Union
from json import load
from pathlib import Path
import lzma
import numpy as np
import torch
from vocos import Vocos
from vocos.pretrained import instantiate_class
from huggingface_hub import snapshot_download
import pybase16384 as b14
from .config import Config
from .model import DVAE, GPT, gen_logits, Tokenizer
from .utils import (
check_all_assets,
download_all_assets,
select_device,
get_latest_modified_file,
del_all,
)
from .utils import logger as utils_logger
from .norm import Normalizer
class Chat:
def __init__(self, logger=logging.getLogger(__name__)):
self.logger = logger
utils_logger.set_logger(logger)
self.config = Config()
self.normalizer = Normalizer(
os.path.join(os.path.dirname(__file__), "res", "homophones_map.json"),
logger,
)
with open(
os.path.join(os.path.dirname(__file__), "res", "sha256_map.json")
) as f:
self.sha256_map: Dict[str, str] = load(f)
print(self.sha256_map)
self.context = GPT.Context()
def has_loaded(self, use_decoder=False):
not_finish = False
check_list = ["vocos", "gpt", "tokenizer"]
if use_decoder:
check_list.append("decoder")
else:
check_list.append("dvae")
for module in check_list:
if not hasattr(self, module):
self.logger.warning(f"{module} not initialized.")
not_finish = True
if not not_finish:
self.logger.info("all models has been initialized.")
return not not_finish
def download_models(
self,
source: Literal["huggingface", "local", "custom"] = "local",
force_redownload=False,
custom_path: Optional[torch.serialization.FILE_LIKE] = None,
) -> Optional[str]:
if source == "local":
download_path = os.getcwd()
if (
not check_all_assets(Path(download_path), self.sha256_map, update=True)
or force_redownload
):
with tempfile.TemporaryDirectory() as tmp:
download_all_assets(tmpdir=tmp)
if not check_all_assets(
Path(download_path), self.sha256_map, update=False
):
self.logger.error(
"download to local path %s failed.", download_path
)
return None
elif source == "huggingface":
hf_home = os.getenv("HF_HOME", os.path.expanduser("~/.cache/huggingface"))
try:
download_path = get_latest_modified_file(
os.path.join(hf_home, "hub/models--2Noise--ChatTTS/snapshots")
)
except:
download_path = None
if download_path is None or force_redownload:
self.logger.log(
logging.INFO,
f"download from HF: https://huggingface.co/2Noise/ChatTTS",
)
try:
download_path = snapshot_download(
repo_id="2Noise/ChatTTS", allow_patterns=["*.pt", "*.yaml"]
)
except:
download_path = None
else:
self.logger.log(
logging.INFO, f"load latest snapshot from cache: {download_path}"
)
if download_path is None:
self.logger.error("download from huggingface failed.")
return None
elif source == "custom":
self.logger.log(logging.INFO, f"try to load from local: {custom_path}")
if not check_all_assets(Path(custom_path), self.sha256_map, update=False):
self.logger.error("check models in custom path %s failed.", custom_path)
return None
download_path = custom_path
return download_path
def load(
self,
source: Literal["huggingface", "local", "custom"] = "local",
force_redownload=False,
compile: bool = True,
custom_path: Optional[torch.serialization.FILE_LIKE] = None,
device: Optional[torch.device] = None,
coef: Optional[torch.Tensor] = None,
use_flash_attn=False,
) -> bool:
download_path = self.download_models(source, force_redownload, custom_path)
if download_path is None:
return False
return self._load(
device=device,
compile=compile,
coef=coef,
use_flash_attn=use_flash_attn,
**{
k: os.path.join(download_path, v)
for k, v in asdict(self.config.path).items()
},
)
def unload(self):
logger = self.logger
self.normalizer.destroy()
del self.normalizer
del self.sha256_map
del_list = ["vocos", "gpt", "decoder", "dvae", "tokenizer"]
for module in del_list:
if hasattr(self, module):
delattr(self, module)
self.__init__(logger)
def sample_random_speaker(self) -> str:
return self.tokenizer._encode_spk_emb(self._sample_random_speaker())
@torch.inference_mode()
def sample_audio_speaker(self, wav: Union[np.ndarray, torch.Tensor]) -> str:
if isinstance(wav, np.ndarray):
wav = torch.from_numpy(wav).to(self.device)
return self.tokenizer._encode_prompt(self.dvae(wav, "encode").squeeze_(0))
@torch.no_grad()
def _sample_random_speaker(self) -> torch.Tensor:
dim: int = self.gpt.gpt.layers[0].mlp.gate_proj.in_features
spk = (
torch.randn(dim, device=self.std.device, dtype=self.std.dtype)
.mul_(self.std)
.add_(self.mean)
)
return spk
@dataclass(repr=False, eq=False)
class RefineTextParams:
prompt: str = ""
top_P: float = 0.7
top_K: int = 20
temperature: float = 0.7
repetition_penalty: float = 1.0
max_new_token: int = 384
min_new_token: int = 0
show_tqdm: bool = True
ensure_non_empty: bool = True
@dataclass(repr=False, eq=False)
class InferCodeParams(RefineTextParams):
prompt: str = "[speed_5]"
spk_emb: Optional[str] = None
spk_smp: Optional[str] = None
txt_smp: Optional[str] = None
temperature: float = 0.3
repetition_penalty: float = 1.05
max_new_token: int = 2048
stream_batch: int = 24
stream_speed: int = 12000
pass_first_n_batches: int = 2
def infer(
self,
text,
stream=False,
lang=None,
skip_refine_text=False,
refine_text_only=False,
use_decoder=True,
do_text_normalization=True,
do_homophone_replacement=True,
params_refine_text=RefineTextParams(),
params_infer_code=InferCodeParams(),
):
self.context.set(False)
res_gen = self._infer(
text,
stream,
lang,
skip_refine_text,
refine_text_only,
use_decoder,
do_text_normalization,
do_homophone_replacement,
params_refine_text,
params_infer_code,
)
if stream:
return res_gen
else:
return next(res_gen)
def interrupt(self):
self.context.set(True)
@torch.no_grad()
def _load(
self,
vocos_ckpt_path: str = None,
dvae_ckpt_path: str = None,
gpt_ckpt_path: str = None,
decoder_ckpt_path: str = None,
tokenizer_path: str = None,
device: Optional[torch.device] = None,
compile: bool = True,
coef: Optional[str] = None,
use_flash_attn=False,
):
if device is None:
device = select_device()
self.logger.info("use device %s", str(device))
self.device = device
self.compile = compile
feature_extractor = instantiate_class(
args=(), init=asdict(self.config.vocos.feature_extractor)
)
backbone = instantiate_class(args=(), init=asdict(self.config.vocos.backbone))
head = instantiate_class(args=(), init=asdict(self.config.vocos.head))
vocos = (
Vocos(feature_extractor=feature_extractor, backbone=backbone, head=head)
.to(
# vocos on mps will crash, use cpu fallback
"cpu"
if "mps" in str(device)
else device
)
.eval()
)
assert vocos_ckpt_path, "vocos_ckpt_path should not be None"
vocos.load_state_dict(torch.load(vocos_ckpt_path, weights_only=True, mmap=True))
self.vocos = vocos
self.logger.log(logging.INFO, "vocos loaded.")
dvae = (
DVAE(
decoder_config=asdict(self.config.dvae.decoder),
encoder_config=asdict(self.config.dvae.encoder),
vq_config=asdict(self.config.dvae.vq),
dim=self.config.dvae.decoder.idim,
coef=coef,
)
.to(device)
.eval()
)
coef = str(dvae)
assert dvae_ckpt_path, "dvae_ckpt_path should not be None"
dvae.load_state_dict(torch.load(dvae_ckpt_path, weights_only=True, mmap=True))
self.dvae = dvae
self.logger.log(logging.INFO, "dvae loaded.")
gpt = GPT(
gpt_config=asdict(self.config.gpt),
use_flash_attn=use_flash_attn,
device=device,
logger=self.logger,
).eval()
assert gpt_ckpt_path, "gpt_ckpt_path should not be None"
gpt.from_pretrained(gpt_ckpt_path)
gpt.prepare(compile=compile and "cuda" in str(device))
self.gpt = gpt
spk_stat_path = os.path.join(os.path.dirname(gpt_ckpt_path), "spk_stat.pt")
assert os.path.exists(spk_stat_path), f"Missing spk_stat.pt: {spk_stat_path}"
spk_stat: torch.Tensor = torch.load(
spk_stat_path,
weights_only=True,
mmap=True,
map_location=device,
)
self.std, self.mean = spk_stat.requires_grad_(False).chunk(2)
self.logger.log(logging.INFO, "gpt loaded.")
decoder = (
DVAE(
decoder_config=asdict(self.config.decoder),
dim=self.config.decoder.idim,
coef=coef,
)
.to(device)
.eval()
)
coef = str(decoder)
assert decoder_ckpt_path, "decoder_ckpt_path should not be None"
decoder.load_state_dict(
torch.load(decoder_ckpt_path, weights_only=True, mmap=True)
)
self.decoder = decoder
self.logger.log(logging.INFO, "decoder loaded.")
if tokenizer_path:
self.tokenizer = Tokenizer(tokenizer_path, device)
self.logger.log(logging.INFO, "tokenizer loaded.")
self.coef = coef
return self.has_loaded()
def _infer(
self,
text,
stream=False,
lang=None,
skip_refine_text=False,
refine_text_only=False,
use_decoder=True,
do_text_normalization=True,
do_homophone_replacement=True,
params_refine_text=RefineTextParams(),
params_infer_code=InferCodeParams(),
):
assert self.has_loaded(use_decoder=use_decoder)
if not isinstance(text, list):
text = [text]
text = [
self.normalizer(
t,
do_text_normalization,
do_homophone_replacement,
lang,
)
for t in text
]
if not skip_refine_text:
refined = self._refine_text(
text,
self.device,
params_refine_text,
)
text_tokens = refined.ids
text_tokens = [i[i.less(self.tokenizer.break_0_ids)] for i in text_tokens]
text = self.tokenizer.decode(text_tokens)
refined.destroy()
if refine_text_only:
yield text
return
if stream:
length = 0
pass_batch_count = 0
for result in self._infer_code(
text,
stream,
self.device,
use_decoder,
params_infer_code,
):
wavs = self._decode_to_wavs(
result.hiddens if use_decoder else result.ids,
use_decoder,
)
result.destroy()
if stream:
pass_batch_count += 1
if pass_batch_count <= params_infer_code.pass_first_n_batches:
continue
a = length
b = a + params_infer_code.stream_speed
if b > wavs.shape[1]:
b = wavs.shape[1]
new_wavs = wavs[:, a:b]
length = b
yield new_wavs
else:
yield wavs
if stream:
new_wavs = wavs[:, length:]
# Identify rows with non-zero elements using np.any
# keep_rows = np.any(array != 0, axis=1)
keep_cols = np.sum(new_wavs != 0, axis=0) > 0
# Filter both rows and columns using slicing
yield new_wavs[:][:, keep_cols]
@staticmethod
@torch.no_grad()
def _encode_spk_emb(spk_emb: torch.Tensor) -> str:
arr: np.ndarray = spk_emb.to(dtype=torch.float16, device="cpu").numpy()
s = b14.encode_to_string(
lzma.compress(
arr.tobytes(),
format=lzma.FORMAT_RAW,
filters=[{"id": lzma.FILTER_LZMA2, "preset": 9 | lzma.PRESET_EXTREME}],
),
)
del arr
return s
@torch.inference_mode()
def _vocos_decode(self, spec: torch.Tensor) -> np.ndarray:
if "mps" in str(self.device):
return self.vocos.decode(spec.cpu()).cpu().numpy()
else:
return self.vocos.decode(spec).cpu().numpy()
@torch.inference_mode()
def _decode_to_wavs(
self,
result_list: List[torch.Tensor],
use_decoder: bool,
):
decoder = self.decoder if use_decoder else self.dvae
max_x_len = -1
if len(result_list) == 0:
return np.array([], dtype=np.float32)
for result in result_list:
if result.size(0) > max_x_len:
max_x_len = result.size(0)
batch_result = torch.zeros(
(len(result_list), result_list[0].size(1), max_x_len),
dtype=result_list[0].dtype,
device=result_list[0].device,
)
for i in range(len(result_list)):
src = result_list[i]
batch_result[i].narrow(1, 0, src.size(0)).copy_(src.permute(1, 0))
del src
del_all(result_list)
mel_specs = decoder(batch_result)
del batch_result
wavs = self._vocos_decode(mel_specs)
del mel_specs
return wavs
@torch.no_grad()
def _infer_code(
self,
text: Tuple[List[str], str],
stream: bool,
device: torch.device,
return_hidden: bool,
params: InferCodeParams,
):
gpt = self.gpt
if not isinstance(text, list):
text = [text]
assert len(text), "text should not be empty"
if not isinstance(params.temperature, list):
temperature = [params.temperature] * gpt.num_vq
else:
temperature = params.temperature
for i, t in enumerate(text):
text[i] = (
t.replace("[Stts]", "")
.replace("[spk_emb]", "")
.replace("[empty_spk]", "")
.strip()
)
"""
see https://github.com/2noise/ChatTTS/issues/459
"""
if params.prompt:
text = [params.prompt + i for i in text]
txt_smp = "" if params.txt_smp is None else params.txt_smp
if params.spk_emb is not None:
text = [f"[Stts][spk_emb]{txt_smp}{i}[Ptts]" for i in text]
else:
text = [f"[Stts][empty_spk]{txt_smp}{i}[Ptts]" for i in text]
input_ids, attention_mask, text_mask = self.tokenizer.encode(
text,
self.gpt.num_vq,
prompt_str=params.spk_smp,
device=gpt.device_gpt,
)
emb = gpt(input_ids, text_mask)
del text_mask
if params.spk_emb is not None:
self.tokenizer.apply_spk_emb(
emb, params.spk_emb, input_ids, self.gpt.device_gpt
)
num_code = int(gpt.emb_code[0].num_embeddings - 1)
logits_warpers, logits_processors = gen_logits(
num_code=num_code,
top_P=params.top_P,
top_K=params.top_K,
repetition_penalty=params.repetition_penalty,
)
result = gpt.generate(
emb,
input_ids,
temperature=torch.tensor(temperature, device=device),
eos_token=num_code,
attention_mask=attention_mask,
max_new_token=params.max_new_token,
min_new_token=params.min_new_token,
logits_warpers=logits_warpers,
logits_processors=logits_processors,
infer_text=False,
return_hidden=return_hidden,
stream=stream,
show_tqdm=params.show_tqdm,
ensure_non_empty=params.ensure_non_empty,
stream_batch=params.stream_batch,
context=self.context,
)
del emb, input_ids
del_all(logits_warpers)
del_all(logits_processors)
return result
@torch.no_grad()
def _refine_text(
self,
text: str,
device: torch.device,
params: RefineTextParams,
):
gpt = self.gpt
if not isinstance(text, list):
text = [text]
text = [f"[Sbreak]{i}[Pbreak]{params.prompt}" for i in text]
input_ids, attention_mask, text_mask = self.tokenizer.encode(
text,
self.gpt.num_vq,
device=gpt.device_gpt,
)
logits_warpers, logits_processors = gen_logits(
num_code=self.tokenizer.len,
top_P=params.top_P,
top_K=params.top_K,
repetition_penalty=params.repetition_penalty,
)
emb = gpt(input_ids, text_mask)
del text_mask
result = next(
gpt.generate(
emb,
input_ids,
temperature=torch.tensor([params.temperature], device=device),
eos_token=self.tokenizer.eos_token,
attention_mask=attention_mask,
max_new_token=params.max_new_token,
min_new_token=params.min_new_token,
logits_warpers=logits_warpers,
logits_processors=logits_processors,
infer_text=True,
stream=False,
show_tqdm=params.show_tqdm,
ensure_non_empty=params.ensure_non_empty,
context=self.context,
)
)
del emb, input_ids
del_all(logits_warpers)
del_all(logits_processors)
return result
================================================
FILE: ChatTTS/experimental/llm.py
================================================
from openai import OpenAI
prompt_dict = {
'kimi': [ {"role": "system", "content": "你是 Kimi，由 Moonshot AI 提供的人工智能助手，你更擅长中文和英文的对话。"},
{"role": "user", "content": "你好，请注意你现在生成的文字要按照人日常生活的口吻，你的回复将会后续用TTS模型转为语音，并且请把回答控制在100字以内。并且标点符号仅包含逗号和句号，将数字等转为文字回答。"},
{"role": "assistant", "content": "好的，我现在生成的文字将按照人日常生活的口吻， 并且我会把回答控制在一百字以内, 标点符号仅包含逗号和句号，将阿拉伯数字等转为中文文字回答。下面请开始对话。"},],
'deepseek': [
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "你好，请注意你现在生成的文字要按照人日常生活的口吻，你的回复将会后续用TTS模型转为语音，并且请把回答控制在100字以内。并且标点符号仅包含逗号和句号，将数字等转为文字回答。"},
{"role": "assistant", "content": "好的，我现在生成的文字将按照人日常生活的口吻， 并且我会把回答控制在一百字以内, 标点符号仅包含逗号和句号，将阿拉伯数字等转为中文文字回答。下面请开始对话。"},],
'deepseek_TN': [
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "你好，现在我们在处理TTS的文本输入，下面将会给你输入一段文本，请你将其中的阿拉伯数字等等转为文字表达，并且输出的文本里仅包含逗号和句号这两个标点符号"},
{"role": "assistant", "content": "好的，我现在对TTS的文本输入进行处理。这一般叫做text normalization。下面请输入"},
{"role": "user", "content": "We paid $123 for this desk."},
{"role": "assistant", "content": "We paid one hundred and twenty three dollars for this desk."},
{"role": "user", "content": "详询请拨打010-724654"},
{"role": "assistant", "content": "详询请拨打零幺零，七二四六五四"},
{"role": "user", "content": "罗森宣布将于7月24日退市，在华门店超6000家！"},
{"role": "assistant", "content": "罗森宣布将于七月二十四日退市，在华门店超过六千家。"},
],
}
class llm_api:
def __init__(self, api_key, base_url, model):
self.client = OpenAI(
api_key = api_key,
base_url = base_url,
)
self.model = model
def call(self, user_question, temperature = 0.3, prompt_version='kimi', **kwargs):
completion = self.client.chat.completions.create(
model = self.model,
messages = prompt_dict[prompt_version]+[{"role": "user", "content": user_question},],
temperature = temperature,
**kwargs
)
return completion.choices[0].message.content
================================================
FILE: ChatTTS/infer/api.py
================================================
import torch
import torch.nn.functional as F
from transformers.generation import TopKLogitsWarper, TopPLogitsWarper
from ..utils.infer_utils import CustomRepetitionPenaltyLogitsProcessorRepeat
def infer_code(
models,
text,
spk_emb = None,
top_P = 0.7,
top_K = 20,
temperature = 0.3,
repetition_penalty = 1.05,
max_new_token = 2048,
stream=False,
**kwargs
):
device = next(models['gpt'].parameters()).device
if not isinstance(text, list):
text = [text]
if not isinstance(temperature, list):
temperature = [temperature] * models['gpt'].num_vq
if spk_emb is not None:
text = [f'[Stts][spk_emb]{i}[Ptts]' for i in text]
else:
text = [f'[Stts][empty_spk]{i}[Ptts]' for i in text]
text_token = models['tokenizer'](text, return_tensors='pt', add_special_tokens=False, padding=True).to(device)
input_ids = text_token['input_ids'][...,None].expand(-1, -1, models['gpt'].num_vq)
text_mask = torch.ones(text_token['input_ids'].shape, dtype=bool, device=device)
inputs = {
'input_ids': input_ids,
'text_mask': text_mask,
'attention_mask': text_token['attention_mask'],
}
emb = models['gpt'].get_emb(**inputs)
if spk_emb is not None:
emb[inputs['input_ids'][..., 0] == models['tokenizer'].convert_tokens_to_ids('[spk_emb]')] = \
F.normalize(spk_emb.to(device).to(emb.dtype)[None].expand(len(text), -1), p=2.0, dim=1, eps=1e-12)
num_code = models['gpt'].emb_code[0].num_embeddings - 1
LogitsWarpers = []
if top_P is not None:
LogitsWarpers.append(TopPLogitsWarper(top_P, min_tokens_to_keep=3))
if top_K is not None:
LogitsWarpers.append(TopKLogitsWarper(top_K, min_tokens_to_keep=3))
LogitsProcessors = []
if repetition_penalty is not None and repetition_penalty != 1:
LogitsProcessors.append(CustomRepetitionPenaltyLogitsProcessorRepeat(\
repetition_penalty, num_code, 16))
result = models['gpt'].generate(
emb, inputs['input_ids'],
temperature = torch.tensor(temperature, device=device),
attention_mask = inputs['attention_mask'],
LogitsWarpers = LogitsWarpers,
LogitsProcessors = LogitsProcessors,
eos_token = num_code,
max_new_token = max_new_token,
infer_text = False,
stream = stream,
**kwargs
)
return result
def refine_text(
models,
text,
top_P = 0.7,
top_K = 20,
temperature = 0.7,
repetition_penalty = 1.0,
max_new_token = 384,
prompt = '',
**kwargs
):
device = next(models['gpt'].parameters()).device
if not isinstance(text, list):
text = [text]
assert len(text), 'text should not be empty'
text = [f"[Sbreak]{i}[Pbreak]{prompt}" for i in text]
text_token = models['tokenizer'](text, return_tensors='pt', add_special_tokens=False, padding=True).to(device)
text_mask = torch.ones(text_token['input_ids'].shape, dtype=bool, device=device)
inputs = {
'input_ids': text_token['input_ids'][...,None].expand(-1, -1, models['gpt'].num_vq),
'text_mask': text_mask,
'attention_mask': text_token['attention_mask'],
}
LogitsWarpers = []
if top_P is not None:
LogitsWarpers.append(TopPLogitsWarper(top_P, min_tokens_to_keep=3))
if top_K is not None:
LogitsWarpers.append(TopKLogitsWarper(top_K, min_tokens_to_keep=3))
LogitsProcessors = []
if repetition_penalty is not None and repetition_penalty != 1:
LogitsProcessors.append(CustomRepetitionPenaltyLogitsProcessorRepeat(repetition_penalty, len(models['tokenizer']), 16))
result = models['gpt'].generate(
models['gpt'].get_emb(**inputs), inputs['input_ids'],
temperature = torch.tensor([temperature,], device=device),
attention_mask = inputs['attention_mask'],
LogitsWarpers = LogitsWarpers,
LogitsProcessors = LogitsProcessors,
eos_token = torch.tensor(models['tokenizer'].convert_tokens_to_ids('[Ebreak]'), device=device)[None],
max_new_token = max_new_token,
infer_text = True,
stream = False,
**kwargs
)
return next(result)
================================================
FILE: ChatTTS/model/__init__.py
================================================
from .dvae import DVAE
from .gpt import GPT
from .processors import gen_logits
from .tokenizer import Tokenizer
================================================
FILE: ChatTTS/model/cuda/__init__.py
================================================
from .te_llama import TELlamaModel
================================================
FILE: ChatTTS/model/cuda/patch.py
================================================
import torch
class LlamaRMSNorm(torch.nn.Module):
def __init__(self, hidden_size, eps=1e-6):
"""
LlamaRMSNorm is equivalent to T5LayerNorm
"""
super().__init__()
self.weight = torch.nn.Parameter(torch.ones(hidden_size))
self.variance_epsilon = eps
def forward(self, hidden_states: torch.Tensor):
input_dtype = hidden_states.dtype
hidden_states = hidden_states.to(torch.float32)
variance = hidden_states.pow(2).mean(-1, keepdim=True)
hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
return self.weight.to(hidden_states.device) * hidden_states.to(input_dtype)
================================================
FILE: ChatTTS/model/cuda/te_llama.py
================================================
# Copyright (c) 2022-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# See LICENSE for license information.
#
# From https://github.com/NVIDIA/TransformerEngine/blob/main/docs/examples/te_llama/te_llama.py
#
# Edited by fumiama.
import re
from contextlib import contextmanager
from typing import Dict
import transformer_engine as te
from transformer_engine.pytorch.attention import RotaryPositionEmbedding
import torch
import transformers
from transformers.models.llama.modeling_llama import (
LlamaModel,
LlamaConfig,
)
from transformers.modeling_utils import _load_state_dict_into_model
from .patch import LlamaRMSNorm
@contextmanager
def replace_decoder(te_decoder_cls, llama_rms_norm_cls):
"""
Replace `LlamaDecoderLayer` with custom `TELlamaDecoderLayer`.
"""
original_llama_decoder_cls = (
transformers.models.llama.modeling_llama.LlamaDecoderLayer
)
transformers.models.llama.modeling_llama.LlamaDecoderLayer = te_decoder_cls
original_llama_rms_norm_cls = transformers.models.llama.modeling_llama.LlamaRMSNorm
transformers.models.llama.modeling_llama.LlamaRMSNorm = llama_rms_norm_cls
try:
yield
finally:
transformers.models.llama.modeling_llama.LlamaDecoderLayer = (
original_llama_decoder_cls
)
transformers.models.llama.modeling_llama.LlamaRMSNorm = (
original_llama_rms_norm_cls
)
class TELlamaDecoderLayer(te.pytorch.TransformerLayer):
"""
Wrapper class over TE's `TransformerLayer`. This makes the wrapper very
similar to HF's `LlamaDecoderLayer` and easier to replace it in the code.
Args:
config: LlamaConfig
args: positional args (for compatibility with `LlamaDecoderLayer`)
kwargs: keyword args (for compatibility with `LlamaDecoderLayer`)
"""
def __init__(self, config, *args, **kwargs):
super().__init__(
hidden_size=config.hidden_size,
ffn_hidden_size=config.intermediate_size,
num_attention_heads=config.num_attention_heads,
bias=False,
layernorm_epsilon=config.rms_norm_eps,
hidden_dropout=0,
attention_dropout=0,
fuse_qkv_params=False,
normalization="RMSNorm",
activation="swiglu",
attn_input_format="bshd",
num_gqa_groups=config.num_key_value_heads,
)
te_rope = RotaryPositionEmbedding(
config.hidden_size // config.num_attention_heads
)
self.te_rope_emb = te_rope(max_seq_len=config.max_position_embeddings).cuda()
def forward(self, hidden_states, *args, attention_mask, **kwargs):
"""
Custom forward to make sure we only pass relevant arguments to the
forward pass of the `TransformerLayer`. Also, make sure the output
format matches the output of the HF's `LlamaDecoderLayer`.
"""
return (
super().forward(
hidden_states,
attention_mask=attention_mask,
rotary_pos_emb=self.te_rope_emb,
),
)
class TELlamaModel:
"""
LM created with `LlamaModel`. The underlying `LlamaDecoderLayer`
class is monkey-patched with `TELlamaDecoderLayer` class before
initializing the causal LM with `LlamaModel`.
Args:
config: LlamaConfig
"""
def __new__(cls, config: LlamaConfig):
with replace_decoder(
te_decoder_cls=TELlamaDecoderLayer, llama_rms_norm_cls=LlamaRMSNorm
):
model = LlamaModel(config)
return model
@classmethod
def from_state_dict(
cls,
state_dict: Dict[str, torch.Tensor],
config: LlamaConfig,
):
"""
Custom method adapted from `from_pretrained` method in HuggingFace
Transformers repo: https://github.com/huggingface/transformers/blob/f497f564bb76697edab09184a252fc1b1a326d1e/src/transformers/modeling_utils.py#L2579
"""
vanilla_model = cls(config)
# replace_params copies parameters relevant only to TransformerEngine
_replace_params(state_dict, vanilla_model.state_dict(), config)
# _load_state_dict_into_model copies parameters other than those in TransformerEngine
_load_state_dict_into_model(vanilla_model, state_dict, start_prefix="")
return vanilla_model
def _replace_params(hf_state_dict, te_state_dict, config):
# collect all layer prefixes to update
all_layer_prefixes = set()
for param_key in hf_state_dict.keys():
layer_prefix_pat = "model.layers.\d+."
m = re.match(layer_prefix_pat, param_key)
if m is not None:
all_layer_prefixes.add(m.group())
for layer_prefix in all_layer_prefixes:
# When loading weights into models with less number of layers, skip the
# copy if the corresponding layer doesn't exist in HF model
if layer_prefix + "input_layernorm.weight" in hf_state_dict:
te_state_dict[
layer_prefix + "self_attention.layernorm_qkv.layer_norm_weight"
].data[:] = hf_state_dict[layer_prefix + "input_layernorm.weight"].data[:]
if layer_prefix + "self_attn.q_proj.weight" in hf_state_dict:
te_state_dict[
layer_prefix + "self_attention.layernorm_qkv.query_weight"
].data[:] = hf_state_dict[layer_prefix + "self_attn.q_proj.weight"].data[:]
if layer_prefix + "self_attn.k_proj.weight" in hf_state_dict:
te_state_dict[
layer_prefix + "self_attention.layernorm_qkv.key_weight"
].data[:] = hf_state_dict[layer_prefix + "self_attn.k_proj.weight"].data[:]
if layer_prefix + "self_attn.v_proj.weight" in hf_state_dict:
te_state_dict[
layer_prefix + "self_attention.layernorm_qkv.value_weight"
].data[:] = hf_state_dict[layer_prefix + "self_attn.v_proj.weight"].data[:]
if layer_prefix + "self_attn.o_proj.weight" in hf_state_dict:
te_state_dict[layer_prefix + "self_attention.proj.weight"].data[:] = (
hf_state_dict[layer_prefix + "self_attn.o_proj.weight"].data[:]
)
if layer_prefix + "post_attention_layernorm.weight" in hf_state_dict:
te_state_dict[layer_prefix + "layernorm_mlp.layer_norm_weight"].data[:] = (
hf_state_dict[layer_prefix + "post_attention_layernorm.weight"].data[:]
)
# It may happen that gate_proj.weight and up_proj.weight will be in the different files, so we need to
# load them separately.
if layer_prefix + "mlp.gate_proj.weight" in hf_state_dict:
te_state_dict[layer_prefix + "layernorm_mlp.fc1_weight"].data[
: config.intermediate_size
] = hf_state_dict[layer_prefix + "mlp.gate_proj.weight"].data
if layer_prefix + "mlp.up_proj.weight" in hf_state_dict:
te_state_dict[layer_prefix + "layernorm_mlp.fc1_weight"].data[
config.intermediate_size :
] = hf_state_dict[layer_prefix + "mlp.up_proj.weight"].data
if layer_prefix + "mlp.down_proj.weight" in hf_state_dict:
te_state_dict[layer_prefix + "layernorm_mlp.fc2_weight"].data[:] = (
hf_state_dict[layer_prefix + "mlp.down_proj.weight"].data[:]
)
return all_layer_prefixes
================================================
FILE: ChatTTS/model/dvae.py
================================================
import math
from typing import List, Optional, Literal, Tuple
import numpy as np
import pybase16384 as b14
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchaudio
from vector_quantize_pytorch import GroupedResidualFSQ
class ConvNeXtBlock(nn.Module):
def __init__(
self,
dim: int,
intermediate_dim: int,
kernel: int,
dilation: int,
layer_scale_init_value: float = 1e-6,
):
# ConvNeXt Block copied from Vocos.
super().__init__()
self.dwconv = nn.Conv1d(
dim,
dim,
kernel_size=kernel,
padding=dilation * (kernel // 2),
dilation=dilation,
groups=dim,
) # depthwise conv
self.norm = nn.LayerNorm(dim, eps=1e-6)
self.pwconv1 = nn.Linear(
dim, intermediate_dim
) # pointwise/1x1 convs, implemented with linear layers
self.act = nn.GELU()
self.pwconv2 = nn.Linear(intermediate_dim, dim)
self.gamma = (
nn.Parameter(layer_scale_init_value * torch.ones(dim), requires_grad=True)
if layer_scale_init_value > 0
else None
)
def forward(self, x: torch.Tensor, cond=None) -> torch.Tensor:
residual = x
y = self.dwconv(x)
y.transpose_(1, 2) # (B, C, T) -> (B, T, C)
x = self.norm(y)
del y
y = self.pwconv1(x)
del x
x = self.act(y)
del y
y = self.pwconv2(x)
del x
if self.gamma is not None:
y *= self.gamma
y.transpose_(1, 2) # (B, T, C) -> (B, C, T)
x = y + residual
del y
return x
class GFSQ(nn.Module):
def __init__(
self, dim: int, levels: List[int], G: int, R: int, eps=1e-5, transpose=True
):
super(GFSQ, self).__init__()
self.quantizer = GroupedResidualFSQ(
dim=dim,
levels=list(levels),
num_quantizers=R,
groups=G,
)
self.n_ind = math.prod(levels)
self.eps = eps
self.transpose = transpose
self.G = G
self.R = R
def _embed(self, x: torch.Tensor):
if self.transpose:
x = x.transpose(1, 2)
"""
x = rearrange(
x, "b t (g r) -> g b t r", g = self.G, r = self.R,
)
"""
x = x.view(x.size(0), x.size(1), self.G, self.R).permute(2, 0, 1, 3)
feat = self.quantizer.get_output_from_indices(x)
return feat.transpose_(1, 2) if self.transpose else feat
def __call__(self, x: torch.Tensor) -> torch.Tensor:
return super().__call__(x)
def forward(self, x: torch.Tensor) -> torch.Tensor:
if self.transpose:
x.transpose_(1, 2)
# feat, ind = self.quantizer(x)
_, ind = self.quantizer(x)
"""
ind = rearrange(
ind, "g b t r ->b t (g r)",
)
"""
ind = ind.permute(1, 2, 0, 3).contiguous()
ind = ind.view(ind.size(0), ind.size(1), -1)
"""
embed_onehot_tmp = F.one_hot(ind.long(), self.n_ind)
embed_onehot = embed_onehot_tmp.to(x.dtype)
del embed_onehot_tmp
e_mean = torch.mean(embed_onehot, dim=[0, 1])
# e_mean = e_mean / (e_mean.sum(dim=1) + self.eps).unsqueeze(1)
torch.div(e_mean, (e_mean.sum(dim=1) + self.eps).unsqueeze(1), out=e_mean)
perplexity = torch.exp(-torch.sum(e_mean * torch.log(e_mean + self.eps), dim=1))
return
torch.zeros(perplexity.shape, dtype=x.dtype, device=x.device),
feat.transpose_(1, 2) if self.transpose else feat,
perplexity,
"""
return ind.transpose_(1, 2) if self.transpose else ind
class DVAEDecoder(nn.Module):
def __init__(
self,
idim: int,
odim: int,
n_layer=12,
bn_dim=64,
hidden=256,
kernel=7,
dilation=2,
up=False,
):
super().__init__()
self.up = up
self.conv_in = nn.Sequential(
nn.Conv1d(idim, bn_dim, 3, 1, 1),
nn.GELU(),
nn.Conv1d(bn_dim, hidden, 3, 1, 1),
)
self.decoder_block = nn.ModuleList(
[
ConvNeXtBlock(
hidden,
hidden * 4,
kernel,
dilation,
)
for _ in range(n_layer)
]
)
self.conv_out = nn.Conv1d(hidden, odim, kernel_size=1, bias=False)
def forward(self, x: torch.Tensor, conditioning=None) -> torch.Tensor:
# B, C, T
y = self.conv_in(x)
del x
for f in self.decoder_block:
y = f(y, conditioning)
x = self.conv_out(y)
del y
return x
class MelSpectrogramFeatures(torch.nn.Module):
def __init__(
self,
sample_rate=24000,
n_fft=1024,
hop_length=256,
n_mels=100,
padding: Literal["center", "same"] = "center",
):
super().__init__()
if padding not in ["center", "same"]:
raise ValueError("Padding must be 'center' or 'same'.")
self.padding = padding
self.mel_spec = torchaudio.transforms.MelSpectrogram(
sample_rate=sample_rate,
n_fft=n_fft,
hop_length=hop_length,
n_mels=n_mels,
center=padding == "center",
power=1,
)
def __call__(self, audio: torch.Tensor) -> torch.Tensor:
return super().__call__(audio)
def forward(self, audio: torch.Tensor) -> torch.Tensor:
mel: torch.Tensor = self.mel_spec(audio)
features = torch.log(torch.clip(mel, min=1e-5))
return features
class DVAE(nn.Module):
def __init__(
self,
decoder_config: dict,
encoder_config: Optional[dict] = None,
vq_config: Optional[dict] = None,
dim=512,
coef: Optional[str] = None,
):
super().__init__()
if coef is None:
coef = torch.rand(100)
else:
coef = torch.from_numpy(
np.copy(np.frombuffer(b14.decode_from_string(coef), dtype=np.float32))
)
self.register_buffer("coef", coef.unsqueeze(0).unsqueeze_(2))
if encoder_config is not None:
self.downsample_conv = nn.Sequential(
nn.Conv1d(100, dim, 3, 1, 1),
nn.GELU(),
nn.Conv1d(dim, dim, 4, 2, 1),
nn.GELU(),
)
self.preprocessor_mel = MelSpectrogramFeatures()
self.encoder: Optional[DVAEDecoder] = DVAEDecoder(**encoder_config)
self.decoder = DVAEDecoder(**decoder_config)
self.out_conv = nn.Conv1d(dim, 100, 3, 1, 1, bias=False)
if vq_config is not None:
self.vq_layer = GFSQ(**vq_config)
else:
self.vq_layer = None
def __repr__(self) -> str:
return b14.encode_to_string(
self.coef.cpu().numpy().astype(np.float32).tobytes()
)
def __call__(
self, inp: torch.Tensor, mode: Literal["encode", "decode"] = "decode"
) -> torch.Tensor:
return super().__call__(inp, mode)
@torch.inference_mode()
def forward(
self, inp: torch.Tensor, mode: Literal["encode", "decode"] = "decode"
) -> torch.Tensor:
if mode == "encode" and hasattr(self, "encoder") and self.vq_layer is not None:
mel = self.preprocessor_mel(inp)
x: torch.Tensor = self.downsample_conv(
torch.div(mel, self.coef.view(100, 1).expand(mel.shape), out=mel),
).unsqueeze_(0)
del mel
x = self.encoder(x)
ind = self.vq_layer(x)
del x
return ind
if self.vq_layer is not None:
vq_feats = self.vq_layer._embed(inp)
else:
vq_feats = inp
vq_feats = (
vq_feats.view(
(vq_feats.size(0), 2, vq_feats.size(1) // 2, vq_feats.size(2)),
)
.permute(0, 2, 3, 1)
.flatten(2)
)
dec_out = self.out_conv(
self.decoder(
x=vq_feats,
),
)
del vq_feats
return torch.mul(dec_out, self.coef, out=dec_out)
================================================
FILE: ChatTTS/model/gpt.py
================================================
import platform
from dataclasses import dataclass
import logging
from typing import Union, List, Optional, Tuple
import gc
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.utils.parametrize as P
from torch.nn.utils.parametrizations import weight_norm
from tqdm import tqdm
from transformers import LlamaModel, LlamaConfig, LogitsWarper
from transformers.cache_utils import Cache
from transformers.modeling_outputs import BaseModelOutputWithPast
from transformers.utils import is_flash_attn_2_available
from .processors import CustomRepetitionPenaltyLogitsProcessorRepeat
from ..utils import del_all
class GPT(nn.Module):
def __init__(
self,
gpt_config: dict,
num_audio_tokens: int = 626,
num_text_tokens: int = 21178,
num_vq=4,
use_flash_attn=False,
device=torch.device("cpu"),
logger=logging.getLogger(__name__),
):
super().__init__()
self.logger = logger
self.device = device
self.device_gpt = device if "mps" not in str(device) else torch.device("cpu")
self.num_vq = num_vq
self.num_audio_tokens = num_audio_tokens
self.use_flash_attn = use_flash_attn
self.gpt, self.llama_config = self._build_llama(gpt_config, self.device_gpt)
self.is_te_llama = False
self.model_dim = int(self.gpt.config.hidden_size)
self.emb_code = nn.ModuleList(
[
nn.Embedding(
num_audio_tokens,
self.model_dim,
device=self.device_gpt,
)
for _ in range(num_vq)
],
)
self.emb_text = nn.Embedding(
num_text_tokens, self.model_dim, device=self.device_gpt
)
self.head_text = weight_norm(
nn.Linear(
self.model_dim,
num_text_tokens,
bias=False,
device=device,
),
name="weight",
)
self.head_code = nn.ModuleList(
[
weight_norm(
nn.Linear(
self.model_dim,
num_audio_tokens,
bias=False,
device=device,
),
name="weight",
)
for _ in range(self.num_vq)
],
)
def from_pretrained(self, file_path: str):
self.load_state_dict(torch.load(file_path, weights_only=True, mmap=True))
if (
"cuda" in str(self.device_gpt) and platform.system().lower() == "linux"
): # is TELlamaModel
try:
from .cuda import TELlamaModel
self.logger.info("Linux with CUDA, try NVIDIA accelerated TELlamaModel")
state_dict = self.gpt.state_dict()
vanilla = TELlamaModel.from_state_dict(state_dict, self.llama_config)
# Force mem release. Taken from huggingface code
del state_dict, self.gpt
gc.collect()
self.gpt = vanilla
self.is_te_llama = True
except Exception as e:
self.logger.warning(
f"use default LlamaModel for importing TELlamaModel error: {e}"
)
class Context:
def __init__(self):
self._interrupt = False
def set(self, v: bool):
self._interrupt = v
def get(self) -> bool:
return self._interrupt
def _build_llama(
self,
config: dict,
device: torch.device,
) -> Tuple[LlamaModel, LlamaConfig]:
if self.use_flash_attn and is_flash_attn_2_available():
llama_config = LlamaConfig(
**config,
attn_implementation="flash_attention_2",
)
self.logger.warning(
"enabling flash_attention_2 may make gpt be even slower"
)
else:
llama_config = LlamaConfig(**config)
model = LlamaModel(llama_config)
del model.embed_tokens
return model.to(device), llama_config
def prepare(self, compile=False):
if self.use_flash_attn and is_flash_attn_2_available():
self.gpt = self.gpt.to(dtype=torch.float16)
if compile and not self.is_te_llama:
try:
self.compile(backend="inductor", dynamic=True)
self.gpt.compile(backend="inductor", dynamic=True)
except RuntimeError as e:
self.logger.warning(f"compile failed: {e}. fallback to normal mode.")
def __call__(
self, input_ids: torch.Tensor, text_mask: torch.Tensor
) -> torch.Tensor:
"""
get_emb
"""
return super().__call__(input_ids, text_mask)
def forward(self, input_ids: torch.Tensor, text_mask: torch.Tensor) -> torch.Tensor:
"""
get_emb
"""
emb_text: torch.Tensor = self.emb_text(
input_ids[text_mask].narrow(1, 0, 1).squeeze_(1).to(self.device_gpt)
)
text_mask_inv = text_mask.logical_not().to(self.device_gpt)
masked_input_ids: torch.Tensor = input_ids[text_mask_inv].to(self.device_gpt)
emb_code = [
self.emb_code[i](masked_input_ids[:, i]) for i in range(self.num_vq)
]
emb_code = torch.stack(emb_code, 2).sum(2)
emb = torch.zeros(
(input_ids.shape[:-1]) + (emb_text.shape[-1],),
device=emb_text.device,
dtype=emb_text.dtype,
)
emb[text_mask] = emb_text
emb[text_mask_inv] = emb_code.to(emb.dtype)
del emb_text, emb_code, text_mask_inv
return emb
@dataclass(repr=False, eq=False)
class _GenerationInputs:
position_ids: torch.Tensor
cache_position: torch.Tensor
use_cache: bool
input_ids: Optional[torch.Tensor] = None
past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None
attention_mask: Optional[torch.Tensor] = None
inputs_embeds: Optional[torch.Tensor] = None
def to(self, device: torch.device, dtype: torch.dtype):
if self.attention_mask is not None:
self.attention_mask = self.attention_mask.to(device, dtype=dtype)
if self.position_ids is not None:
self.position_ids = self.position_ids.to(device, dtype=dtype)
if self.inputs_embeds is not None:
self.inputs_embeds = self.inputs_embeds.to(device, dtype=dtype)
if self.cache_position is not None:
self.cache_position = self.cache_position.to(device, dtype=dtype)
def _prepare_generation_inputs(
self,
input_ids: torch.Tensor,
past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
attention_mask: Optional[torch.Tensor] = None,
inputs_embeds: Optional[torch.Tensor] = None,
cache_position: Optional[torch.Tensor] = None,
position_ids: Optional[torch.Tensor] = None,
use_cache=True,
) -> _GenerationInputs:
# With static cache, the `past_key_values` is None
# TODO joao: standardize interface for the different Cache classes and remove of this if
has_static_cache = False
if past_key_values is None:
if hasattr(self.gpt.layers[0], "self_attn"):
past_key_values = getattr(
self.gpt.layers[0].self_attn, "past_key_value", None
)
has_static_cache = past_key_values is not None
past_length = 0
if past_key_values is not None:
if isinstance(past_key_values, Cache):
past_length = (
int(cache_position[0])
if cache_position is not None
else past_key_values.get_seq_length()
)
max_cache_length = past_key_values.get_max_length()
cache_length = (
past_length
if max_cache_length is None
else min(max_cache_length, past_length)
)
# TODO joao: remove this `else` after `generate` prioritizes `Cache` objects
else:
cache_length = past_length = past_key_values[0][0].shape[2]
max_cache_length = None
# Keep only the unprocessed tokens:
# 1 - If the length of the attention_mask exceeds the length of input_ids, then we are in a setting where
# some of the inputs are exclusively passed as part of the cache (e.g. when passing input_embeds as
# input)
if (
attention_mask is not None
and attention_mask.shape[1] > input_ids.shape[1]
):
start = attention_mask.shape[1] - past_length
input_ids = input_ids.narrow(1, -start, start)
# 2 - If the past_length is smaller than input_ids', then input_ids holds all input tokens. We can discard
# input_ids based on the past_length.
elif past_length < input_ids.shape[1]:
input_ids = input_ids.narrow(
1, past_length, input_ids.size(1) - past_length
)
# 3 - Otherwise (past_length >= input_ids.shape[1]), let's assume input_ids only has unprocessed tokens.
# If we are about to go beyond the maximum cache length, we need to crop the input attention mask.
if (
max_cache_length is not None
and attention_mask is not None
and cache_length + input_ids.shape[1] > max_cache_length
):
attention_mask = attention_mask.narrow(
1, -max_cache_length, max_cache_length
)
if attention_mask is not None and position_ids is None:
# create position_ids on the fly for batch generation
position_ids = attention_mask.long().cumsum(-1) - 1
position_ids.masked_fill_(attention_mask.eq(0), 1)
if past_key_values:
position_ids = position_ids.narrow(
1, -input_ids.shape[1], input_ids.shape[1]
)
input_length = (
position_ids.shape[-1] if position_ids is not None else input_ids.shape[-1]
)
if cache_position is None:
cache_position = torch.arange(
past_length, past_length + input_length, device=input_ids.device
)
else:
cache_position = cache_position.narrow(0, -input_length, input_length)
if has_static_cache:
past_key_values = None
model_inputs = self._GenerationInputs(
position_ids=position_ids,
cache_position=cache_position,
use_cache=use_cache,
)
# if `inputs_embeds` are passed, we only want to use them in the 1st generation step
if inputs_embeds is not None and past_key_values is None:
model_inputs.inputs_embeds = inputs_embeds
else:
# The `contiguous()` here is necessary to have a static stride during decoding. torchdynamo otherwise
# recompiles graphs as the stride of the inputs is a guard. Ref: https://github.com/huggingface/transformers/pull/29114
# TODO: use `next_tokens` directly instead.
model_inputs.input_ids = input_ids.contiguous()
model_inputs.past_key_values = past_key_values
model_inputs.attention_mask = attention_mask
return model_inputs
@dataclass(repr=False, eq=False)
class GenerationOutputs:
ids: List[torch.Tensor]
attentions: List[Optional[Tuple[torch.FloatTensor, ...]]]
hiddens: List[torch.Tensor]
def destroy(self):
del_all(self.ids)
del_all(self.attentions)
del_all(self.hiddens)
def _prepare_generation_outputs(
self,
inputs_ids: torch.Tensor,
start_idx: int,
end_idx: torch.Tensor,
attentions: List[Optional[Tuple[torch.FloatTensor, ...]]],
hiddens: List[torch.Tensor],
infer_text: bool,
) -> GenerationOutputs:
inputs_ids = [
inputs_ids[idx].narrow(0, start_idx, i) for idx, i in enumerate(end_idx)
]
if infer_text:
inputs_ids = [i.narrow(1, 0, 1).squeeze_(1) for i in inputs_ids]
if len(hiddens) > 0:
hiddens = torch.stack(hiddens, 1)
hiddens = [
hiddens[idx].narrow(0, 0, i) for idx, i in enumerate(end_idx.int())
]
return self.GenerationOutputs(
ids=inputs_ids,
attentions=attentions,
hiddens=hiddens,
)
@torch.no_grad()
def generate(
self,
emb: torch.Tensor,
inputs_ids: torch.Tensor,
temperature: torch.Tensor,
eos_token: Union[int, torch.Tensor],
attention_mask: Optional[torch.Tensor] = None,
max_new_token=2048,
min_new_token=0,
logits_warpers: List[LogitsWarper] = [],
logits_processors: List[CustomRepetitionPenaltyLogitsProcessorRepeat] = [],
infer_text=False,
return_attn=False,
return_hidden=False,
stream=False,
show_tqdm=True,
ensure_non_empty=True,
stream_batch=24,
context=Context(),
):
attentions: List[Optional[Tuple[torch.FloatTensor, ...]]] = []
hiddens = []
stream_iter = 0
start_idx, end_idx = inputs_ids.shape[1], torch.zeros(
inputs_ids.shape[0], device=inputs_ids.device, dtype=torch.long
)
finish = torch.zeros(inputs_ids.shape[0], device=inputs_ids.device).bool()
old_temperature = temperature
temperature = (
temperature.unsqueeze(0)
.expand(inputs_ids.shape[0], -1)
.contiguous()
.view(-1, 1)
)
attention_mask_cache = torch.ones(
(
inputs_ids.shape[0],
inputs_ids.shape[1] + max_new_token,
),
dtype=torch.bool,
device=inputs_ids.device,
)
if attention_mask is not None:
attention_mask_cache.narrow(1, 0, attention_mask.shape[1]).copy_(
attention_mask
)
progress = inputs_ids.size(1)
# pre-allocate inputs_ids
inputs_ids_buf = torch.zeros(
inputs_ids.size(0),
progress + max_new_token,
inputs_ids.size(2),
dtype=inputs_ids.dtype,
device=inputs_ids.device,
)
inputs_ids_buf.narrow(1, 0, progress).copy_(inputs_ids)
del inputs_ids
inputs_ids = inputs_ids_buf.narrow(1, 0, progress)
pbar: Optional[tqdm] = None
if show_tqdm:
pbar = tqdm(
total=max_new_token,
desc="text" if infer_text else "code",
bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}(max) [{elapsed}, {rate_fmt}{postfix}]",
)
past_key_values = None
for i in range(max_new_token):
model_input = self._prepare_generation_inputs(
inputs_ids,
past_key_values,
attention_mask_cache.narrow(1, 0, inputs_ids.shape[1]),
use_cache=not self.is_te_llama,
)
if i > 0:
del emb
inputs_ids_emb = model_input.input_ids.to(self.device_gpt)
if infer_text:
emb: torch.Tensor = self.emb_text(inputs_ids_emb[:, :, 0])
else:
code_emb = [
self.emb_code[i](inputs_ids_emb[:, :, i])
for i in range(self.num_vq)
]
emb = torch.stack(code_emb, 3).sum(3)
del inputs_ids_emb, model_input.input_ids
model_input.inputs_embeds = emb
model_input.to(self.device_gpt, self.gpt.dtype)
outputs: BaseModelOutputWithPast = self.gpt(
attention_mask=model_input.attention_mask,
position_ids=model_input.position_ids,
past_key_values=model_input.past_key_values,
inputs_embeds=model_input.inputs_embeds,
use_cache=model_input.use_cache,
output_attentions=return_attn,
cache_position=model_input.cache_position,
)
del_all(model_input)
attentions.append(outputs.attentions)
hidden_states = outputs.last_hidden_state.to(
self.device, dtype=torch.float
) # 🐻
past_key_values = outputs.past_key_values
del_all(outputs)
if return_hidden:
hiddens.append(hidden_states.narrow(1, -1, 1).squeeze_(1))
with P.cached():
if infer_text:
logits: torch.Tensor = self.head_text(hidden_states)
else:
# logits = torch.stack([self.head_code[i](hidden_states) for i in range(self.num_vq)], 3)
logits = torch.empty(
hidden_states.size(0),
hidden_states.size(1),
self.num_audio_tokens,
self.num_vq,
dtype=torch.float,
device=self.device,
)
for num_vq_iter in range(self.num_vq):
x: torch.Tensor = self.head_code[num_vq_iter](hidden_states)
logits[..., num_vq_iter] = x
del x
del hidden_states
# logits = logits[:, -1].float()
logits = logits.narrow(1, -1, 1).squeeze_(1).float()
if not infer_text:
# logits = rearrange(logits, "b c n -> (b n) c")
logits = logits.permute(0, 2, 1)
logits = logits.reshape(-1, logits.size(2))
# logits_token = rearrange(inputs_ids[:, start_idx:], "b c n -> (b n) c")
inputs_ids_sliced = inputs_ids.narrow(
1,
start_idx,
inputs_ids.size(1) - start_idx,
).permute(0, 2, 1)
logits_token = inputs_ids_sliced.reshape(
inputs_ids_sliced.size(0) * inputs_ids_sliced.size(1),
-1,
).to(self.device)
del inputs_ids_sliced
else:
logits_token = (
inputs_ids.narrow(
1,
start_idx,
inputs_ids.size(1) - start_idx,
)
.narrow(2, 0, 1)
.to(self.device)
)
logits /= temperature
for logitsProcessors in logits_processors:
logits = logitsProcessors(logits_token, logits)
for logitsWarpers in logits_warpers:
logits = logitsWarpers(logits_token, logits)
del logits_token
if i < min_new_token:
logits[:, eos_token] = -torch.inf
scores = F.softmax(logits, dim=-1)
del logits
idx_next = torch.multinomial(scores, num_samples=1).to(finish.device)
del scores
if not infer_text:
# idx_next = rearrange(idx_next, "(b n) 1 -> b n", n=self.num_vq)
idx_next = idx_next.view(-1, self.num_vq)
finish_or = idx_next.eq(eos_token).any(1)
finish.logical_or_(finish_or)
del finish_or
inputs_ids_buf.narrow(1, progress, 1).copy_(idx_next.unsqueeze_(1))
else:
finish_or = idx_next.eq(eos_token).any(1)
finish.logical_or_(finish_or)
del finish_or
inputs_ids_buf.narrow(1, progress, 1).copy_(
idx_next.unsqueeze_(-1).expand(-1, -1, self.num_vq),
)
if i == 0 and finish.any():
self.logger.warning(
"unexpected end at index %s",
str([unexpected_idx.item() for unexpected_idx in finish.nonzero()]),
)
if ensure_non_empty:
if show_tqdm:
pbar.close()
self.logger.warning("regenerate in order to ensure non-empty")
del_all(attentions)
del_all(hiddens)
del (
start_idx,
end_idx,
finish,
temperature,
attention_mask_cache,
past_key_values,
idx_next,
inputs_ids_buf,
)
new_gen = self.generate(
emb,
inputs_ids,
old_temperature,
eos_token,
attention_mask,
max_new_token,
min_new_token,
logits_warpers,
logits_processors,
infer_text,
return_attn,
return_hidden,
stream,
show_tqdm,
ensure_non_empty,
stream_batch,
context,
)
for result in new_gen:
yield result
del inputs_ids
return
del idx_next
progress += 1
inputs_ids = inputs_ids_buf.narrow(1, 0, progress)
not_finished = finish.logical_not().to(end_idx.device)
end_idx.add_(not_finished.int())
stream_iter += not_finished.any().int()
if stream:
if stream_iter > 0 and stream_iter % stream_batch == 0:
self.logger.debug("yield stream result, end: %d", end_idx)
yield self._prepare_generation_outputs(
inputs_ids,
start_idx,
end_idx,
attentions,
hiddens,
infer_text,
)
del not_finished
if finish.all() or context.get():
break
if pbar is not None:
pbar.update(1)
if pbar is not None:
pbar.close()
if not finish.all():
if context.get():
self.logger.warning("generation is interrupted")
else:
self.logger.warning(
f"incomplete result. hit max_new_token: {max_new_token}"
)
del finish, inputs_ids_buf
yield self._prepare_generation_outputs(
inputs_ids,
start_idx,
end_idx,
attentions,
hiddens,
infer_text,
)
================================================
FILE: ChatTTS/model/processors.py
================================================
import torch
import torch.nn.functional as F
from transformers.generation import TopKLogitsWarper, TopPLogitsWarper
class CustomRepetitionPenaltyLogitsProcessorRepeat:
def __init__(self, penalty: float, max_input_ids: int, past_window: int):
if not isinstance(penalty, float) or not (penalty > 0):
raise ValueError(
f"`penalty` has to be a strictly positive float, but is {penalty}"
)
self.penalty = penalty
self.max_input_ids = max_input_ids
self.past_window = past_window
def __call__(
self, input_ids: torch.LongTensor, scores: torch.FloatTensor
) -> torch.FloatTensor:
if input_ids.size(1) > self.past_window:
input_ids = input_ids.narrow(1, -self.past_window, self.past_window)
freq = F.one_hot(input_ids, scores.size(1)).sum(1)
if freq.size(0) > self.max_input_ids:
freq.narrow(
0, self.max_input_ids, freq.size(0) - self.max_input_ids
).zero_()
alpha = torch.pow(self.penalty, freq)
scores = scores.contiguous()
inp = scores.multiply(alpha)
oth = scores.divide(alpha)
con = scores < 0
out = torch.where(con, inp, oth)
del inp, oth, scores, con, alpha
return out
def gen_logits(
num_code: int,
top_P=0.7,
top_K=20,
repetition_penalty=1.0,
):
logits_warpers = []
if top_P is not None:
logits_warpers.append(TopPLogitsWarper(top_P, min_tokens_to_keep=3))
if top_K is not None:
logits_warpers.append(TopKLogitsWarper(top_K, min_tokens_to_keep=3))
logits_processors = []
if repetition_penalty is not None and repetition_penalty != 1:
logits_processors.append(
CustomRepetitionPenaltyLogitsProcessorRepeat(
repetition_penalty, num_code, 16
)
)
return logits_warpers, logits_processors
================================================
FILE: ChatTTS/model/tokenizer.py
================================================
import os
os.environ["TOKENIZERS_PARALLELISM"] = "false"
"""
https://stackoverflow.com/questions/62691279/how-to-disable-tokenizers-parallelism-true-false-warning
"""
from typing import List, Tuple, Optional
import lzma
import numpy as np
import pybase16384 as b14
import torch
import torch.nn.functional as F
from transformers import BertTokenizerFast
from ..utils import del_all
class Tokenizer:
def __init__(
self, tokenizer_path: torch.serialization.FILE_LIKE, device: torch.device
):
tokenizer: BertTokenizerFast = torch.load(
tokenizer_path, map_location=device, mmap=True
)
self._tokenizer = tokenizer
self.len = len(tokenizer)
self.spk_emb_ids = tokenizer.convert_tokens_to_ids("[spk_emb]")
self.break_0_ids = tokenizer.convert_tokens_to_ids("[break_0]")
self.eos_token = tokenizer.convert_tokens_to_ids("[Ebreak]")
self.decode = self._tokenizer.batch_decode
@torch.inference_mode()
def encode(
self,
text: List[str],
num_vq: int,
prompt_str: Optional[str] = None,
device="cpu",
) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
input_ids_lst = []
attention_mask_lst = []
max_input_ids_len = -1
max_attention_mask_len = -1
prompt_size = 0
prompt = self._decode_prompt(prompt_str) if prompt_str is not None else None
if prompt is not None:
assert prompt.size(0) == num_vq, "prompt dim 0 must equal to num_vq"
prompt_size = prompt.size(1)
# avoid random speaker embedding of tokenizer in the other dims
for t in text:
x = self._tokenizer.encode_plus(
t, return_tensors="pt", add_special_tokens=False, padding=True
)
input_ids_lst.append(x["input_ids"].squeeze_(0))
attention_mask_lst.append(x["attention_mask"].squeeze_(0))
del_all(x)
ids_sz = input_ids_lst[-1].size(0)
if ids_sz > max_input_ids_len:
max_input_ids_len = ids_sz
attn_sz = attention_mask_lst[-1].size(0)
if attn_sz > max_attention_mask_len:
max_attention_mask_len = attn_sz
if prompt is not None:
max_input_ids_len += prompt_size
max_attention_mask_len += prompt_size
input_ids = torch.zeros(
len(input_ids_lst),
max_input_ids_len,
device=device,
dtype=input_ids_lst[0].dtype,
)
for i in range(len(input_ids_lst)):
input_ids.narrow(0, i, 1).narrow(
1,
max_input_ids_len - prompt_size - input_ids_lst[i].size(0),
input_ids_lst[i].size(0),
).copy_(
input_ids_lst[i]
) # left padding
del_all(input_ids_lst)
attention_mask = torch.zeros(
len(attention_mask_lst),
max_attention_mask_len,
device=device,
dtype=attention_mask_lst[0].dtype,
)
for i in range(len(attention_mask_lst)):
attn = attention_mask.narrow(0, i, 1)
attn.narrow(
1,
max_attention_mask_len - prompt_size - attention_mask_lst[i].size(0),
attention_mask_lst[i].size(0),
).copy_(
attention_mask_lst[i]
) # left padding
if prompt_size > 0:
attn.narrow(
1,
max_attention_mask_len - prompt_size,
prompt_size,
).fill_(1)
del_all(attention_mask_lst)
text_mask = attention_mask.bool()
new_input_ids = input_ids.unsqueeze_(-1).expand(-1, -1, num_vq).clone()
del input_ids
if prompt_size > 0:
text_mask.narrow(1, max_input_ids_len - prompt_size, prompt_size).fill_(0)
prompt_t = prompt.t().unsqueeze_(0).expand(new_input_ids.size(0), -1, -1)
new_input_ids.narrow(
1,
max_input_ids_len - prompt_size,
prompt_size,
).copy_(prompt_t)
del prompt_t
return new_input_ids, attention_mask, text_mask
@staticmethod
def _decode_spk_emb(spk_emb: str) -> np.ndarray:
return np.frombuffer(
lzma.decompress(
b14.decode_from_string(spk_emb),
format=lzma.FORMAT_RAW,
filters=[{"id": lzma.FILTER_LZMA2, "preset": 9 | lzma.PRESET_EXTREME}],
),
dtype=np.float16,
).copy()
@torch.no_grad()
def apply_spk_emb(
self,
emb: torch.Tensor,
spk_emb: str,
input_ids: torch.Tensor,
device: torch.device,
):
n = (
F.normalize(
torch.from_numpy(
self._decode_spk_emb(spk_emb),
),
p=2.0,
dim=0,
eps=1e-12,
)
.to(device)
.unsqueeze_(0)
.expand(emb.size(0), -1)
.unsqueeze_(1)
.expand(emb.shape)
)
cond = input_ids.narrow(-1, 0, 1).eq(self.spk_emb_ids).expand(emb.shape)
torch.where(cond, n, emb, out=emb)
del cond, n
@staticmethod
@torch.no_grad()
def _decode_prompt(prompt: str) -> torch.Tensor:
dec = b14.decode_from_string(prompt)
shp = np.frombuffer(dec[:4], dtype="<u2")
p = np.frombuffer(
lzma.decompress(
dec[4:],
format=lzma.FORMAT_RAW,
filters=[{"id": lzma.FILTER_LZMA2, "preset": 9 | lzma.PRESET_EXTREME}],
),
dtype="<u2",
).copy()
del dec
return torch.from_numpy(p).view(*shp)
@staticmethod
@torch.no_grad()
def _encode_prompt(prompt: torch.Tensor) -> str:
arr: np.ndarray = prompt.to(dtype=torch.uint16, device="cpu").numpy()
shp = arr.shape
assert len(shp) == 2, "prompt must be a 2D tensor"
s = b14.encode_to_string(
np.array(shp, dtype="<u2").tobytes()
+ lzma.compress(
arr.astype("<u2").tobytes(),
format=lzma.FORMAT_RAW,
filters=[{"id": lzma.FILTER_LZMA2, "preset": 9 | lzma.PRESET_EXTREME}],
),
)
del arr
return s
@staticmethod
@torch.no_grad()
def _encode_spk_emb(spk_emb: torch.Tensor) -> str:
arr: np.ndarray = spk_emb.to(dtype=torch.float16, device="cpu").numpy()
s = b14.encode_to_string(
lzma.compress(
arr.tobytes(),
format=lzma.FORMAT_RAW,
filters=[{"id": lzma.FILTER_LZMA2, "preset": 9 | lzma.PRESET_EXTREME}],
),
)
del arr
return s
================================================
FILE: ChatTTS/norm.py
================================================
import json
import logging
import re
from typing import Dict, Tuple, List, Literal, Callable, Optional
import sys
from numba import jit
import numpy as np
from .utils import del_all
@jit
def _find_index(table: np.ndarray, val: np.uint16):
for i in range(table.size):
if table[i] == val:
return i
return -1
@jit
def _fast_replace(
table: np.ndarray, text: bytes
) -> Tuple[np.ndarray, List[Tuple[str, str]]]:
result = np.frombuffer(text, dtype=np.uint16).copy()
replaced_words = []
for i in range(result.size):
ch = result[i]
p = _find_index(table[0], ch)
if p >= 0:
repl_char = table[1][p]
result[i] = repl_char
replaced_words.append((chr(ch), chr(repl_char)))
return result, replaced_words
class Normalizer:
def __init__(self, map_file_path: str, logger=logging.getLogger(__name__)):
self.logger = logger
self.normalizers: Dict[str, Callable[[str], str]] = {}
self.homophones_map = self._load_homophones_map(map_file_path)
"""
homophones_map
Replace the mispronounced characters with correctly pronounced ones.
Creation process of homophones_map.json:
1. Establish a word corpus using the [Tencent AI Lab Embedding Corpora v0.2.0 large] with 12 million entries. After cleaning, approximately 1.8 million entries remain. Use ChatTTS to infer the text.
2. Record discrepancies between the inferred and input text, identifying about 180,000 misread words.
3. Create a pinyin to common characters mapping using correctly read characters by ChatTTS.
4. For each discrepancy, extract the correct pinyin using [python-pinyin] and find homophones with the correct pronunciation from the mapping.
Thanks to:
[Tencent AI Lab Embedding Corpora for Chinese and English Words and Phrases](https://ai.tencent.com/ailab/nlp/en/embedding.html)
[python-pinyin](https://github.com/mozillazg/python-pinyin)
"""
self.coding = "utf-16-le" if sys.byteorder == "little" else "utf-16-be"
self.reject_pattern = re.compile(r"[^\u4e00-\u9fffA-Za-z，。、,\. ]")
self.sub_pattern = re.compile(r"\[uv_break\]|\[laugh\]|\[lbreak\]")
self.chinese_char_pattern = re.compile(r"[\u4e00-\u9fff]")
self.english_word_pattern = re.compile(r"\b[A-Za-z]+\b")
self.character_simplifier = str.maketrans(
{
"：": "，",
"；": "，",
"！": "。",
"（": "，",
"）": "，",
"【": "，",
"】": "，",
"『": "，",
"』": "，",
"「": "，",
"」": "，",
"《": "，",
"》": "，",
"－": "，",
":": ",",
";": ",",
"!": ".",
"(": ",",
")": ",",
#"[": ",",
#"]": ",",
">": ",",
"<": ",",
"-": ",",
}
)
self.halfwidth_2_fullwidth = str.maketrans(
{
"!": "！",
'"': "“",
"'": "‘",
"#": "＃",
"$": "＄",
"%": "％",
"&": "＆",
"(": "（",
")": "）",
",": "，",
"-": "－",
"*": "＊",
"+": "＋",
".": "。",
"/": "／",
":": "：",
";": "；",
"<": "＜",
"=": "＝",
">": "＞",
"?": "？",
"@": "＠",
# '[': '［',
"\\": "＼",
# ']': '］',
"^": "＾",
# '_': '＿',
"`": "｀",
"{": "｛",
"|": "｜",
"}": "｝",
"~": "～",
}
)
def __call__(
self,
text: str,
do_text_normalization=True,
do_homophone_replacement=True,
lang: Optional[Literal["zh", "en"]] = None,
) -> str:
if do_text_normalization:
_lang = self._detect_language(text) if lang is None else lang
if _lang in self.normalizers:
text = self.normalizers[_lang](text)
if _lang == "zh":
text = self._apply_half2full_map(text)
invalid_characters = self._count_invalid_characters(text)
if len(invalid_characters):
self.logger.warning(f"found invalid characters: {invalid_characters}")
text = self._apply_character_map(text)
if do_homophone_replacement:
arr, replaced_words = _fast_replace(
self.homophones_map,
text.encode(self.coding),
)
if replaced_words:
text = arr.tobytes().decode(self.coding)
repl_res = ", ".join([f"{_[0]}->{_[1]}" for _ in replaced_words])
self.logger.info(f"replace homophones: {repl_res}")
if len(invalid_characters):
text = self.reject_pattern.sub("", text)
return text
def register(self, name: str, normalizer: Callable[[str], str]) -> bool:
if name in self.normalizers:
self.logger.warning(f"name {name} has been registered")
return False
try:
val = normalizer("test string 测试字符串")
if not isinstance(val, str):
self.logger.warning("normalizer must have caller type (str) -> str")
return False
except Exception as e:
self.logger.warning(e)
return False
self.normalizers[name] = normalizer
return True
def unregister(self, name: str):
if name in self.normalizers:
del self.normalizers[name]
def destroy(self):
del_all(self.normalizers)
del self.homophones_map
def _load_homophones_map(self, map_file_path: str) -> np.ndarray:
with open(map_file_path, "r", encoding="utf-8") as f:
homophones_map: Dict[str, str] = json.load(f)
map = np.empty((2, len(homophones_map)), dtype=np.uint32)
for i, k in enumerate(homophones_map.keys()):
map[:, i] = (ord(k), ord(homophones_map[k]))
del homophones_map
return map
def _count_invalid_characters(self, s: str):
s = self.sub_pattern.sub("", s)
non_alphabetic_chinese_chars = self.reject_pattern.findall(s)
return set(non_alphabetic_chinese_chars)
def _apply_half2full_map(self, text: str) -> str:
return text.translate(self.halfwidth_2_fullwidth)
def _apply_character_map(self, text: str) -> str:
return text.translate(self.character_simplifier)
def _detect_language(self, sentence: str) -> Literal["zh", "en"]:
chinese_chars = self.chinese_char_pattern.findall(sentence)
english_words = self.english_word_pattern.findall(sentence)
if len(chinese_chars) > len(english_words):
return "zh"
else:
return "en"
================================================
FILE: ChatTTS/res/__init__.py
================================================
================================================
FILE: ChatTTS/res/homophones_map.json
================================================
{
"粡": "同",
"為": "位",
"瀹": "月",
"滆": "格",
"摲": "颤",
"渹": "轰",
"於": "鱼",
"満": "满",
"鍑": "父",
"與": "雨",
"阃": "捆",
"橹": "鲁",
"骞": "前",
"岀": "出",
"铓": "忙",
"杩": "骂",
"鍞": "坑",
"擼": "鲁",
"後": "后",
"來": "来",
"喔": "哦",
"會": "会",
"爰": "原",
"煡": "进",
"鐗": "减",
"個": "个",
"澶": "缠",
"時": "石",
"噢": "哦",
"铚": "至",
"栧": "意",
"浘": "伟",
"這": "这",
"穞": "旅",
"妳": "你",
"佷": "很",
"對": "对",
"並": "病",
"國": "国",
"戠": "知",
"笟": "姑",
"唔": "无",
"勫": "翻",
"徃": "网",
"還": "孩",
"將": "将",
"閮": "停",
"屽": "汉",
"過": "过",
"網": "网",
"紅": "红",
"說": "说",
"開": "开",
"區": "区",
"該": "该",
"從": "从",
"鑹": "窜",
"硗": "敲",
"內": "内",
"涘": "四",
"屄": "逼",
"種": "种",
"爾": "耳",
"讓": "让",
"搧": "山",
"甯": "凝",
"晢": "哲",
"愛": "爱",
"吖": "呀",
"沒": "梅",
"長": "长",
"線": "现",
"熱": "热",
"肏": "操",
"鎶": "歌",
"傚": "笑",
"無": "无",
"號": "号",
"兩": "两",
"榫": "损",
"強": "强",
"瓒": "赞",
"發": "发",
"機": "机",
"達": "达",
"圖": "图",
"稱": "称",
"則": "则",
"間": "间",
"馬": "马",
"點": "点",
"級": "极",
"輪": "伦",
"壹": "一",
"東": "东",
"鍚": "羊",
"給": "给",
"學": "学",
"數": "树",
"軍": "君",
"當": "当",
"嗎": "吗",
"爲": "位",
"鏂": "欧",
"場": "场",
"寮": "聊",
"鏈": "练",
"獎": "讲",
"約": "约",
"現": "现",
"裏": "李",
"縣": "现",
"阌": "文",
"婬": "银",
"們": "们",
"萬": "万",
"亞": "亚",
"經": "精",
"艹": "草",
"張": "张",
"隊": "对",
"進": "进",
"帶": "带",
"镩": "窜",
"曽": "层",
"麽": "魔",
"閲": "月",
"賽": "赛",
"鐮": "连",
"見": "见",
"書": "书",
"祂": "他",
"鐭": "玉",
"龍": "龙",
"犳": "着",
"墝": "敲",
"門": "门",
"連": "连",
"嘅": "凯",
"處": "处",
"設": "设",
"屬": "鼠",
"戹": "恶",
"員": "原",
"體": "体",
"車": "车",
"裡": "李",
"羅": "罗",
"憺": "蛋",
"頭": "头",
"類": "泪",
"戰": "战",
"話": "话",
"動": "动",
"麼": "么",
"組": "组",
"別": "别",
"嚕": "鲁",
"請": "请",
"許": "许",
"總": "总",
"島": "导",
"華": "华",
"卻": "确",
"編": "编",
"業": "夜",
"鐜": "堆",
"師": "诗",
"雙": "双",
"準": "准",
"黃": "黄",
"涁": "肾",
"報": "报",
"倫": "伦",
"視": "是",
"選": "选",
"揄": "鱼",
"鍙": "互",
"純": "纯",
"樻": "溃",
"幾": "几",
"濈": "极",
"辦": "办",
"應": "应",
"極": "极",
"柊": "中",
"納": "那",
"铰": "角",
"蹇": "减",
"係": "系",
"掑": "其",
"飾": "是",
"闱": "维",
"團": "团",
"歳": "岁",
"變": "变",
"陳": "陈",
"娍": "成",
"義": "意",
"兒": "而",
"碼": "马",
"條": "条",
"轉": "转",
"難": "南",
"曜": "要",
"邊": "编",
"項": "向",
"積": "机",
"滿": "满",
"幹": "干",
"奧": "奥",
"裝": "装",
"町": "听",
"哜": "记",
"笫": "子",
"絑": "朱",
"風": "风",
"黨": "挡",
"晟": "成",
"闃": "去",
"蘭": "蓝",
"樣": "样",
"魚": "鱼",
"較": "教",
"聲": "生",
"戝": "贼",
"單": "单",
"氣": "气",
"獲": "或",
"語": "雨",
"樂": "乐",
"實": "石",
"親": "亲",
"沖": "冲",
"鎮": "镇",
"阒": "去",
"褚": "楚",
"玖": "久",
"樓": "楼",
"楽": "乐",
"闾": "驴",
"夠": "够",
"嬪": "贫",
"宮": "工",
"殇": "伤",
"劉": "刘",
"舉": "举",
"尻": "烤",
"園": "原",
"傳": "传",
"蹙": "促",
"聯": "连",
"維": "维",
"鐵": "铁",
"宸": "陈",
"砲": "炮",
"試": "是",
"導": "导",
"製": "至",
"勝": "胜",
"萊": "来",
"絕": "觉",
"僅": "紧",
"聖": "胜",
"睇": "地",
"隨": "随",
"浜": "帮",
"慾": "玉",
"億": "意",
"屆": "借",
"硒": "西",
"電": "电",
"玥": "月",
"權": "全",
"殺": "沙",
"埚": "锅",
"買": "买",
"創": "创",
"雲": "云",
"記": "记",
"臺": "台",
"誰": "谁",
"夢": "梦",
"關": "关",
"荜": "必",
"叁": "三",
"層": "层",
"寶": "宝",
"寫": "写",
"問": "问",
"啲": "低",
"備": "被",
"靑": "青",
"務": "物",
"灏": "号",
"镑": "棒",
"佢": "取",
"諾": "诺",
"鍧": "轰",
"葉": "夜",
"節": "节",
"樹": "树",
"舊": "就",
"煜": "玉",
"飛": "飞",
"歲": "岁",
"擊": "机",
"灣": "弯",
"蘇": "苏",
"調": "掉",
"產": "铲",
"謝": "谢",
"髮": "发",
"冇": "帽",
"劇": "巨",
"優": "优",
"費": "费",
"铬": "个",
"姦": "间",
"廣": "广",
"論": "论",
"锰": "猛",
"眾": "重",
"遠": "远",
"絲": "思",
"灬": "标",
"麗": "利",
"覃": "谈",
"烬": "进",
"魯": "鲁",
"橋": "桥",
"钴": "古",
"館": "管",
"辊": "滚",
"讀": "毒",
"統": "统",
"筆": "比",
"蕩": "荡",
"橫": "横",
"盡": "紧",
"錢": "钱",
"柟": "南",
"賞": "赏",
"贰": "二",
"題": "提",
"戶": "互",
"奷": "前",
"泓": "红",
"嘭": "砰",
"楊": "羊",
"計": "记",
"薩": "萨",
"陣": "镇",
"茗": "明",
"專": "专",
"鬆": "松",
"庫": "裤",
"焱": "燕",
"銉": "玉",
"滅": "灭",
"闄": "咬",
"澤": "则",
"梓": "子",
"鄉": "相",
"側": "册",
"質": "至",
"佔": "战",
"復": "父",
"剛": "刚",
"吳": "无",
"洩": "谢",
"巳": "四",
"鍦": "诗",
"漢": "汉",
"異": "意",
"終": "中",
"聽": "听",
"職": "直",
"標": "标",
"賛": "赞",
"咁": "干",
"離": "离",
"歡": "欢",
"劍": "见",
"靈": "零",
"運": "运",
"榛": "真",
"叧": "寡",
"歐": "欧",
"領": "领",
"搽": "茶",
"換": "换",
"绫": "零",
"餘": "鱼",
"椿": "春",
"瀬": "赖",
"萫": "向",
"溆": "续",
"藥": "要",
"頂": "顶",
"徵": "睁",
"吋": "寸",
"環": "环",
"玮": "伟",
"結": "节",
"陽": "羊",
"據": "巨",
"興": "性",
"詞": "瓷",
"貝": "被",
"敗": "败",
"陸": "路",
"儘": "紧",
"亂": "乱",
"紀": "记",
"貴": "贵",
"議": "意",
"術": "树",
"詩": "诗",
"銀": "银",
"锏": "减",
"叻": "乐",
"捻": "年",
"嬴": "营",
"確": "确",
"砼": "同",
"載": "在",
"乜": "灭",
"盅": "中",
"頓": "顿",
"鲲": "昆",
"廠": "场",
"钑": "萨",
"姧": "间",
"盤": "盘",
"衛": "位",
"讬": "拖",
"獸": "瘦",
"駐": "助",
"発": "发",
"盃": "杯",
"喏": "诺",
"镢": "觉",
"黒": "黑",
"僕": "葡",
"偈": "记",
"週": "周",
"绾": "碗",
"蓋": "概",
"锺": "中",
"溫": "温",
"齊": "其",
"幫": "帮",
"斷": "断",
"姝": "书",
"飚": "标",
"堝": "锅",
"璟": "井",
"祢": "迷",
"乇": "拖",
"藍": "蓝",
"況": "矿",
"昱": "玉",
"綫": "现",
"傷": "伤",
"鐘": "中",
"臧": "脏",
"栾": "鸾",
"鏄": "团",
"囗": "维",
"涧": "见",
"護": "互",
"罡": "刚",
"浗": "求",
"輕": "青",
"馀": "鱼",
"額": "额",
"隻": "知",
"湪": "团",
"臨": "林",
"奚": "西",
"锛": "奔",
"婧": "静",
"錯": "错",
"順": "顺",
"浠": "西",
"芮": "瑞",
"続": "续",
"奪": "夺",
"預": "玉",
"須": "需",
"孫": "孙",
"淩": "零",
"賣": "卖",
"細": "系",
"顯": "显",
"頁": "夜",
"灞": "爸",
"邬": "乌",
"昇": "生",
"茲": "姿",
"彈": "蛋",
"実": "石",
"贏": "营",
"狀": "壮",
"營": "营",
"菁": "精",
"勢": "是",
"畫": "话",
"讚": "赞",
"價": "驾",
"闆": "板",
"壓": "呀",
"螭": "吃",
"獨": "毒",
"麥": "卖",
"資": "姿",
"牠": "他",
"針": "真",
"瑪": "马",
"遊": "由",
"講": "讲",
"決": "觉",
"説": "说",
"喺": "习",
"豔": "燕",
"繼": "记",
"姉": "子",
"傑": "节",
"斮": "错",
"歸": "归",
"歷": "利",
"譯": "意",
"鄭": "挣",
"沢": "则",
"錄": "路",
"槍": "枪",
"廳": "听",
"趙": "照",
"霏": "飞",
"咻": "修",
"鍏": "维",
"貓": "猫",
"殑": "情",
"觀": "关",
"慱": "团",
"盧": "芦",
"讜": "挡",
"祇": "其",
"扠": "插",
"欸": "哀",
"圍": "维",
"炜": "伟",
"缃": "相",
"絶": "觉",
"銈": "机",
"綱": "刚",
"態": "太",
"騎": "其",
"莊": "装",
"麵": "面",
"顔": "颜",
"櫠": "费",
"烏": "乌",
"腳": "角",
"談": "谈",
"钼": "木",
"寬": "宽",
"榮": "容",
"镉": "格",
"莪": "额",
"啐": "翠",
"濠": "豪",
"續": "续",
"聞": "文",
"钨": "乌",
"蕙": "会",
"課": "客",
"嚒": "么",
"毓": "玉",
"漸": "见",
"黶": "眼",
"寧": "凝",
"簡": "减",
"養": "养",
"湯": "汤",
"垣": "原",
"證": "挣",
"旡": "记",
"際": "记",
"鈥": "火",
"減": "减",
"莳": "石",
"韓": "含",
"锭": "定",
"凱": "凯",
"響": "想",
"珏": "觉",
"伱": "你",
"砷": "深",
"禮": "李",
"覺": "觉",
"劵": "倦",
"泠": "零",
"濮": "葡",
"諸": "朱",
"艦": "见",
"祗": "知",
"醫": "一",
"豐": "风",
"卐": "万",
"複": "父",
"慶": "庆",
"訂": "定",
"賴": "赖",
"谙": "安",
"旳": "地",
"織": "知",
"硼": "朋",
"鳥": "尿",
"晁": "朝",
"葭": "家",
"鄰": "林",
"涊": "年",
"誠": "成",
"爭": "睁",
"補": "捕",
"妺": "墨",
"冊": "册",
"笺": "间",
"樽": "尊",
"臉": "脸",
"圩": "维",
"塊": "快",
"瑛": "应",
"岱": "带",
"紝": "任",
"緒": "续",
"識": "石",
"円": "原",
"巻": "倦",
"負": "父",
"枰": "平",
"緊": "紧",
"歆": "心",
"敵": "敌",
"鐐": "聊",
"昃": "责",
"藝": "意",
"瀛": "营",
"叟": "搜",
"隼": "损",
"翎": "零",
"恁": "嫩",
"専": "专",
"願": "院",
"気": "气",
"埠": "不",
"蔺": "吝",
"參": "参",
"轧": "亚",
"睨": "逆",
"铀": "由",
"恵": "会",
"採": "采",
"仟": "前",
"謂": "位",
"韋": "维",
"佘": "蛇",
"鰭": "其",
"岡": "刚",
"込": "迂",
"戲": "系",
"捲": "卷",
"煨": "微",
"捌": "八",
"飯": "饭",
"黍": "鼠",
"鎴": "习",
"擡": "台",
"紙": "指",
"鎵": "家",
"閫": "捆",
"咲": "笑",
"銆": "墨",
"筱": "小",
"軟": "软",
"敤": "可",
"啜": "踹",
"顧": "固",
"儀": "宜",
"迩": "耳",
"髙": "高",
"賱": "允",
"庾": "雨",
"評": "平",
"昀": "云",
"責": "则",
"併": "病",
"喙": "会",
"踫": "碰",
"婕": "节",
"逹": "达",
"溴": "秀",
"煸": "编",
"铣": "洗",
"鐧": "间",
"倉": "仓",
"稥": "相",
"輝": "灰",
"驚": "精",
"翊": "意",
"坶": "母",
"様": "样",
"遷": "前",
"農": "农",
"綠": "绿",
"鸢": "冤",
"鑽": "钻",
"帛": "博",
"忓": "干",
"蔣": "讲",
"緣": "原",
"媓": "黄",
"炁": "气",
"镌": "捐",
"钖": "羊",
"輛": "亮",
"壊": "坏",
"钒": "烦",
"厝": "错",
"鋼": "刚",
"馗": "奎",
"釆": "变",
"聿": "玉",
"娆": "扰",
"褃": "肯",
"噴": "喷",
"匯": "会",
"嚴": "颜",
"雞": "机",
"莘": "深",
"蛹": "永",
"垸": "院",
"晔": "夜",
"谥": "是",
"舐": "是",
"孑": "节",
"峯": "风",
"镪": "枪",
"圓": "原",
"渇": "可",
"剌": "啦",
"涜": "毒",
"掛": "挂",
"測": "册",
"貼": "贴",
"睬": "采",
"適": "是",
"珈": "家",
"徳": "德",
"轄": "侠",
"兇": "胸",
"認": "任",
"嶅": "敖",
"惡": "恶",
"嬫": "容",
"鍛": "断",
"狃": "纽",
"協": "鞋",
"査": "扎",
"劃": "话",
"巽": "训",
"練": "练",
"貨": "或",
"嗳": "哀",
"範": "饭",
"寤": "物",
"簽": "前",
"祯": "真",
"卅": "萨",
"郜": "告",
"趕": "感",
"湫": "角",
"晉": "进",
"揚": "羊",
"廟": "庙",
"脫": "拖",
"濃": "农",
"竴": "村",
"啖": "蛋",
"醐": "胡",
"椁": "果",
"妤": "鱼",
"衆": "重",
"昶": "场",
"讷": "呢",
"鮑": "报",
"钜": "巨",
"鐢": "烦",
"祐": "右",
"勮": "巨",
"戀": "练",
"颦": "贫",
"嚯": "或",
"璁": "聪",
"壞": "坏",
"琰": "眼",
"勐": "猛",
"靜": "静",
"鐨": "费",
"诇": "胸",
"呎": "尺",
"顆": "科",
"戦": "战",
"闀": "红",
"瑄": "宣",
"賢": "闲",
"賀": "贺",
"訪": "访",
"氲": "晕",
"锉": "错",
"隅": "鱼",
"陰": "因",
"獕": "催",
"呂": "旅",
"厍": "设",
"嗗": "挖",
"監": "间",
"媽": "妈",
"曉": "小",
"嬢": "娘",
"涼": "良",
"牝": "聘",
"娑": "缩",
"瘠": "极",
"剐": "寡",
"懷": "怀",
"谛": "地",
"尋": "寻",
"閣": "格",
"俾": "比",
"镭": "雷",
"婦": "父",
"圃": "普",
"乛": "呀",
"勞": "劳",
"腚": "定",
"貫": "灌",
"錦": "紧",
"癣": "选",
"頒": "班",
"丅": "下",
"賷": "机",
"蓟": "记",
"嬩": "鱼",
"蓮": "连",
"遒": "求",
"忻": "心",
"鍒": "柔",
"堇": "紧",
"輸": "书",
"荿": "成",
"菈": "拉",
"豬": "朱",
"谌": "陈",
"珮": "配",
"贮": "助",
"閭": "驴",
"凊": "庆",
"贊": "赞",
"徹": "撤",
"札": "炸",
"産": "铲",
"焗": "局",
"俪": "利",
"呷": "嘎",
"喬": "桥",
"檔": "荡",
"雖": "虽",
"歎": "探",
"闇": "按",
"襲": "习",
"嶨": "学",
"凈": "静",
"敕": "赤",
"執": "直",
"噸": "蹲",
"枓": "抖",
"飲": "引",
"毗": "皮",
"猢": "胡",
"膘": "标",
"廢": "费",
"遺": "宜",
"筠": "云",
"壇": "谈",
"敝": "必",
"枧": "减",
"犟": "降",
"奮": "愤",
"钡": "被",
"財": "才",
"塬": "原",
"忚": "西",
"孬": "脑",
"氩": "亚",
"槿": "紧",
"钯": "靶",
"髒": "脏",
"夔": "奎",
"曆": "利",
"腦": "脑",
"泤": "四",
"浚": "俊",
"嶂": "帐",
"輻": "福",
"杷": "爬",
"轶": "意",
"嘬": "踹",
"燈": "灯",
"髻": "记",
"伧": "仓",
"揩": "开",
"娉": "平",
"險": "显",
"珞": "落",
"剜": "弯",
"構": "够",
"濟": "记",
"脈": "卖",
"紗": "沙",
"侑": "右",
"頻": "贫",
"誌": "至",
"齒": "尺",
"鍐": "宗",
"幔": "慢",
"姫": "机",
"擬": "你",
"伝": "云",
"糸": "密",
"抜": "拔",
"宓": "密",
"騷": "骚",
"衝": "冲",
"姣": "教",
"規": "归",
"蓓": "被",
"謀": "谋",
"毀": "毁",
"譜": "普",
"寵": "宠",
"遑": "黄",
"畀": "必",
"銮": "鸾",
"帋": "指",
"箐": "庆",
"搶": "抢",
"锑": "踢",
"鮮": "先",
"缁": "姿",
"阚": "罕",
"掸": "胆",
"桜": "应",
"誤": "物",
"瓤": "嚷",
"蕭": "消",
"噌": "层",
"槌": "垂",
"輔": "辅",
"鏡": "静",
"泷": "龙",
"鳃": "塞",
"椴": "断",
"尙": "上",
"雉": "至",
"褌": "昆",
"楔": "些",
"邨": "村",
"珩": "行",
"溟": "明",
"隱": "引",
"氐": "低",
"紋": "文",
"冼": "显",
"绥": "随",
"淬": "翠",
"抻": "陈",
"馮": "逢",
"贲": "奔",
"駛": "使",
"邝": "矿",
"祼": "灌",
"柘": "这",
"斛": "胡",
"掬": "居",
"蕪": "无",
"畢": "必",
"鬥": "豆",
"憑": "平",
"習": "习",
"檢": "减",
"輯": "极",
"坳": "奥",
"購": "够",
"啟": "起",
"築": "助",
"霁": "记",
"釋": "是",
"槼": "归",
"弼": "必",
"邰": "台",
"蹶": "觉",
"績": "机",
"煦": "续",
"嚟": "离",
"対": "对",
"緯": "伟",
"矾": "烦",
"賈": "假",
"棄": "气",
"瓯": "欧",
"樾": "月",
"徑": "静",
"煙": "烟",
"洟": "替",
"殘": "残",
"浔": "寻",
"磬": "庆",
"叴": "求",
"闈": "维",
"攝": "设",
"稞": "科",
"绉": "昼",
"岫": "秀",
"辭": "瓷",
"増": "增",
"塚": "种",
"吣": "亲",
"褋": "叠",
"鷹": "应",
"鳳": "奉",
"燒": "烧",
"瓴": "零",
"鐡": "铁",
"觸": "处",
"氫": "青",
"汛": "训",
"跡": "机",
"繞": "绕",
"镙": "罗",
"旻": "民",
"咂": "匝",
"玦": "觉",
"噫": "一",
"桿": "感",
"爺": "爷",
"卟": "捕",
"訓": "训",
"湴": "办",
"沅": "原",
"姹": "差",
"嵇": "机",
"滢": "营",
"蟥": "黄",
"缙": "进",
"浼": "美",
"顏": "颜",
"垚": "摇",
"獄": "玉",
"堅": "间",
"轟": "轰",
"櫈": "凳",
"戍": "树",
"斬": "展",
"瓚": "赞",
"揖": "一",
"帥": "帅",
"扈": "互",
"诪": "周",
"呤": "另",
"汆": "窜",
"疣": "由",
"亜": "亚",
"軸": "轴",
"昴": "帽",
"箸": "助",
"鑳": "见",
"濕": "诗",
"賓": "彬",
"膣": "至",
"瀨": "赖",
"偉": "伟",
"珺": "俊",
"亓": "其",
"啓": "起",
"沣": "风",
"澹": "蛋",
"曳": "夜",
"蒯": "快",
"痂": "家",
"爛": "烂",
"階": "接",
"彧": "玉",
"蜃": "肾",
"噙": "琴",
"褉": "谢",
"鄧": "凳",
"壽": "瘦",
"鷄": "机",
"郗": "西",
"偎": "微",
"鈴": "零",
"衿": "金",
"俟": "其",
"劑": "记",
"賲": "宝",
"蟲": "虫",
"広": "广",
"囍": "洗",
"洵": "寻",
"競": "静",
"槃": "盘",
"鶴": "贺",
"锗": "者",
"潤": "润",
"殒": "允",
"苓": "零",
"縮": "缩",
"厜": "嘴",
"禌": "姿",
"铳": "冲",
"嶺": "领",
"醚": "迷",
"菀": "碗",
"鹽": "颜",
"癡": "吃",
"宥": "右",
"註": "助",
"濂": "连",
"薨": "轰",
"鲛": "教",
"舂": "冲",
"棟": "动",
"颉": "节",
"閑": "闲",
"淺": "浅",
"彜": "宜",
"捱": "埃",
"齡": "零",
"銷": "消",
"慘": "惨",
"滛": "银",
"荃": "全",
"辇": "年",
"錶": "表",
"審": "审",
"訊": "训",
"繪": "会",
"軌": "鬼",
"吶": "那",
"勁": "进",
"貞": "真",
"讘": "聂",
"雒": "落",
"锆": "告",
"妣": "比",
"潞": "路",
"吠": "费",
"魈": "消",
"鄢": "烟",
"栫": "见",
"倆": "俩",
"嚐": "长",
"佈": "不",
"陂": "杯",
"虛": "需",
"诲": "会",
"銅": "同",
"谒": "夜",
"埴": "直",
"瘀": "迂",
"噘": "绝",
"違": "维",
"鄌": "唐",
"膷": "相",
"骊": "离",
"囯": "国",
"暫": "赞",
"鉄": "直",
"処": "楚",
"拚": "判",
"錫": "西",
"郦": "利",
"嘢": "也",
"閃": "闪",
"仝": "同",
"讛": "意",
"潔": "节",
"曞": "利",
"濱": "彬",
"耢": "烙",
"邁": "卖",
"鍾": "中",
"讫": "气",
"紹": "绍",
"趺": "夫",
"祎": "一",
"緻": "至",
"唿": "呼",
"犲": "柴",
"煳": "胡",
"賵": "奉",
"膠": "教",
"噉": "蛋",
"愬": "速",
"恆": "横",
"彥": "燕",
"団": "团",
"夥": "火",
"锟": "昆",
"琏": "脸",
"綋": "红",
"獻": "现",
"戸": "互",
"雜": "杂",
"獅": "诗",
"霧": "物",
"憲": "现",
"撃": "机",
"贈": "赠",
"飨": "想",
"櫻": "应",
"岬": "假",
"卍": "万",
"逄": "旁",
"氳": "晕",
"蒽": "恩",
"祿": "路",
"鐏": "尊",
"遜": "训",
"変": "变",
"濯": "着",
"擺": "摆",
"垠": "银",
"淨": "静",
"煊": "宣",
"軳": "袍",
"旌": "精",
"殁": "墨",
"嶋": "导",
"鍗": "提",
"皋": "高",
"骋": "成",
"谞": "需",
"譽": "玉",
"蟻": "以",
"搴": "前",
"訴": "速",
"鯉": "李",
"蟿": "气",
"獾": "欢",
"菡": "汉",
"丟": "丢",
"偌": "弱",
"嗄": "啊",
"钺": "月",
"崏": "民",
"濉": "虽",
"忿": "愤",
"硌": "个",
"璎": "应",
"铄": "硕",
"獒": "敖",
"鋒": "风",
"踞": "巨",
"炀": "羊",
"壯": "壮",
"汙": "乌",
"関": "关",
"捨": "舍",
"粵": "月",
"琨": "昆",
"颍": "影",
"賜": "次",
"夲": "掏",
"郢": "影",
"淚": "泪",
"赊": "舍",
"礎": "楚",
"豊": "李",
"夾": "家",
"芈": "米",
"穩": "稳",
"诰": "告",
"翌": "意",
"閉": "必",
"鳴": "明",
"鍋": "锅",
"垅": "垄",
"鎖": "锁",
"潃": "修",
"缦": "慢",
"爐": "芦",
"嗟": "接",
"縱": "宗",
"摺": "哲",
"鋪": "瀑",
"昰": "是",
"箓": "路",
"澧": "李",
"馥": "父",
"侗": "动",
"歩": "不",
"毎": "美",
"瑨": "进",
"秆": "感",
"姒": "四",
"椽": "传",
"蹤": "宗",
"鹹": "闲",
"畦": "其",
"挿": "插",
"掣": "撤",
"綾": "零",
"鏉": "瘦",
"軒": "宣",
"芠": "文",
"齋": "摘",
"岄": "月",
"昝": "赞",
"潛": "钱",
"伢": "牙",
"鐪": "鲁",
"蕃": "翻",
"恥": "尺",
"討": "讨",
"厠": "册",
"箩": "罗",
"彡": "山",
"弁": "变",
"貢": "共",
"鴻": "红",
"氬": "亚",
"墻": "强",
"芾": "费",
"亳": "博",
"鸩": "镇",
"牆": "强",
"譚": "谈",
"鲧": "滚",
"铖": "成",
"氡": "东",
"蕞": "最",
"汚": "乌",
"缨": "应",
"埙": "熏",
"饷": "想",
"闊": "扩",
"铱": "一",
"钤": "钱",
"漲": "长",
"擢": "着",
"殼": "咳",
"饧": "唐",
"枳": "指",
"埂": "梗",
"賊": "贼",
"働": "动",
"哂": "审",
"鬲": "格",
"弋": "意",
"斫": "着",
"瞇": "眯",
"槊": "硕",
"託": "拖",
"嗬": "喝",
"龜": "归",
"锶": "思",
"潵": "洒",
"唸": "念",
"杈": "插",
"箕": "机",
"崥": "皮",
"濆": "坟",
"繫": "系",
"騰": "腾",
"銘": "明",
"蚩": "吃",
"椤": "罗",
"隗": "奎",
"笅": "角",
"祕": "密",
"滾": "滚",
"怛": "达",
"檫": "茶",
"療": "聊",
"稅": "睡",
"韻": "运",
"皎": "角",
"鍊": "练",
"総": "总",
"渑": "免",
"铵": "俺",
"椹": "肾",
"舫": "访",
"盜": "到",
"遲": "持",
"龐": "旁",
"騙": "片",
"煩": "烦",
"溝": "勾",
"俅": "求",
"缐": "现",
"飄": "飘",
"颚": "恶",
"雎": "居",
"泗": "四",
"賳": "灾",
"褰": "前",
"閒": "闲",
"驗": "燕",
"酆": "风",
"炝": "呛",
"犇": "奔",
"猷": "由",
"籌": "愁",
"胫": "静",
"塵": "陈",
"荻": "敌",
"暝": "明",
"訾": "姿",
"牒": "叠",
"蟽": "达",
"屍": "诗",
"餌": "耳",
"舖": "瀑",
"铌": "尼",
"劭": "绍",
"熘": "溜",
"盂": "鱼",
"燮": "谢",
"呔": "呆",
"悅": "月",
"尕": "尬",
"彌": "迷",
"獵": "裂",
"恙": "样",
"烃": "听",
"涎": "闲",
"岙": "奥",
"貉": "豪",
"铉": "炫",
"崗": "岗",
"鋁": "旅",
"豕": "使",
"蠻": "瞒",
"俠": "侠",
"桢": "真",
"讗": "鞋",
"镗": "汤",
"埸": "意",
"萼": "恶",
"酔": "最",
"餵": "位",
"嬌": "教",
"擋": "挡",
"損": "损",
"钽": "坦",
"髯": "然",
"幣": "必",
"紒": "记",
"囡": "喃",
"淖": "闹",
"覽": "懒",
"氖": "奶",
"轲": "科",
"虬": "求",
"鍥": "妾",
"衾": "亲",
"璜": "黄",
"嵘": "容",
"隣": "林",
"揿": "亲",
"拋": "抛",
"峁": "帽",
"莅": "利",
"勬": "捐",
"沱": "驮",
"嗮": "赛",
"绺": "柳",
"甑": "赠",
"鍵": "见",
"篑": "溃",
"迴": "回",
"憩": "气",
"図": "图",
"証": "挣",
"铟": "因",
"愮": "摇",
"粿": "果",
"衹": "指",
"牽": "前",
"巿": "福",
"棲": "七",
"橾": "书",
"晩": "碗",
"録": "路",
"豺": "柴",
"璨": "灿",
"诐": "必",
"洺": "明",
"颢": "号",
"鬧": "闹",
"艖": "插",
"賺": "赚",
"婀": "阿",
"淦": "干",
"绡": "消",
"迳": "静",
"悶": "闷",
"艷": "燕",
"勳": "熏",
"蜇": "遮",
"蒼": "仓",
"笣": "包",
"欤": "鱼",
"嬲": "尿",
"旸": "羊",
"売": "卖",
"蓦": "墨",
"喪": "丧",
"褔": "父",
"颔": "汉",
"苒": "染",
"隠": "引",
"觞": "伤",
"兗": "眼",
"弾": "蛋",
"嬬": "如",
"泑": "优",
"姘": "拼",
"琮": "从",
"廋": "搜",
"阍": "昏",
"椋": "良",
"嗕": "入",
"囩": "云",
"纾": "书",
"絵": "会",
"鐝": "觉",
"祙": "妹",
"堀": "哭",
"铋": "必",
"桉": "安",
"礦": "矿",
"鐫": "捐",
"祚": "做",
"幇": "帮",
"滦": "鸾",
"仞": "任",
"鎻": "锁",
"阕": "确",
"彲": "吃",
"傾": "青",
"箬": "弱",
"熶": "窜",
"皴": "村",
"馊": "搜",
"湄": "梅",
"骐": "其",
"镓": "家",
"靛": "电",
"悪": "恶",
"徕": "来",
"鯰": "年",
"駅": "意",
"龋": "曲",
"筵": "颜",
"洙": "朱",
"犼": "吼",
"廿": "念",
"霭": "矮",
"鲎": "后",
"芶": "狗",
"呯": "平",
"塗": "图",
"妝": "装",
"鹄": "古",
"佚": "意",
"嘁": "七",
"樑": "良",
"薦": "见",
"嗚": "乌",
"勸": "劝",
"楮": "楚",
"砣": "驮",
"葳": "微",
"棰": "垂",
"舷": "闲",
"菅": "间",
"誘": "右",
"夊": "虽",
"頗": "坡",
"潼": "同",
"畈": "饭",
"琬": "碗",
"佸": "活",
"邺": "夜",
"姵": "配",
"郵": "由",
"儲": "楚",
"鑑": "见",
"旃": "占",
"躍": "月",
"珉": "民",
"皬": "和",
"苡": "以",
"贻": "宜",
"鹜": "物",
"駕": "驾",
"馔": "赚",
"濛": "盟",
"仺": "仓",
"鍔": "恶",
"遞": "地",
"鈺": "玉",
"災": "灾",
"偸": "偷",
"邕": "庸",
"诤": "挣",
"蜱": "皮",
"砾": "利",
"禛": "真",
"翳": "意",
"潋": "练",
"钚": "不",
"醴": "李",
"紐": "纽",
"殳": "书",
"偃": "眼",
"碴": "茶",
"猶": "由",
"偽": "伟",
"嚌": "记",
"谂": "审",
"蜞": "其",
"刪": "山",
"婳": "话",
"镒": "意",
"慮": "绿",
"菏": "和",
"癥": "睁",
"褍": "端",
"樺": "话",
"唵": "俺",
"沤": "欧",
"恣": "字",
"欽": "亲",
"栎": "利",
"堜": "练",
"潆": "营",
"掃": "扫",
"鎏": "刘",
"汨": "密",
"傝": "探",
"繚": "聊",
"唎": "利",
"瀵": "愤",
"賮": "进",
"墜": "缀",
"峒": "动",
"曌": "照",
"萘": "耐",
"剋": "客",
"鼐": "耐",
"睑": "减",
"楹": "营",
"乗": "成",
"讞": "燕",
"謎": "迷",
"鏃": "族",
"魑": "吃",
"卮": "知",
"輩": "被",
"賭": "堵",
"菸": "烟",
"醬": "降",
"淵": "冤",
"铯": "色",
"煉": "练",
"蔵": "脏",
"杓": "标",
"燊": "深",
"渌": "路",
"哋": "叠",
"琚": "居",
"榀": "品",
"襹": "诗",
"虢": "国",
"瑗": "院",
"睢": "虽",
"繳": "角",
"诘": "极",
"罵": "骂",
"铍": "批",
"埄": "崩",
"膑": "宾",
"挶": "居",
"鱸": "芦",
"遙": "摇",
"粈": "柔",
"擾": "扰",
"擔": "单",
"罷": "爸",
"潰": "溃",
"炅": "窘",
"诓": "框",
"戕": "枪",
"恔": "角",
"壘": "垒",
"遽": "巨",
"鴨": "呀",
"邴": "饼",
"硪": "卧",
"纭": "云",
"虱": "诗",
"揮": "灰",
"狍": "袍",
"堑": "欠",
"廈": "煞",
"囬": "回",
"澍": "树",
"诳": "狂",
"飏": "羊",
"磚": "专",
"脳": "脑",
"枋": "方",
"浄": "静",
"囿": "右",
"讙": "欢",
"眞": "真",
"搾": "咋",
"钭": "偷",
"慳": "前",
"谯": "桥",
"倏": "书",
"凪": "指",
"唛": "骂",
"缶": "否",
"痈": "庸",
"脣": "纯",
"縛": "父",
"憂": "优",
"糧": "良",
"螯": "敖",
"畼": "唱",
"翦": "减",
"溼": "诗",
"鐣": "称",
"娌": "李",
"釐": "离",
"妫": "归",
"蟺": "善",
"墦": "烦",
"钕": "女",
"玑": "机",
"钏": "串",
"卩": "节",
"堥": "毛",
"氰": "情",
"谗": "缠",
"銳": "瑞",
"璩": "取",
"尐": "节",
"樞": "书",
"寳": "宝",
"巖": "颜",
"貸": "带",
"绦": "掏",
"銇": "泪",
"疝": "善",
"铑": "老",
"膽": "胆",
"詠": "永",
"曬": "筛",
"粲": "灿",
"栀": "知",
"钎": "前",
"疃": "团",
"愽": "博",
"窮": "穷",
"窩": "窝",
"铡": "炸",
"暢": "唱",
"剎": "沙",
"鵬": "朋",
"搵": "问",
"湧": "永",
"笆": "八",
"緩": "缓",
"偻": "楼",
"邈": "秒",
"衞": "位",
"郃": "和",
"钷": "坡",
"胄": "昼",
"晞": "西",
"泮": "判",
"滁": "除",
"霰": "现",
"桁": "横",
"掼": "灌",
"闖": "闯",
"撥": "波",
"呖": "利",
"嚇": "下",
"棹": "照",
"怏": "样",
"埭": "带",
"絡": "落",
"镞": "族",
"癒": "玉",
"洌": "裂",
"蹚": "汤",
"収": "收",
"涞": "来",
"亻": "人",
"綜": "宗",
"懸": "旋",
"燚": "意",
"蓼": "了",
"洇": "因",
"痢": "利",
"庢": "至",
"濋": "楚",
"帯": "带",
"咝": "思",
"罰": "罚",
"彎": "弯",
"讟": "毒",
"阡": "前",
"鍜": "侠",
"膻": "山",
"颡": "桑",
"赓": "耕",
"詳": "翔",
"槎": "茶",
"桷": "觉",
"懋": "帽",
"冫": "冰",
"秸": "接",
"醮": "教",
"氽": "吞",
"讴": "欧",
"兂": "赞",
"嵐": "蓝",
"鸷": "至",
"郞": "狼",
"囉": "罗",
"魃": "拔",
"鼋": "原",
"籠": "龙",
"铧": "华",
"撲": "铺",
"擁": "庸",
"莤": "速",
"畲": "舍",
"晌": "赏",
"姮": "横",
"儇": "宣",
"澪": "零",
"壅": "庸",
"驅": "区",
"禪": "缠",
"靥": "夜",
"詔": "照",
"嗰": "葛",
"鬃": "宗",
"尓": "耳",
"亟": "极",
"糁": "三",
"擤": "醒",
"竜": "龙",
"羸": "雷",
"錾": "赞",
"瑠": "刘",
"湊": "凑",
"楣": "梅",
"巜": "快",
"苫": "山",
"芃": "朋",
"罒": "网",
"僮": "同",
"哞": "某",
"宀": "眠",
"単": "单",
"鎯": "狼",
"媞": "是",
"謙": "前",
"愍": "敏",
"虺": "灰",
"鑰": "要",
"樘": "唐",
"沵": "米",
"骅": "华",
"菓": "果",
"锝": "德",
"醯": "西",
"凍": "动",
"钹": "博",
"遼": "聊",
"悌": "替",
"餅": "饼",
"瞋": "陈",
"矽": "系",
"蹟": "机",
"奂": "换",
"楓": "风",
"撿": "减",
"峤": "教",
"佃": "电",
"墒": "伤",
"倖": "性",
"蠍": "些",
"眀": "明",
"漿": "将",
"檯": "台",
"羣": "群",
"疊": "叠",
"佺": "全",
"扦": "前",
"蕈": "训",
"吽": "轰",
"嘆": "探",
"涪": "福",
"賤": "见",
"珥": "耳",
"孛": "被",
"簋": "鬼",
"苕": "勺",
"鎰": "意",
"藐": "秒",
"氱": "养",
"涸": "和",
"撫": "辅",
"閽": "昏",
"畝": "母",
"芩": "琴",
"嘗": "长",
"猹": "茶",
"彘": "至",
"聰": "聪",
"淸": "青",
"泫": "炫",
"観": "关",
"醜": "丑",
"桅": "维",
"瑷": "爱",
"莜": "由",
"庣": "挑",
"癿": "茄",
"氚": "穿",
"眦": "字",
"堃": "昆",
"篙": "高",
"瘋": "风",
"淙": "从",
"耒": "垒",
"煅": "断",
"穂": "岁",
"鉆": "搀",
"凜": "吝",
"鐸": "夺",
"獩": "会",
"乄": "五",
"阗": "田",
"罂": "应",
"蘅": "横",
"啱": "颜",
"瑭": "唐",
"芪": "其",
"屼": "物",
"鬚": "需",
"洧": "伟",
"傢": "家",
"阇": "督",
"閘": "炸",
"搖": "摇",
"氘": "刀",
"逑": "求",
"镬": "或",
"娛": "鱼",
"嫒": "爱",
"縫": "奉",
"傘": "三",
"嵋": "梅",
"焓": "含",
"蠀": "刺",
"蠡": "离",
"湟": "黄",
"逯": "路",
"袂": "妹",
"耆": "其",
"鉅": "巨",
"褟": "他",
"妗": "进",
"綿": "眠",
"賦": "父",
"穔": "黄",
"谝": "偏",
"邙": "忙",
"炔": "贵",
"琇": "秀",
"钅": "金",
"篤": "堵",
"嵴": "几",
"穀": "古",
"両": "两",
"彙": "会",
"铨": "全",
"畑": "田",
"祜": "互",
"涙": "泪",
"撷": "鞋",
"牍": "毒",
"刂": "刀",
"夐": "胸",
"吔": "也",
"貘": "墨",
"啻": "赤",
"鎷": "马",
"締": "地",
"鏁": "锁",
"舄": "系",
"稔": "忍",
"児": "而",
"懶": "懒",
"忤": "五",
"貪": "贪",
"艙": "仓",
"铊": "他",
"鱗": "林",
"隷": "利",
"蠹": "度",
"骜": "奥",
"砦": "寨",
"垌": "动",
"涐": "额",
"湍": "团",
"埕": "成",
"镧": "蓝",
"獐": "张",
"綁": "绑",
"铼": "来",
"脩": "修",
"岷": "民",
"効": "笑",
"駿": "俊",
"廚": "除",
"褘": "灰",
"嫱": "强",
"刈": "意",
"孺": "如",
"恚": "会",
"灘": "贪",
"貧": "贫",
"綦": "其",
"爨": "窜",
"闂": "红",
"顼": "需",
"摀": "五",
"滃": "瓮",
"閿": "文",
"溧": "利",
"獣": "瘦",
"紛": "分",
"竦": "耸",
"菽": "书",
"莒": "举",
"婐": "我",
"畿": "机",
"蚬": "显",
"峋": "寻",
"栢": "摆",
"隸": "利",
"缗": "民",
"孓": "觉",
"阆": "狼",
"泺": "落",
"霈": "配",
"忝": "舔",
"兖": "眼",
"饯": "见",
"戯": "呼",
"呰": "子",
"甙": "带",
"嫚": "慢",
"綴": "缀",
"镄": "费",
"癞": "赖",
"迨": "带",
"绔": "裤",
"腆": "舔",
"肅": "速",
"臥": "卧",
"圻": "其",
"瘘": "漏",
"屢": "旅",
"酢": "促",
"辻": "石",
"擴": "扩",
"撳": "亲",
"従": "从",
"憶": "意",
"鯨": "精",
"貿": "帽",
"珣": "寻",
"嵬": "维",
"碩": "硕",
"艶": "燕",
"壩": "爸",
"穎": "影",
"曷": "和",
"銜": "闲",
"硐": "动",
"韫": "运",
"寛": "宽",
"颀": "其",
"谟": "魔",
"滟": "燕",
"笄": "机",
"碁": "其",
"閥": "罚",
"缑": "勾",
"鍝": "鱼",
"钌": "了",
"苌": "长",
"豢": "换",
"閩": "敏",
"骶": "底",
"棂": "零",
"鹞": "要",
"鑒": "见",
"瓊": "穷",
"儍": "傻",
"愠": "运",
"屙": "阿",
"孖": "妈",
"钿": "电",
"兲": "天",
"锷": "恶",
"轭": "恶",
"珪": "归",
"礡": "博",
"叕": "着",
"丌": "机",
"壺": "胡",
"蛭": "至",
"墎": "锅",
"帏": "维",
"徇": "训",
"詢": "寻",
"笪": "达",
"吥": "不",
"殛": "极",
"杲": "搞",
"滬": "互",
"診": "枕",
"隹": "追",
"磙": "滚",
"堣": "鱼",
"乺": "锁",
"苋": "现",
"雹": "薄",
"啶": "定",
"繇": "摇",
"凫": "福",
"抟": "团",
"沄": "云",
"翕": "西",
"玎": "丁",
"鏍": "罗",
"僑": "桥",
"虧": "亏",
"篁": "黄",
"瑀": "雨",
"嵊": "胜",
"柰": "耐",
"婺": "物",
"洹": "环",
"喰": "参",
"钇": "以",
"镊": "聂",
"褲": "裤",
"腓": "肥",
"蕲": "其",
"檄": "习",
"笉": "寝",
"陟": "至",
"珲": "灰",
"矇": "盟",
"讻": "胸",
"佗": "驮",
"轸": "枕",
"垴": "脑",
"崧": "松",
"揾": "问",
"铈": "是",
"渾": "魂",
"丼": "井",
"尛": "魔",
"頌": "宋",
"凼": "荡",
"挛": "鸾",
"鍖": "尘",
"吡": "比",
"挈": "妾",
"佾": "意",
"黱": "带",
"俎": "组",
"赭": "者",
"趨": "区",
"嬭": "奶",
"撐": "称",
"磯": "机",
"臟": "藏",
"滄": "仓",
"薜": "必",
"觚": "姑",
"旖": "以",
"艏": "手",
"苻": "福",
"経": "精",
"獭": "塔",
"纏": "缠",
"纔": "才",
"鑾": "鸾",
"赟": "晕",
"亍": "处",
"芫": "颜",
"呓": "意",
"蓁": "真",
"馳": "持",
"禍": "或",
"扞": "感",
"帳": "帐",
"氙": "先",
"缈": "秒",
"擘": "掰",
"庖": "袍",
"骧": "相",
"訣": "觉",
"墊": "电",
"瀧": "龙",
"嫰": "嫩",
"刖": "月",
"禦": "玉",
"姩": "念",
"尅": "客",
"剣": "见",
"醅": "培",
"锕": "啊",
"圪": "歌",
"雛": "除",
"鑲": "相",
"繩": "生",
"玠": "借",
"掾": "院",
"倌": "关",
"笏": "互",
"螫": "是",
"茆": "毛",
"瑁": "帽",
"疽": "居",
"県": "现",
"擇": "则",
"頃": "请",
"绶": "瘦",
"舛": "喘",
"唌": "闲",
"偵": "真",
"欄": "蓝",
"谪": "哲",
"転": "转",
"恽": "运",
"谶": "衬",
"褜": "袍",
"恸": "痛",
"萁": "其",
"娈": "鸾",
"飽": "宝",
"饴": "宜",
"丷": "八",
"孃": "娘",
"紮": "匝",
"綉": "透",
"羟": "抢",
"鎬": "号",
"鍟": "生",
"囘": "回",
"賬": "帐",
"鄞": "银",
"钍": "土",
"闢": "屁",
"錘": "垂",
"郏": "夹",
"脘": "碗",
"鳅": "秋",
"靚": "静",
"楦": "炫",
"膩": "逆",
"辯": "变",
"岢": "可",
"鈈": "批",
"燧": "岁",
"債": "寨",
"楸": "秋",
"曠": "矿",
"娚": "南",
"龇": "姿",
"绀": "干",
"剡": "善",
"慣": "灌",
"腸": "长",
"傩": "挪",
"曈": "同",
"蝾": "容",
"歴": "利",
"帰": "归",
"磔": "哲",
"郧": "云",
"侶": "旅",
"漁": "鱼",
"佶": "极",
"冨": "父",
"臌": "古",
"醪": "劳",
"樯": "强",
"魍": "网",
"槸": "意",
"佹": "鬼",
"蝦": "虾",
"鯛": "雕",
"逅": "后",
"鸫": "东",
"鹳": "灌",
"硷": "减",
"嚩": "魔",
"篠": "小",
"锲": "妾",
"沭": "树",
"嚥": "燕",
"乂": "意",
"矬": "搓",
"锘": "诺",
"诮": "巧",
"绠": "梗",
"庠": "翔",
"餓": "恶",
"稜": "棱",
"祉": "指",
"掴": "乖",
"噁": "饿",
"薬": "要",
"厩": "就",
"籤": "前",
"囱": "聪",
"萸": "鱼",
"読": "毒",
"囹": "零",
"擠": "几",
"颏": "科",
"繆": "谋",
"栄": "容",
"綺": "起",
"穰": "嚷",
"疔": "丁",
"莼": "纯",
"凃": "图",
"叢": "从",
"镝": "低",
"鞑": "达",
"蹼": "普",
"槬": "话",
"償": "长",
"簟": "电",
"腈": "精",
"庹": "妥",
"嗵": "通",
"鎺": "组",
"粍": "哲",
"蘋": "平",
"窈": "咬",
"郄": "妾",
"钲": "睁",
"屾": "深",
"旎": "你",
"桡": "扰",
"鹬": "玉",
"暈": "晕",
"蘿": "罗",
"艂": "逢",
"赉": "赖",
"聶": "聂",
"嶈": "枪",
"瞑": "明",
"焐": "物",
"鏅": "修",
"踵": "种",
"滓": "子",
"楗": "见",
"巔": "颠",
"碓": "对",
"琊": "牙",
"碛": "气",
"嫵": "五",
"庡": "以",
"釣": "掉",
"钬": "火",
"厳": "颜",
"冦": "扣",
"襦": "如",
"卝": "矿",
"雫": "哪",
"諡": "是",
"苆": "切",
"訷": "深",
"咭": "机",
"璘": "林",
"喚": "换",
"锨": "先",
"惇": "蹲",
"緑": "绿",
"氭": "东",
"玚": "唱",
"柞": "咋",
"锴": "凯",
"毖": "必",
"馐": "修",
"湁": "赤",
"鄣": "张",
"儆": "井",
"芘": "皮",
"俚": "李",
"埝": "念",
"喑": "因",
"觥": "工",
"囟": "信",
"肓": "荒",
"蠛": "灭",
"黜": "处",
"歙": "设",
"狹": "侠",
"鬻": "玉",
"亀": "归",
"柢": "底",
"誕": "蛋",
"啮": "聂",
"谰": "蓝",
"亊": "是",
"佽": "次",
"亅": "觉",
"峇": "八",
"闩": "拴",
"棢": "网",
"圧": "呀",
"樁": "装",
"觪": "星",
"夋": "群",
"鋆": "云",
"瀰": "迷",
"呶": "脑",
"氺": "水",
"葯": "要",
"圏": "圈",
"螟": "明",
"乀": "福",
"攜": "鞋",
"仵": "五",
"粳": "精",
"郅": "至",
"爿": "盘",
"醣": "唐",
"濤": "掏",
"荑": "提",
"沨": "风",
"臬": "聂",
"垱": "荡",
"榷": "确",
"啭": "赚",
"鐩": "岁",
"钃": "竹",
"膚": "夫",
"潺": "缠",
"跖": "直",
"薙": "替",
"闳": "红",
"玳": "带",
"铷": "如",
"腴": "鱼",
"幵": "间",
"呒": "五",
"鹗": "恶",
"蟬": "缠",
"戢": "极",
"荇": "性",
"欑": "攒",
"誅": "朱",
"鍘": "炸",
"雠": "愁",
"趐": "血",
"陞": "生",
"滘": "教",
"攤": "贪",
"値": "直",
"槑": "梅",
"牸": "字",
"塩": "颜",
"绗": "行",
"賯": "胸",
"笕": "减",
"籃": "蓝",
"寢": "寝",
"垟": "羊",
"鱷": "恶",
"篦": "必",
"鑻": "判",
"俦": "愁",
"眚": "省",
"呋": "夫",
"駒": "居",
"胔": "字",
"鑄": "助",
"驷": "四",
"楫": "极",
"绌": "处",
"漉": "路",
"崝": "睁",
"撚": "年",
"唳": "利",
"瑩": "营",
"滝": "龙",
"猊": "尼",
"彀": "够",
"焼": "烧",
"笂": "完",
"闘": "豆",
"猗": "一",
"嗐": "害",
"叒": "弱",
"凇": "松",
"碲": "地",
"菰": "姑",
"堺": "借",
"虻": "盟",
"誼": "意",
"珯": "老",
"裾": "居",
"憐": "连",
"袢": "判",
"姀": "和",
"滙": "会",
"検": "减",
"溏": "唐",
"髪": "发",
"焘": "到",
"槔": "高",
"龅": "包",
"魉": "两",
"櫃": "贵",
"拏": "拿",
"脲": "尿",
"缟": "搞",
"媪": "袄",
"厲": "利",
"堯": "摇",
"臘": "蜡",
"兕": "四",
"踅": "学",
"箅": "必",
"圉": "雨",
"婠": "弯",
"悭": "前",
"敘": "续",
"夂": "指",
"褨": "锁",
"笈": "极",
"亾": "王",
"鲢": "连",
"賰": "春",
"騒": "骚",
"怿": "意",
"稲": "到",
"昐": "分",
"樸": "普",
"笳": "家",
"疥": "借",
"験": "燕",
"箇": "个",
"逋": "不",
"欹": "一",
"痾": "阿",
"埵": "朵",
"鵝": "额",
"嗥": "豪",
"砟": "眨",
"誊": "腾",
"茔": "营",
"贇": "晕",
"屮": "撤",
"笞": "吃",
"剝": "波",
"闼": "踏",
"鉛": "前",
"钣": "板",
"綝": "陈",
"杪": "秒",
"翀": "冲",
"腭": "恶",
"郤": "系",
"僦": "就",
"閱": "月",
"钪": "抗",
"鑿": "凿",
"齣": "出",
"舸": "葛",
"汜": "四",
"熷": "增",
"崑": "昆",
"僖": "西",
"丄": "上",
"厭": "燕",
"諭": "玉",
"枞": "聪",
"烝": "睁",
"嬰": "应",
"咥": "系",
"蚓": "引",
"诜": "深",
"溱": "琴",
"犻": "博",
"缄": "间",
"鸮": "消",
"篾": "灭",
"菘": "松",
"饒": "扰",
"兘": "使",
"唻": "赖",
"鰻": "瞒",
"璺": "问",
"叡": "瑞",
"劢": "卖",
"湜": "石",
"辶": "绰",
"罅": "下",
"窨": "熏",
"檩": "吝",
"罴": "皮",
"邾": "朱",
"黙": "墨",
"鄒": "邹",
"桖": "血",
"婓": "飞",
"缱": "浅",
"荏": "忍",
"洄": "回",
"霂": "木",
"睺": "喉",
"頸": "井",
"芰": "记",
"掽": "碰",
"蛏": "称",
"琯": "管",
"蔸": "兜",
"倬": "捉",
"覚": "觉",
"烜": "选",
"薮": "搜",
"捰": "我",
"眇": "秒",
"阝": "父",
"嶼": "雨",
"峽": "侠",
"纛": "到",
"郷": "相",
"绱": "上",
"稟": "饼",
"飼": "四",
"嶄": "展",
"彵": "妥",
"勵": "利",
"镲": "差",
"豎": "树",
"鄯": "善",
"脅": "鞋",
"崮": "固",
"嗌": "爱",
"鄱": "婆",
"墀": "持",
"颳": "瓜",
"漯": "落",
"蓑": "缩",
"賠": "培",
"疖": "接",
"豈": "起",
"绋": "福",
"隈": "微",
"洳": "入",
"哙": "快",
"鹂": "离",
"瑤": "摇",
"汊": "差",
"麴": "区",
"蜚": "飞",
"絨": "容",
"谉": "审",
"釘": "丁",
"勻": "云",
"觴": "伤",
"岘": "现",
"骈": "偏",
"壆": "学",
"櫣": "连",
"妪": "玉",
"薹": "台",
"鲈": "芦",
"跶": "达",
"坭": "尼",
"姪": "直",
"洮": "桃",
"箧": "妾",
"挹": "意",
"囝": "减",
"乩": "机",
"芑": "起",
"乚": "引",
"睏": "困",
"腫": "种",
"偲": "猜",
"荥": "行",
"擲": "至",
"蛔": "回",
"讣": "父",
"膦": "吝",
"餮": "贴",
"嶽": "月",
"倨": "巨",
"砭": "编",
"牀": "床",
"濞": "必",
"謹": "紧",
"腎": "肾",
"圌": "传",
"苜": "木",
"肱": "工",
"胴": "动",
"纟": "思",
"犽": "亚",
"肼": "井",
"酊": "丁",
"綏": "虽",
"籐": "腾",
"渉": "设",
"缯": "增",
"悆": "玉",
"锔": "居",
"欏": "罗",
"謇": "减",
"橐": "驮",
"霎": "煞",
"殄": "舔",
"禇": "者",
"鉤": "勾",
"噠": "答",
"郇": "环",
"蕖": "取",
"戆": "杠",
"勭": "同",
"勖": "续",
"婭": "亚",
"咛": "凝",
"燦": "灿",
"肟": "卧",
"抺": "妹",
"弭": "米",
"趸": "蹲",
"蝕": "石",
"浞": "着",
"臎": "翠",
"垵": "俺",
"笱": "狗",
"邛": "穷",
"応": "应",
"墮": "堕",
"墳": "坟",
"擞": "搜",
"蚺": "然",
"绐": "带",
"髁": "科",
"蹁": "偏",
"簾": "连",
"厶": "思",
"頼": "赖",
"苄": "变",
"噤": "进",
"鈞": "君",
"蓖": "必",
"廻": "回",
"臵": "格",
"慄": "利",
"紘": "红",
"柩": "就",
"垩": "恶",
"蠅": "营",
"冏": "窘",
"槭": "七",
"幷": "病",
"緝": "机",
"纡": "迂",
"鷲": "就",
"迤": "宜",
"芏": "度",
"昉": "访",
"沔": "免",
"叵": "坡",
"郯": "谈",
"桠": "呀",
"翹": "巧",
"忄": "心",
"驽": "努",
"埧": "巨",
"佥": "前",
"蕤": "瑞",
"笥": "四",
"楃": "卧",
"颞": "聂",
"骓": "追",
"嗪": "琴",
"旒": "刘",
"岜": "八",
"偣": "烟",
"禳": "嚷",
"恫": "动",
"権": "全",
"匚": "方",
"愆": "前",
"牖": "有",
"钐": "山",
"鲟": "寻",
"栞": "看",
"诌": "周",
"仉": "长",
"坼": "撤",
"鯊": "沙",
"販": "饭",
"硎": "行",
"赍": "机",
"洎": "记",
"杌": "物",
"鈔": "超",
"遴": "林",
"圜": "环",
"齢": "零",
"貳": "二",
"瘿": "影",
"镕": "容",
"呭": "意",
"憿": "角",
"芎": "琼",
"絞": "角",
"頜": "和",
"肫": "准",
"颛": "专",
"訳": "意",
"鬱": "玉",
"醌": "昆",
"哝": "农",
"紡": "访",
"尢": "由",
"忖": "存",
"炘": "心",
"铒": "耳",
"磴": "凳",
"諧": "鞋",
"缳": "环",
"纥": "歌",
"嚧": "芦",
"貶": "扁",
"窯": "摇",
"嬗": "善",
"郸": "单",
"襠": "当",
"崙": "伦",
"彊": "降",
"氿": "鬼",
"幛": "帐",
"绻": "犬",
"骢": "聪",
"镛": "庸",
"孀": "双",
"粄": "板",
"裨": "必",
"荪": "孙",
"礙": "爱",
"胪": "芦",
"戞": "夹",
"脿": "标",
"逖": "替",
"螅": "西",
"鏀": "鲁",
"蘆": "芦",
"萆": "必",
"吚": "一",
"麸": "夫",
"矍": "觉",
"燔": "烦",
"浥": "意",
"碣": "节",
"椟": "毒",
"鞯": "间",
"荠": "记",
"镫": "凳",
"堍": "兔",
"拰": "您",
"芣": "福",
"啫": "者",
"揸": "扎",
"狎": "侠",
"咤": "咋",
"郓": "运",
"傛": "永",
"悩": "脑",
"呑": "吞",
"攞": "罗",
"菟": "图",
"洰": "巨",
"崆": "空",
"屐": "机",
"竽": "鱼",
"嗾": "搜",
"鳩": "纠",
"俿": "虎",
"艸": "草",
"豸": "至",
"攔": "蓝",
"绂": "福",
"儷": "利",
"衲": "那",
"苘": "请",
"砜": "风",
"洐": "行",
"骖": "参",
"琍": "离",
"瘥": "拆",
"佞": "宁",
"彳": "赤",
"龘": "达",
"砀": "荡",
"庝": "同",
"盍": "和",
"烀": "呼",
"峄": "意",
"穑": "色",
"阊": "昌",
"臋": "吞",
"硖": "侠",
"嗫": "聂",
"苴": "居",
"龔": "工",
"誇": "夸",
"槓": "杠",
"愪": "云",
"呙": "锅",
"莛": "停",
"鏆": "灌",
"卣": "有",
"聃": "单",
"閻": "颜",
"滀": "处",
"怙": "互",
"诒": "宜",
"喫": "吃",
"缂": "客",
"枱": "台",
"镱": "意",
"薫": "熏",
"讵": "巨",
"橛": "觉",
"蚧": "借",
"蘊": "运",
"庑": "五",
"飧": "孙",
"瑣": "锁",
"惘": "网",
"淪": "伦",
"汅": "免",
"儋": "单",
"醭": "哺",
"蟮": "善",
"撘": "答",
"癍": "班",
"矸": "干",
"苼": "生",
"嘌": "票",
"杼": "助",
"婁": "楼",
"铙": "脑",
"荭": "红",
"恏": "号",
"捭": "摆",
"羨": "现",
"痩": "瘦",
"缡": "离",
"姞": "极",
"閔": "敏",
"棗": "早",
"谡": "速",
"糞": "愤",
"颯": "萨",
"緬": "免",
"舁": "鱼",
"敓": "夺",
"谲": "觉",
"龊": "绰",
"艱": "间",
"炆": "文",
"庋": "鬼",
"鈎": "勾",
"逕": "静",
"箜": "空",
"荊": "精",
"蠃": "裸",
"稗": "败",
"湉": "田",
"婼": "绰",
"蟼": "井",
"蚶": "憨",
"岽": "东",
"眭": "虽",
"塆": "弯",
"呮": "气",
"崁": "看",
"斿": "由",
"慊": "欠",
"窉": "饼",
"噂": "尊",
"碇": "定",
"楝": "练",
"鱂": "将",
"鈣": "概",
"憣": "翻",
"酽": "燕",
"毬": "求",
"汎": "饭",
"徼": "角",
"瑯": "狼",
"揆": "奎",
"揺": "摇",
"铘": "爷",
"芗": "相",
"觐": "进",
"蛩": "穷",
"荳": "豆",
"鋸": "巨",
"镹": "久",
"霊": "零",
"镋": "躺",
"濁": "着",
"閤": "格",
"珙": "拱",
"袪": "区",
"蚨": "福",
"榧": "匪",
"軽": "至",
"冂": "窘",
"畹": "碗",
"坻": "持",
"怍": "做",
"滷": "鲁",
"锒": "狼",
"囷": "群",
"胱": "光",
"耄": "帽",
"娠": "深",
"熸": "间",
"孒": "觉",
"冴": "互",
"砻": "龙",
"沩": "维",
"攵": "铺",
"澀": "色",
"怆": "创",
"煥": "换",
"氷": "冰",
"侪": "柴",
"弔": "掉",
"妘": "云",
"奁": "连",
"鰓": "塞",
"栉": "至",
"啉": "林",
"贠": "原",
"濬": "俊",
"荘": "装",
"鼍": "驮",
"俷": "费",
"堛": "必",
"萩": "秋",
"蔭": "因",
"髡": "昆",
"鋈": "物",
"鈪": "恶",
"忕": "是",
"铕": "有",
"瘁": "翠",
"嫑": "薄",
"絆": "办",
"帙": "至",
"藁": "搞",
"芴": "物",
"済": "记",
"觳": "胡",
"黉": "红",
"渃": "弱",
"纖": "先",
"贅": "缀",
"埗": "不",
"茭": "教",
"鋅": "心",
"搿": "格",
"虜": "鲁",
"鹕": "胡",
"戜": "叠",
"紳": "深",
"瓙": "到",
"谖": "宣",
"锎": "开",
"駁": "博",
"蒌": "楼",
"隍": "黄",
"谀": "鱼",
"葶": "停",
"鏋": "满",
"灑": "洒",
"詈": "利",
"堿": "减",
"夼": "旷",
"鑷": "聂",
"弢": "掏",
"塍": "成",
"旂": "其",
"羧": "缩",
"帱": "愁",
"墾": "肯",
"鸪": "姑",
"潴": "朱",
"鏊": "奥",
"睌": "满",
"傥": "躺",
"胍": "瓜",
"萋": "七",
"赀": "姿",
"俣": "雨",
"邳": "批",
"讝": "占",
"暱": "逆",
"鲵": "尼",
"亽": "极",
"嚭": "匹",
"赜": "则",
"暾": "吞",
"噑": "豪",
"罟": "古",
"燙": "烫",
"奬": "讲",
"醢": "海",
"朮": "树",
"骛": "物",
"辺": "编",
"勪": "觉",
"溲": "搜",
"憤": "愤",
"覧": "懒",
"暉": "灰",
"儏": "灿",
"闕": "确",
"蒐": "搜",
"斃": "必",
"樨": "西",
"鳕": "雪",
"檠": "情",
"媺": "美",
"懼": "巨",
"莖": "精",
"葑": "风",
"裎": "成",
"俶": "处",
"肜": "容",
"鏌": "墨",
"龢": "和",
"闅": "文",
"诨": "混",
"龑": "眼",
"镨": "普",
"凖": "准",
"艉": "伟",
"濫": "烂",
"仩": "长",
"仮": "反",
"碜": "尘",
"牯": "古",
"飆": "标",
"眄": "免",
"髂": "恰",
"辔": "配",
"滯": "至",
"滗": "必",
"浈": "真",
"啗": "蛋",
"冮": "刚",
"璠": "烦",
"瞞": "瞒",
"絢": "炫",
"跹": "先",
"戗": "枪",
"苣": "巨",
"噹": "当",
"泬": "觉",
"蛸": "烧",
"狻": "酸",
"唁": "燕",
"耋": "叠",
"睜": "睁",
"訫": "信",
"剞": "机",
"啝": "和",
"夌": "零",
"頑": "完",
"琭": "路",
"曛": "熏",
"觯": "至",
"廪": "吝",
"弒": "是",
"殓": "练",
"繰": "早",
"兌": "对",
"鳐": "摇",
"祧": "挑",
"擄": "鲁",
"茑": "尿",
"檚": "楚",
"浃": "家",
"驕": "教",
"営": "营",
"蘖": "聂",
"脇": "鞋",
"侓": "路",
"刋": "欠",
"齑": "机",
"稹": "枕",
"鬣": "裂",
"艿": "奶",
"钆": "嘎",
"鎗": "枪",
"顛": "颠",
"雩": "鱼",
"麂": "几",
"糺": "纠",
"鍍": "度",
"圬": "乌",
"疋": "匹",
"陉": "行",
"婂": "眠",
"戣": "奎",
"毘": "皮",
"玢": "彬",
"摭": "直",
"瘢": "班",
"苁": "聪",
"戻": "替",
"嶇": "区",
"惢": "锁",
"荛": "扰",
"諫": "见",
"獬": "谢",
"辂": "路",
"楀": "雨",
"錠": "定",
"喾": "裤",
"盪": "荡",
"罍": "雷",
"釀": "娘",
"谿": "西",
"濾": "绿",
"榉": "举",
"訥": "呢",
"璽": "洗",
"袛": "低",
"冧": "林",
"椐": "居",
"詰": "节",
"玹": "旋",
"彂": "发",
"笮": "则",
"暍": "椰",
"熳": "慢",
"佤": "瓦",
"閏": "润",
"饔": "庸",
"旆": "配",
"貅": "修",
"陬": "邹",
"猱": "脑",
"迓": "亚",
"嗞": "姿",
"頔": "敌",
"酎": "昼",
"緋": "飞",
"铪": "哈",
"懲": "成",
"舎": "设",
"聡": "聪",
"髭": "姿",
"礻": "是",
"蘧": "取",
"攴": "铺",
"箨": "拓",
"罨": "眼",
"垓": "该",
"勰": "鞋",
"漬": "字",
"蠟": "蜡",
"鄄": "倦",
"缷": "谢",
"哕": "会",
"圮": "匹",
"诎": "区",
"埽": "懆",
"羙": "高",
"廂": "相",
"侔": "谋",
"顎": "恶",
"摈": "宾",
"竄": "窜",
"恿": "永",
"侩": "快",
"氤": "因",
"鐖": "机",
"蔥": "聪",
"鹵": "鲁",
"焜": "昆",
"谘": "姿",
"骠": "标",
"攪": "角",
"蟀": "帅",
"錐": "追",
"悛": "圈",
"蠂": "设",
"鎸": "捐",
"枌": "坟",
"瀕": "彬",
"埤": "皮",
"鲞": "想",
"徴": "睁",
"淆": "肖",
"偠": "咬",
"諒": "亮",
"懇": "肯",
"吿": "告",
"暁": "小",
"茏": "龙",
"猭": "穿",
"朊": "软",
"俜": "平",
"诿": "伟",
"俳": "排",
"倻": "椰",
"勯": "单",
"槁": "搞",
"蚵": "和",
"瓠": "互",
"渫": "谢",
"鲷": "雕",
"葺": "气",
"镏": "刘",
"嶝": "凳",
"鳎": "塔",
"翮": "和",
"禤": "宣",
"钋": "坡",
"搠": "硕",
"攬": "懒",
"踐": "见",
"蛉": "零",
"帑": "躺",
"埌": "浪",
"耪": "旁",
"煄": "种",
"衽": "任",
"晧": "号",
"犴": "按",
"鲂": "房",
"跬": "魁",
"蠁": "想",
"洸": "光",
"傜": "摇",
"隰": "习",
"喟": "溃",
"錨": "毛",
"剰": "胜",
"襪": "袜",
"锇": "额",
"伲": "逆",
"忔": "气",
"匏": "袍",
"繡": "秀",
"弐": "二",
"衄": "女",
"鎧": "凯",
"陲": "垂",
"驛": "意",
"滂": "旁",
"谮": "怎",
"髹": "修",
"璿": "旋",
"龕": "看",
"嗉": "速",
"铥": "丢",
"詣": "意",
"蝽": "春",
"堟": "赚",
"甦": "苏",
"匐": "福",
"厣": "眼",
"嶆": "曹",
"媸": "吃",
"煖": "暖",
"殤": "伤",
"倮": "裸",
"簌": "速",
"寔": "石",
"捩": "裂",
"竇": "豆",
"鮋": "由",
"珵": "成",
"呬": "系",
"萜": "贴",
"吇": "子",
"梱": "捆",
"笹": "踢",
"妁": "硕",
"瑱": "镇",
"旯": "啦",
"窪": "挖",
"槄": "掏",
"圹": "矿",
"儡": "垒",
"缌": "思",
"鹛": "梅",
"敎": "教",
"撈": "捞",
"徂": "促",
"呺": "消",
"彖": "团",
"枨": "成",
"舘": "管",
"宬": "成",
"鲠": "梗",
"鈦": "太",
"椂": "路",
"噺": "心",
"鞞": "饼",
"蠓": "猛",
"悻": "性",
"蓠": "离",
"泅": "求",
"妧": "万",
"镡": "缠",
"嗘": "机",
"瞽": "古",
"酃": "零",
"衪": "宜",
"覓": "密",
"誦": "宋",
"蠈": "贼",
"粋": "翠",
"缧": "雷",
"柽": "称",
"剤": "记",
"匦": "鬼",
"鞣": "柔",
"澆": "教",
"梃": "挺",
"潅": "灌",
"癢": "养",
"冪": "密",
"溦": "微",
"沬": "妹",
"鮨": "意",
"暐": "伟",
"囵": "伦",
"雱": "旁",
"浯": "无",
"瀾": "蓝",
"蛴": "其",
"躇": "除",
"镆": "墨",
"侀": "行",
"熺": "西",
"窬": "鱼",
"疴": "科",
"薈": "会",
"仂": "乐",
"霑": "占",
"铽": "特",
"媾": "够",
"逭": "换",
"黾": "敏",
"燐": "林",
"酞": "太",
"钄": "蓝",
"哌": "派",
"粧": "装",
"鄹": "邹",
"仼": "王",
"柝": "拓",
"渦": "窝",
"翥": "助",
"缬": "鞋",
"纮": "红",
"蘼": "迷",
"黥": "情",
"堞": "叠",
"鲇": "年",
"嬖": "必",
"柙": "侠",
"箻": "绿",
"硃": "朱",
"怹": "贪",
"諱": "会",
"埘": "石",
"鍩": "舔",
"菹": "居",
"愀": "巧",
"隳": "灰",
"垜": "朵",
"犺": "抗",
"螢": "营",
"觜": "姿",
"矚": "主",
"侖": "伦",
"觊": "记",
"蠲": "捐",
"燿": "要",
"坵": "秋",
"嬿": "燕",
"崱": "责",
"怄": "欧",
"跗": "夫",
"诔": "垒",
"鴉": "呀",
"饑": "机",
"睞": "赖",
"悳": "德",
"襯": "衬",
"垁": "至",
"滲": "肾",
"柁": "堕",
"玒": "红",
"屛": "平",
"篪": "持",
"籼": "先",
"崘": "伦",
"佉": "区",
"囲": "通",
"癮": "引",
"倜": "替",
"胝": "知",
"徭": "摇",
"讠": "颜",
"荽": "虽",
"偆": "春",
"鵰": "雕",
"嗙": "旁",
"宄": "鬼",
"镘": "慢",
"鼉": "驮",
"殲": "间",
"伋": "极",
"諜": "叠",
"莴": "窝",
"儂": "农",
"佻": "挑",
"銎": "穷",
"疳": "干",
"犵": "歌",
"嫫": "魔",
"娡": "至",
"褕": "鱼",
"漤": "懒",
"帔": "配",
"澘": "山",
"旄": "毛",
"锍": "柳",
"豇": "将",
"栌": "芦",
"垧": "赏",
"閾": "玉",
"晳": "西",
"賗": "串",
"夁": "一",
"粜": "跳",
"拊": "辅",
"暸": "聊",
"褛": "旅",
"瘗": "意",
"鍓": "极",
"羰": "汤",
"儵": "书",
"賍": "脏",
"驢": "驴",
"嘏": "古",
"蚣": "工",
"鎼": "下",
"鍪": "谋",
"兝": "分",
"梟": "消",
"懔": "吝",
"繖": "三",
"臿": "插",
"峩": "额",
"篩": "筛",
"猓": "果",
"泐": "乐",
"撄": "应",
"鈍": "顿",
"绁": "谢",
"驍": "消",
"褫": "尺",
"瑋": "伟",
"閨": "归",
"覗": "四",
"秣": "墨",
"挙": "举",
"瓿": "不",
"繃": "崩",
"豳": "彬",
"噓": "需",
"埒": "裂",
"涠": "维",
"涑": "速",
"僞": "伟",
"儉": "减",
"黼": "辅",
"贛": "干",
"窕": "挑",
"揹": "杯",
"涴": "卧",
"峿": "雨",
"盌": "碗",
"囨": "偏",
"痱": "费",
"淏": "号",
"蓐": "入",
"湅": "练",
"穢": "会",
"綔": "互",
"潑": "坡",
"酐": "干",
"莠": "有",
"摳": "口",
"鈉": "那",
"頤": "宜",
"谠": "挡",
"聙": "精",
"詐": "咋",
"勛": "熏",
"榖": "古",
"竊": "妾",
"兎": "兔",
"尥": "料",
"囓": "聂",
"逡": "群",
"鸱": "吃",
"筮": "是",
"嘯": "笑",
"巛": "穿",
"嚜": "么",
"払": "反",
"絃": "闲",
"顫": "颤",
"抔": "剖",
"嶷": "宜",
"鳜": "贵",
"鱈": "雪",
"攏": "垄",
"僉": "前",
"皤": "婆",
"廬": "芦",
"陜": "侠",
"锪": "霍",
"僳": "速",
"鞒": "桥",
"薤": "谢",
"霪": "银",
"詭": "鬼",
"戙": "动",
"扃": "窘",
"罘": "福",
"鎂": "美",
"胗": "真",
"絹": "倦",
"鼖": "坟",
"祅": "邀",
"躏": "吝",
"寃": "冤",
"冹": "福",
"囪": "聪",
"橼": "原",
"豨": "西",
"鸬": "芦",
"閬": "浪",
"餍": "燕",
"瑧": "真",
"犭": "犬",
"氾": "饭",
"邶": "被",
"嬱": "欠",
"酹": "泪",
"擗": "匹",
"塎": "永",
"缢": "意",
"鹼": "减",
"涫": "灌",
"栲": "考",
"謊": "谎",
"胙": "做",
"馃": "果",
"厓": "牙",
"呿": "去",
"継": "记",
"驟": "昼",
"闍": "督",
"襙": "操",
"婱": "闲",
"湡": "鱼",
"劼": "节",
"疠": "利",
"窓": "窗",
"媵": "硬",
"槠": "朱",
"縁": "原",
"仏": "佛",
"駭": "害",
"跎": "驮",
"宍": "肉",
"袴": "裤",
"硶": "尘",
"駱": "落",
"躔": "缠",
"朐": "取",
"茕": "穷",
"逶": "微",
"亶": "胆",
"媄": "美",
"暦": "利",
"瓘": "灌",
"洨": "肖",
"綄": "环",
"尪": "汪",
"脹": "帐",
"跫": "穷",
"肊": "意",
"氹": "荡",
"鎳": "聂",
"哚": "朵",
"戋": "间",
"哿": "葛",
"骘": "至",
"钀": "聂",
"菔": "福",
"冭": "太",
"渶": "应",
"溷": "混",
"沚": "指",
"蛘": "羊",
"碚": "被",
"筌": "全",
"鵺": "夜",
"挲": "撒",
"钫": "方",
"铩": "沙",
"撓": "脑",
"贽": "至",
"绨": "提",
"觇": "搀",
"炪": "捉",
"崾": "咬",
"堋": "朋",
"仃": "丁",
"骟": "善",
"晷": "鬼",
"塱": "浪",
"浐": "铲",
"殂": "促",
"缒": "缀",
"叏": "怪",
"珰": "当",
"綸": "伦",
"倣": "访",
"薑": "将",
"朂": "续",
"蔔": "博",
"銃": "冲",
"悕": "西",
"恂": "寻",
"鴿": "歌",
"糾": "纠",
"睃": "缩",
"耧": "楼",
"胛": "假",
"嘧": "密",
"帼": "国",
"髀": "必",
"镥": "鲁",
"嘹": "聊",
"茈": "瓷",
"狁": "允",
"颙": "庸",
"樗": "出",
"狷": "倦",
"劬": "取",
"袤": "帽",
"栊": "龙",
"儓": "台",
"郫": "皮",
"铗": "夹",
"莨": "浪",
"赕": "胆",
"砉": "或",
"楯": "顿",
"壱": "一",
"聴": "听",
"謠": "摇",
"螈": "原",
"炲": "台",
"甾": "灾",
"櫺": "零",
"螽": "中",
"阄": "纠",
"禎": "真",
"叆": "爱",
"佧": "卡",
"儸": "罗",
"攢": "赞",
"蚴": "右",
"轎": "教",
"垆": "芦",
"饫": "玉",
"紑": "否",
"崤": "肖",
"蕏": "除",
"縄": "生",
"踔": "戳",
"墠": "善",
"墁": "慢",
"繭": "减",
"徨": "黄",
"掤": "冰",
"銹": "秀",
"琌": "零",
"衤": "一",
"俢": "修",
"魨": "吞",
"骝": "刘",
"橥": "朱",
"戡": "看",
"晡": "不",
"耜": "四",
"姤": "够",
"匜": "宜",
"鈾": "由",
"盞": "展",
"緹": "提",
"隕": "允",
"敠": "多",
"汏": "大",
"罠": "民",
"埏": "山",
"擝": "蒙",
"斝": "假",
"噾": "因",
"鳔": "标",
"诹": "邹",
"悊": "哲",
"侽": "南",
"榘": "举",
"鲔": "伟",
"瞓": "愤",
"蝼": "楼",
"驲": "日",
"蓥": "营",
"泖": "帽",
"涒": "吞",
"妯": "轴",
"晝": "昼",
"睚": "牙",
"篼": "兜",
"簫": "消",
"屦": "巨",
"熻": "西",
"擱": "歌",
"鄴": "夜",
"殻": "巧",
"岣": "狗",
"嚮": "向",
"嗍": "缩",
"煺": "退",
"苊": "恶",
"鷺": "路",
"蜮": "玉",
"脽": "谁",
"葸": "洗",
"邗": "含",
"锞": "客",
"夤": "银",
"竈": "造",
"锜": "其",
"傭": "庸",
"鎭": "镇",
"朩": "等",
"悽": "七",
"簷": "颜",
"踣": "博",
"臾": "鱼",
"掮": "钱",
"榊": "神",
"攉": "霍",
"脔": "鸾",
"歺": "恶",
"罾": "增",
"洶": "胸",
"毌": "灌",
"耱": "墨",
"挻": "山",
"陝": "闪",
"纜": "懒",
"枥": "利",
"畠": "田",
"浍": "会",
"嬨": "瓷",
"茍": "记",
"淝": "肥",
"椼": "眼",
"濊": "会",
"瀞": "静",
"鳙": "庸",
"竑": "红",
"灝": "号",
"呪": "昼",
"踰": "鱼",
"菖": "昌",
"冩": "写",
"蜆": "现",
"滏": "辅",
"汩": "古",
"勅": "赤",
"墿": "意",
"垕": "后",
"酩": "命",
"觌": "敌",
"縷": "旅",
"鶯": "应",
"愰": "荒",
"綵": "采",
"呴": "许",
"脛": "静",
"垎": "贺",
"蓿": "须",
"胨": "动",
"坜": "利",
"刳": "哭",
"鸺": "修",
"巣": "朝",
"獴": "猛",
"尒": "耳",
"皯": "感",
"茳": "将",
"虿": "拆",
"馭": "玉",
"蠔": "豪",
"愦": "溃",
"泭": "福",
"鏢": "标",
"秫": "熟",
"鲳": "昌",
"筘": "扣",
"瘕": "假",
"喎": "歪",
"岿": "亏",
"睥": "屁",
"軀": "区",
"菴": "安",
"曘": "如",
"煕": "西",
"捜": "搜",
"苾": "必",
"桤": "七",
"籹": "女",
"甏": "甭",
"缣": "间",
"釦": "扣",
"娿": "阿",
"犸": "骂",
"偗": "省",
"鉢": "波",
"聼": "听",
"崟": "银",
"塢": "物",
"琤": "称",
"髌": "宾",
"砹": "爱",
"笁": "竹",
"髟": "标",
"姟": "该",
"孥": "努",
"艽": "教",
"莣": "王",
"脢": "梅",
"澔": "号",
"伕": "夫",
"砘": "顿",
"儛": "五",
"紺": "干",
"盄": "招",
"懆": "草",
"輥": "滚",
"鬘": "瞒",
"痠": "酸",
"樼": "真",
"哓": "消",
"脬": "抛",
"価": "四",
"伉": "抗",
"蕓": "云",
"偅": "重",
"扱": "西",
"乸": "哪",
"盉": "和",
"漭": "忙",
"鸞": "鸾",
"窺": "亏",
"搗": "导",
"愔": "因",
"蓍": "诗",
"幄": "卧",
"赧": "男",
"饩": "系",
"醃": "烟",
"鑼": "罗",
"鞏": "拱",
"噯": "哀",
"姳": "命",
"崃": "来",
"痍": "宜",
"儑": "岸",
"喹": "奎",
"坉": "吞",
"鏇": "炫",
"鲅": "爸",
"笾": "编",
"鲋": "父",
"悫": "确",
"鹍": "昆",
"禚": "着",
"筇": "穷",
"檑": "雷",
"斎": "摘",
"鎚": "垂",
"鳶": "冤",
"镔": "彬",
"綬": "瘦",
"愎": "必",
"苎": "助",
"郐": "快",
"楁": "和",
"诖": "挂",
"崐": "昆",
"荸": "鼻",
"韪": "伟",
"皺": "昼",
"骣": "铲",
"谇": "岁",
"瘰": "裸",
"岃": "任",
"銓": "全",
"鑺": "取",
"粬": "区",
"飑": "标",
"輿": "鱼",
"褴": "蓝",
"轍": "哲",
"旀": "妹",
"硏": "颜",
"泩": "生",
"畛": "枕",
"龉": "雨",
"骱": "借",
"冖": "密",
"褞": "允",
"鮎": "年",
"殚": "单",
"暻": "井",
"嫻": "闲",
"覇": "爸",
"啞": "哑",
"堙": "因",
"黟": "一",
"耥": "汤",
"褏": "秀",
"悝": "亏",
"蚋": "瑞",
"籴": "敌",
"鏖": "敖",
"掱": "爬",
"俬": "思",
"撻": "踏",
"蝰": "奎",
"鉻": "落",
"粢": "姿",
"脨": "促",
"肄": "意",
"駆": "区",
"炤": "照",
"酡": "驮",
"鬍": "胡",
"愷": "凯",
"遅": "持",
"鈊": "心",
"遄": "传",
"绲": "滚",
"馓": "三",
"烔": "同",
"靼": "达",
"畾": "雷",
"跣": "显",
"湳": "男",
"榇": "衬",
"蠊": "连",
"砵": "波",
"禿": "突",
"秕": "比",
"鋰": "李",
"絷": "直",
"歯": "尺",
"懐": "怀",
"燠": "玉",
"卌": "系",
"坌": "笨",
"浬": "李",
"堠": "后",
"弝": "爸",
"夶": "比",
"筲": "烧",
"瑢": "容",
"龀": "衬",
"墘": "钱",
"炱": "台",
"夈": "摘",
"蝮": "父",
"筅": "显",
"熾": "赤",
"欐": "利",
"艡": "当",
"渟": "停",
"郾": "眼",
"跞": "利",
"鄺": "矿",
"闡": "铲",
"惱": "脑",
"鳯": "奉",
"曇": "谈",
"硯": "燕",
"脥": "浅",
"庒": "装",
"寲": "宜",
"輒": "哲",
"欎": "玉",
"淒": "七",
"盥": "灌",
"婃": "从",
"沆": "行",
"庅": "魔",
"亼": "极",
"羈": "机",
"跄": "枪",
"瘳": "抽",
"雑": "杂",
"氅": "场",
"饣": "石",
"欒": "鸾",
"柵": "山",
"芄": "完",
"槻": "归",
"垨": "手",
"骺": "喉",
"岈": "牙",
"椛": "花",
"傕": "觉",
"裟": "沙",
"穦": "拼",
"鈹": "批",
"埍": "卷",
"蒉": "溃",
"甕": "瓮",
"嗻": "遮",
"涚": "睡",
"鐑": "妾",
"癜": "电",
"濄": "锅",
"悎": "号",
"薷": "如",
"觏": "够",
"斂": "脸",
"廁": "册",
"喈": "接",
"囦": "冤",
"暘": "羊",
"槲": "胡",
"眬": "龙",
"鲮": "零",
"镦": "对",
"庥": "修",
"袷": "夹",
"噍": "教",
"裥": "减",
"趼": "减",
"坫": "电",
"岺": "零",
"愭": "其",
"缏": "变",
"锸": "插",
"尨": "忙",
"畨": "攀",
"愩": "工",
"縢": "腾",
"秊": "年",
"搥": "垂",
"駡": "骂",
"芨": "机",
"玘": "起",
"廾": "拱",
"谳": "燕",
"誐": "额",
"茌": "持",
"貯": "助",
"眏": "养",
"漈": "记",
"賃": "吝",
"垡": "罚",
"鹣": "间",
"诂": "古",
"鏟": "铲",
"鉗": "钱",
"獗": "觉",
"洿": "乌",
"棨": "起",
"燉": "顿",
"閪": "色",
"槙": "颠",
"蠖": "或",
"龠": "月",
"鑱": "缠",
"綍": "福",
"倥": "空",
"戥": "等",
"圄": "雨",
"鼗": "桃",
"哾": "说",
"鏽": "秀",
"僱": "固",
"睍": "现",
"鉀": "假",
"裼": "替",
"鷗": "欧",
"晫": "着",
"涏": "挺",
"濇": "色",
"櫒": "萨",
"鱻": "先",
"籺": "和",
"嫘": "雷",
"傧": "彬",
"卬": "昂",
"枡": "生",
"菂": "地",
"鸸": "而",
"屺": "起",
"簲": "排",
"閰": "局",
"峓": "宜",
"枃": "进",
"裢": "连",
"囙": "因",
"脗": "稳",
"祆": "先",
"奭": "是",
"舡": "传",
"痼": "固",
"骀": "带",
"貊": "墨",
"皵": "确",
"贶": "矿",
"祓": "福",
"謦": "请",
"銭": "钱",
"褎": "秀",
"鮫": "教",
"秾": "农",
"憷": "处",
"魟": "红",
"亰": "精",
"蔟": "促",
"匂": "胸",
"湰": "龙",
"仳": "匹",
"歃": "煞",
"嬅": "话",
"栬": "最",
"辏": "凑",
"鬯": "唱",
"岍": "前",
"逦": "李",
"檻": "砍",
"庀": "匹",
"艚": "曹",
"辎": "姿",
"裉": "肯",
"媗": "宣",
"鲭": "青",
"琻": "金",
"褑": "院",
"扆": "以",
"駌": "冤",
"撴": "蹲",
"箌": "到",
"蔘": "深",
"堢": "宝",
"敫": "角",
"尯": "溃",
"嵛": "鱼",
"甗": "眼",
"朠": "应",
"砑": "亚",
"凵": "浅",
"鍣": "招",
"庁": "听",
"縻": "迷",
"惀": "伦",
"峠": "恰",
"彐": "记",
"鸹": "瓜",
"煋": "星",
"廛": "缠",
"茚": "印",
"倶": "巨",
"櫛": "至",
"僾": "爱",
"芲": "花",
"畋": "田",
"婄": "剖",
"蠶": "残",
"轺": "摇",
"迕": "物",
"曟": "陈",
"廝": "思",
"揞": "俺",
"煒": "伟",
"紵": "助",
"褡": "答",
"燄": "燕",
"袓": "巨",
"朶": "朵",
"摻": "灿",
"煇": "灰",
"澌": "思",
"甪": "路",
"鉯": "以",
"蒹": "间",
"偘": "砍",
"鰍": "秋",
"彫": "雕",
"椀": "碗",
"燭": "竹",
"伈": "信",
"抎": "允",
"瓑": "利",
"葙": "相",
"伥": "昌",
"玏": "乐",
"鲆": "平",
"鞴": "被",
"狆": "重",
"鈕": "纽",
"芟": "山",
"筯": "助",
"癲": "颠",
"菫": "紧",
"搮": "利",
"鈳": "科",
"芤": "口",
"晥": "碗",
"婲": "花",
"笸": "坡",
"骉": "标",
"儶": "会",
"戓": "歌",
"鹱": "互",
"姌": "染",
"咴": "灰",
"玆": "姿",
"絀": "处",
"栥": "姿",
"煶": "是",
"膰": "烦",
"鲊": "眨",
"舳": "竹",
"帻": "则",
"塅": "断",
"塄": "棱",
"敉": "米",
"黠": "侠",
"挊": "弄",
"孳": "姿",
"紬": "愁",
"夎": "错",
"嚅": "如",
"黧": "离",
"冚": "砍",
"矧": "审",
"揷": "插",
"忉": "刀",
"胂": "肾",
"馴": "寻",
"菿": "到",
"鳏": "关",
"欍": "就",
"儴": "嚷",
"瞢": "盟",
"杺": "心",
"赳": "纠",
"祌": "重",
"瘛": "赤",
"驺": "邹",
"茛": "根",
"磲": "取",
"搦": "诺",
"朹": "鬼",
"掙": "睁",
"讐": "愁",
"襞": "必",
"忮": "至",
"祫": "侠",
"膮": "消",
"瀉": "谢",
"偪": "逼",
"鍃": "霍",
"呡": "稳",
"誣": "乌",
"苧": "凝",
"莸": "由",
"滌": "敌",
"罱": "懒",
"鵜": "提",
"穫": "或",
"烎": "银",
"簦": "灯",
"鐒": "劳",
"犱": "几",
"猟": "裂",
"铫": "掉",
"檗": "薄",
"繕": "善",
"伄": "掉",
"鎽": "风",
"篌": "喉",
"甍": "盟",
"麣": "颜",
"鲽": "叠",
"麺": "面",
"毴": "逼",
"矯": "角",
"脶": "罗",
"軋": "亚",
"粝": "利",
"廴": "引",
"贖": "熟",
"厷": "工",
"潲": "绍",
"浤": "红",
"咘": "不",
"栱": "拱",
"咑": "答",
"垲": "凯",
"崦": "烟",
"湀": "鬼",
"轾": "至",
"渀": "笨",
"悗": "瞒",
"酲": "成",
"劓": "意",
"簒": "窜",
"僪": "局",
"廨": "谢",
"鸲": "取",
"幝": "铲",
"跏": "家",
"躜": "钻",
"荦": "落",
"隴": "垄",
"憍": "教",
"闶": "康",
"鞫": "居",
"仫": "木",
"艄": "烧",
"缽": "波",
"圝": "鸾",
"脰": "豆",
"窳": "雨",
"襻": "判",
"舻": "芦",
"囑": "主",
"槳": "讲",
"鼙": "皮",
"畚": "本",
"刎": "稳",
"皲": "君",
"皞": "号",
"莩": "福",
"仡": "歌",
"廃": "费",
"挾": "鞋",
"姏": "瞒",
"籲": "玉",
"迺": "奶",
"拝": "败",
"鳊": "编",
"圯": "宜",
"遘": "够",
"乣": "久",
"狨": "容",
"銑": "显",
"鹩": "聊",
"荩": "进",
"涢": "云",
"撺": "窜",
"籀": "昼",
"籬": "离",
"峣": "摇",
"嘩": "花",
"麹": "区",
"伅": "顿",
"蛄": "姑",
"哢": "弄",
"廯": "先",
"狲": "孙",
"瓨": "翔",
"竷": "砍",
"焃": "贺",
"猡": "罗",
"虓": "消",
"鑸": "垒",
"洣": "米",
"渼": "美",
"汸": "方",
"墖": "塔",
"樶": "嘴",
"兿": "意",
"踟": "持",
"搋": "揣",
"寘": "至",
"岵": "互",
"庤": "至",
"蕹": "瓮",
"摯": "至",
"矅": "要",
"鎹": "宋",
"洏": "而",
"稂": "狼",
"呉": "无",
"諦": "地",
"鉑": "博",
"搛": "间",
"艋": "猛",
"鳇": "黄",
"繘": "玉",
"桴": "福",
"缍": "朵",
"蠉": "宣",
"婅": "局",
"诼": "着",
"澗": "见",
"迣": "至",
"爇": "弱",
"鲩": "换",
"簮": "赞",
"龃": "举",
"簖": "断",
"盱": "需",
"砬": "啦",
"畳": "叠",
"潗": "极",
"緂": "田",
"闿": "凯",
"黻": "福",
"苐": "提",
"挢": "角",
"鹾": "搓",
"懑": "闷",
"獃": "呆",
"聳": "耸",
"塁": "垒",
"謨": "魔",
"淠": "屁",
"佀": "四",
"砩": "福",
"窆": "扁",
"拡": "扩",
"鰈": "叠",
"埜": "也",
"箝": "钱",
"吢": "亲",
"脤": "肾",
"簬": "路",
"氶": "整",
"蛯": "老",
"袮": "迷",
"諷": "奉",
"驊": "华",
"檜": "贵",
"汭": "瑞",
"儱": "垄",
"錚": "睁",
"雋": "倦",
"痺": "必",
"湇": "气",
"炴": "养",
"苺": "梅",
"泚": "此",
"獍": "静",
"鮭": "归",
"泔": "干",
"秭": "子",
"翾": "宣",
"箦": "则",
"蒨": "欠",
"蜢": "猛",
"镠": "刘",
"粨": "摆",
"笤": "条",
"穸": "西",
"茼": "同",
"栝": "瓜",
"陔": "该",
"洅": "在",
"訟": "宋",
"飢": "机",
"棬": "圈",
"笊": "照",
"僰": "博",
"礪": "利",
"旰": "干",
"趵": "报",
"佴": "二",
"郛": "福",
"滐": "节",
"栨": "次",
"畬": "舍",
"鳟": "尊",
"儔": "愁",
"湎": "免",
"嗛": "浅",
"箣": "册",
"羮": "耕",
"瓞": "叠",
"徉": "羊",
"蒔": "石",
"毳": "翠",
"麿": "迷",
"鹧": "这",
"耔": "子",
"虼": "个",
"缛": "入",
"枊": "盎",
"莶": "先",
"穌": "苏",
"糈": "许",
"犷": "广",
"亠": "头",
"侉": "垮",
"舾": "西",
"苳": "东",
"柃": "零",
"岖": "区",
"彯": "飘",
"蚱": "咋",
"颎": "窘",
"踬": "至",
"伒": "进",
"硭": "忙",
"暀": "网",
"澐": "云",
"檆": "山",
"嫠": "离",
"熀": "谎",
"豝": "八",
"桕": "就",
"圊": "青",
"瘆": "肾",
"牴": "底",
"缵": "钻",
"壸": "捆",
"泶": "学",
"夬": "怪",
"蛍": "营",
"酏": "以",
"趿": "他",
"餉": "想",
"珽": "挺",
"嘖": "则",
"弎": "三",
"禘": "地",
"鲡": "离",
"馿": "驴",
"讦": "节",
"忸": "纽",
"埇": "永",
"栘": "宜",
"砗": "车",
"溇": "楼",
"疒": "呢",
"儁": "俊",
"忎": "人",
"湔": "间",
"葦": "伟",
"脷": "利",
"潓": "会",
"笌": "牙",
"箞": "前",
"摰": "聂",
"镅": "梅",
"鍠": "黄",
"祔": "父",
"彴": "着",
"儹": "赞",
"忋": "改",
"疄": "吝",
"譻": "应",
"龒": "龙",
"迮": "则",
"馡": "飞",
"葚": "任",
"嫀": "琴",
"紜": "云",
"奨": "讲",
"嫃": "真",
"嬮": "烟",
"裣": "脸",
"噐": "气",
"滈": "号",
"橦": "同",
"偍": "提",
"蘩": "烦",
"猁": "利",
"樫": "间",
"亇": "吗",
"苠": "民",
"囥": "抗",
"甓": "屁",
"忪": "松",
"嵯": "搓",
"浿": "配",
"誮": "花",
"趄": "居",
"蟛": "朋",
"讧": "红",
"軎": "位",
"慝": "特",
"郕": "成",
"詤": "谎",
"萑": "环",
"潶": "黑",
"擐": "换",
"鱉": "憋",
"箋": "间",
"炻": "石",
"褊": "扁",
"轫": "任",
"択": "则",
"硇": "脑",
"縦": "宗",
"禊": "系",
"梶": "伟",
"鋭": "瑞",
"镤": "葡",
"眈": "单",
"顗": "以",
"凥": "居",
"蠱": "古",
"崋": "话",
"垤": "叠",
"慟": "痛",
"跚": "山",
"礤": "擦",
"綘": "逢",
"獞": "同",
"瘡": "窗",
"颱": "台",
"藴": "运",
"栦": "愁",
"綽": "绰",
"藔": "聊",
"輶": "由",
"簍": "楼",
"齤": "全",
"瓏": "龙",
"彿": "福",
"嬶": "鼻",
"龖": "达",
"嫲": "吗",
"譲": "让",
"阋": "系",
"箪": "单",
"麈": "主",
"丆": "罕",
"碹": "炫",
"厤": "利",
"裒": "剖",
"廸": "敌",
"瘐": "雨",
"籓": "翻",
"筍": "损",
"钶": "科",
"瑺": "长",
"眢": "冤",
"龤": "鞋",
"翚": "灰",
"仴": "卧",
"撙": "尊",
"俍": "良",
"緱": "勾",
"悓": "欠",
"繹": "意",
"丗": "是",
"邠": "彬",
"侷": "局",
"狅": "狂",
"傞": "缩",
"蜩": "条",
"褓": "宝",
"汔": "气",
"掟": "整",
"毵": "三",
"臁": "连",
"繋": "记",
"曡": "叠",
"埼": "其",
"缋": "会",
"嶉": "催",
"虮": "几",
"瞾": "照",
"鸶": "思",
"瑆": "星",
"歿": "墨",
"慉": "续",
"謁": "夜",
"呾": "达",
"濺": "见",
"涳": "空",
"龁": "和",
"艧": "或",
"貍": "离",
"嶶": "微",
"菥": "西",
"篃": "妹",
"肷": "浅",
"絳": "降",
"碶": "气",
"鯖": "睁",
"翛": "消",
"阏": "恶",
"轵": "指",
"萣": "定",
"鶏": "机",
"訛": "额",
"儯": "腾",
"眛": "妹",
"悱": "匪",
"鋬": "判",
"絜": "节",
"珹": "成",
"瀝": "利",
"盦": "安",
"銊": "续",
"眵": "吃",
"婹": "咬",
"嶃": "展",
"簏": "路",
"襤": "蓝",
"咾": "老",
"疎": "书",
"恠": "怪",
"脧": "捐",
"牮": "见",
"涗": "睡",
"腙": "宗",
"捽": "做",
"礅": "蹲",
"滺": "优",
"竅": "巧",
"捯": "刀",
"崡": "含",
"颥": "如",
"霙": "应",
"茓": "学",
"駄": "驮",
"頰": "夹",
"蔴": "麻",
"窭": "巨",
"燻": "熏",
"鴞": "消",
"锾": "环",
"儞": "你",
"蟊": "毛",
"桫": "缩",
"棿": "尼",
"犮": "拔",
"箢": "冤",
"棧": "战",
"崚": "棱",
"韜": "掏",
"涇": "精",
"贄": "至",
"叄": "参",
"覌": "关",
"鉨": "洗",
"蒇": "铲",
"琀": "含",
"幟": "至",
"澥": "谢",
"鯤": "昆",
"羥": "抢",
"剉": "错",
"餸": "宋",
"螚": "耐",
"幞": "福",
"嗆": "枪",
"剀": "凯",
"簨": "损",
"鎊": "棒",
"嬸": "审",
"衕": "痛",
"偄": "软",
"蚿": "闲",
"蕺": "极",
"曖": "爱",
"紓": "书",
"儚": "盟",
"枵": "消",
"譙": "巧",
"伀": "中",
"囄": "离",
"纙": "落",
"躋": "机",
"鎾": "温",
"渕": "冤",
"幋": "盘",
"揵": "钱",
"躅": "竹",
"莐": "陈",
"溽": "入",
"羝": "低",
"昜": "羊",
"棼": "坟",
"邡": "方",
"鈻": "四",
"竤": "红",
"缫": "骚",
"疍": "蛋",
"掲": "接",
"駙": "父",
"烠": "回",
"埖": "花",
"妡": "心",
"栆": "早",
"怫": "福",
"偾": "愤",
"蘚": "显",
"趱": "赞",
"嫜": "张",
"觋": "习",
"艣": "鲁",
"牋": "间",
"嘍": "楼",
"刿": "贵",
"媿": "溃",
"脠": "山",
"琎": "进",
"婇": "采",
"耩": "讲",
"锖": "枪",
"衳": "中",
"仌": "冰",
"偁": "称",
"鹆": "玉",
"缲": "敲",
"饸": "和",
"勣": "机",
"旛": "翻",
"褀": "其",
"痲": "麻",
"梏": "固",
"禱": "导",
"冑": "昼",
"灉": "庸",
"舗": "瀑",
"嵗": "岁",
"勹": "包",
"犰": "求",
"棻": "分",
"侟": "存",
"塒": "石",
"蛑": "谋",
"嫇": "明",
"爀": "贺",
"屻": "任",
"脕": "万",
"邽": "归",
"镟": "炫",
"炵": "通",
"躶": "裸",
"亖": "四",
"錳": "猛",
"鐾": "被",
"餡": "现",
"笀": "忙",
"鐤": "顶",
"劄": "扎",
"冋": "窘",
"嫋": "尿",
"啁": "招",
"扺": "指",
"玙": "鱼",
"禰": "迷",
"榎": "假",
"夨": "责",
"壒": "爱",
"隂": "因",
"揲": "叠",
"栭": "而",
"苀": "行",
"曚": "盟",
"竝": "病",
"蠋": "竹",
"觎": "鱼",
"怮": "优",
"睱": "下",
"慬": "琴",
"礿": "月",
"楢": "由",
"搌": "展",
"丬": "强",
"駝": "驮",
"徧": "变",
"粞": "西",
"溻": "他",
"俆": "徐",
"濜": "进",
"嵫": "姿",
"颃": "行",
"勩": "意",
"刭": "井",
"锼": "搜",
"脝": "哼",
"鎌": "连",
"慫": "耸",
"叚": "假",
"坲": "佛",
"墍": "系",
"氼": "逆",
"鹮": "环",
"偰": "谢",
"崞": "锅",
"檎": "琴",
"瘜": "西",
"廲": "离",
"毆": "欧",
"洫": "续",
"萏": "蛋",
"棩": "冤",
"崄": "显",
"傈": "利",
"槦": "庸",
"馱": "驮",
"陥": "现",
"庨": "消",
"塝": "棒",
"樿": "善",
"琸": "着",
"瘝": "关",
"龆": "条",
"艟": "冲",
"嗱": "拿",
"顸": "憨",
"蚍": "皮",
"鬈": "全",
"檛": "抓",
"砕": "岁",
"舣": "以",
"趔": "裂",
"谵": "占",
"蚰": "由",
"沺": "田",
"斉": "其",
"烺": "浪",
"勍": "情",
"嶠": "教",
"吙": "霍",
"鰲": "敖",
"竒": "其",
"蠼": "取",
"冃": "帽",
"叾": "了",
"獯": "熏",
"倳": "字",
"脙": "修",
"賁": "必",
"脡": "挺",
"潯": "寻",
"猞": "舍",
"曁": "记",
"黴": "梅",
"勲": "熏",
"咢": "恶",
"顒": "庸",
"朣": "同",
"膂": "旅",
"膿": "农",
"甁": "平",
"湲": "原",
"挒": "裂",
"甶": "福",
"灺": "谢",
"艼": "听",
"侘": "差",
"皢": "小",
"妽": "深",
"笢": "敏",
"戔": "间",
"锃": "赠",
"俵": "标",
"鉬": "木",
"琲": "被",
"蒴": "硕",
"屲": "挖",
"斻": "行",
"掊": "剖",
"悃": "捆",
"儖": "蓝",
"鹚": "瓷",
"奀": "恩",
"佲": "命",
"尜": "嘎",
"菪": "荡",
"蛞": "扩",
"脒": "米",
"氍": "取",
"愯": "耸",
"鳚": "位",
"莰": "砍",
"鰨": "塔",
"杄": "前",
"螣": "特",
"跽": "记",
"嗭": "直",
"仛": "拖",
"戽": "互",
"賄": "会",
"釵": "拆",
"寖": "进",
"橀": "西",
"珃": "染",
"锳": "应",
"諮": "姿",
"卽": "极",
"箏": "睁",
"譏": "机",
"淰": "年",
"珧": "摇",
"涶": "拖",
"魮": "皮",
"脟": "裂",
"毐": "矮",
"蓅": "刘",
"侊": "光",
"畊": "耕",
"廒": "敖",
"亣": "大",
"跢": "堕",
"鏘": "枪",
"厙": "设",
"妋": "夫",
"酤": "姑",
"僬": "教",
"峫": "鞋",
"眰": "叠",
"祄": "谢",
"鈡": "中",
"郿": "梅",
"忞": "民",
"枘": "瑞",
"枼": "夜",
"偒": "躺",
"莀": "陈",
"偊": "雨",
"屸": "龙",
"癔": "意",
"硂": "全",
"錡": "其",
"裰": "多",
"迗": "额",
"铹": "劳",
"埯": "俺",
"唴": "呛",
"畤": "至",
"眳": "明",
"浉": "诗",
"斁": "意",
"鱧": "李",
"黡": "眼",
"癱": "贪",
"轹": "利",
"跸": "必",
"偂": "钱",
"贓": "脏",
"仈": "八",
"暠": "搞",
"壷": "胡",
"撶": "华",
"锓": "寝",
"馇": "插",
"阼": "做",
"譁": "华",
"摅": "书",
"莈": "墨",
"揃": "减",
"脪": "信",
"苈": "利",
"躰": "体",
"労": "劳",
"蟙": "直",
"閹": "烟",
"玊": "速",
"筧": "减",
"怴": "续",
"伖": "躺",
"旼": "民",
"冄": "染",
"崀": "浪",
"檤": "到",
"脭": "成",
"璾": "姿",
"墼": "机",
"惣": "总",
"誾": "银",
"熼": "意",
"馑": "紧",
"掭": "天",
"綮": "起",
"誥": "告",
"亱": "夜",
"舲": "零",
"窰": "摇",
"卲": "绍",
"拶": "匝",
"鑚": "钻",
"礽": "仍",
"湓": "盆",
"訖": "气",
"朿": "次",
"儼": "眼",
"脞": "搓",
"桄": "光",
"帀": "匝",
"鹎": "杯",
"斺": "铲",
"琞": "胜",
"鹇": "闲",
"瘮": "肾",
"赱": "走",
"趯": "替",
"曱": "约",
"綑": "捆",
"燹": "显",
"渖": "审",
"彁": "歌",
"穏": "稳",
"棤": "错",
"鲀": "吞",
"磡": "看",
"逺": "远",
"垙": "光",
"暌": "奎",
"舯": "中",
"莂": "别",
"覀": "西",
"岕": "借",
"渋": "色",
"堎": "愣",
"暎": "硬",
"燁": "夜",
"贳": "是",
"鳢": "李",
"蓳": "紧",
"蚡": "坟",
"秂": "人",
"馘": "国",
"焌": "俊",
"叿": "轰",
"乬": "巨",
"儕": "柴",
"舴": "则",
"杻": "丑",
"鍨": "奎",
"鑴": "西",
"钔": "门",
"髑": "毒",
"伛": "雨",
"璶": "进",
"聩": "溃",
"朲": "人",
"锩": "卷",
"祘": "算",
"栤": "病",
"浕": "进",
"韡": "伟",
"牬": "被",
"濅": "进",
"栴": "占",
"埛": "窘",
"絺": "吃",
"玡": "牙",
"蓆": "习",
"懾": "设",
"淯": "玉",
"摽": "标",
"拠": "巨",
"麪": "面",
"弍": "二",
"剷": "铲",
"牐": "炸",
"榃": "谈",
"糨": "降",
"芐": "互",
"鹪": "教",
"珝": "许",
"纓": "应",
"腘": "国",
"癯": "取",
"紶": "区",
"昺": "饼",
"袞": "滚",
"膞": "专",
"蓊": "瓮",
"洀": "盘",
"撱": "伟",
"垪": "病",
"潽": "铺",
"緢": "描",
"嚆": "蒿",
"黐": "吃",
"氇": "撸",
"嬈": "扰",
"癀": "黄",
"氈": "占",
"儳": "缠",
"菑": "灾",
"偧": "扎",
"炰": "袍",
"佇": "助",
"瞫": "审",
"蛱": "夹",
"赙": "父",
"涖": "利",
"踯": "直",
"镚": "甭",
"廑": "紧",
"蝥": "毛",
"殪": "意",
"殢": "替",
"榱": "催",
"瞹": "爱",
"窞": "蛋",
"澋": "红",
"巯": "求",
"籣": "蓝",
"熴": "昆",
"庯": "不",
"瀣": "谢",
"秏": "号",
"裑": "深",
"镈": "博",
"锫": "培",
"轱": "姑",
"踽": "举",
"囁": "聂",
"蜉": "福",
"撹": "角",
"鏗": "坑",
"墕": "燕",
"碥": "扁",
"脦": "的",
"賧": "探",
"螓": "琴",
"蕻": "红",
"悘": "一",
"囂": "消",
"蔰": "互",
"旇": "批",
"羑": "有",
"祤": "雨",
"腧": "树",
"跘": "盘",
"怱": "聪",
"粛": "速",
"墬": "地",
"鯶": "换",
"繍": "秀",
"麇": "君",
"锿": "哀",
"艨": "盟",
"罝": "居",
"罈": "谈",
"澉": "感",
"凕": "命",
"惓": "全",
"誨": "会",
"岆": "咬",
"踴": "永",
"瘉": "玉",
"瀷": "意",
"憳": "坦",
"啍": "吞",
"忛": "翻",
"揎": "宣",
"詮": "全",
"縯": "眼",
"糰": "团",
"頵": "晕",
"寍": "凝",
"溿": "判",
"鎢": "乌",
"偬": "总",
"茝": "拆",
"皒": "额",
"骵": "体",
"紥": "匝",
"嚄": "霍",
"阬": "坑",
"蛲": "脑",
"幓": "山",
"檸": "凝",
"蟳": "寻",
"樋": "通",
"畎": "犬",
"哖": "年",
"爣": "躺",
"蜊": "离",
"頹": "推",
"陴": "皮",
"櫓": "鲁",
"眙": "宜",
"矞": "玉",
"顱": "芦",
"遯": "顿",
"勧": "劝",
"謚": "是",
"椾": "间",
"甡": "深",
"脜": "有",
"嵝": "楼",
"辋": "网",
"彆": "蹩",
"璣": "机",
"荌": "按",
"腠": "凑",
"莔": "盟",
"樰": "雪",
"襌": "单",
"罥": "倦",
"鵟": "狂",
"緵": "宗",
"璉": "脸",
"蟜": "角",
"釈": "是",
"緞": "断",
"瘵": "寨",
"猋": "标",
"摟": "楼",
"亁": "干",
"坩": "干",
"誡": "借",
"飈": "标",
"嗶": "必",
"擰": "凝",
"劧": "指",
"鰕": "虾",
"蒗": "浪",
"勶": "撤",
"闔": "和",
"菉": "路",
"鑣": "标",
"眕": "枕",
"徠": "来",
"忾": "开",
"噵": "到",
"澂": "成",
"蒄": "关",
"幙": "木",
"牜": "牛",
"蛦": "宜",
"鈷": "古",
"猀": "沙",
"偢": "丑",
"簰": "排",
"瘧": "虐",
"繙": "翻",
"薊": "记",
"偡": "战",
"熥": "腾",
"鹨": "六",
"檺": "搞",
"彛": "宜",
"窀": "准",
"沲": "驮",
"幀": "挣",
"咃": "拖",
"鸀": "楚",
"玗": "鱼",
"礌": "雷",
"訶": "喝",
"甌": "欧",
"饋": "溃",
"嘠": "嘎",
"鼴": "眼",
"淂": "德",
"蓌": "错",
"泦": "局",
"縠": "胡",
"玧": "门",
"恝": "夹",
"筊": "肖",
"潟": "系",
"嫐": "脑",
"餼": "系",
"醑": "许",
"訇": "轰",
"唅": "含",
"鄠": "互",
"檳": "彬",
"渓": "西",
"塭": "温",
"媱": "摇",
"閞": "变",
"鲱": "飞",
"冿": "间",
"褙": "被",
"笵": "饭",
"鉉": "炫",
"掕": "零",
"弇": "眼",
"赑": "必",
"攰": "贵",
"獑": "缠",
"錕": "昆",
"耑": "端",
"茺": "冲",
"楨": "真",
"褁": "果",
"聻": "你",
"訁": "颜",
"佝": "勾",
"緈": "性",
"紱": "福",
"幈": "平",
"咵": "垮",
"覈": "和",
"揶": "爷",
"萢": "抛",
"蕗": "路",
"癃": "龙",
"塲": "长",
"玅": "庙",
"瞶": "贵",
"墚": "良",
"荅": "答",
"揑": "捏",
"鈧": "抗",
"鲦": "条",
"硚": "桥",
"斾": "配",
"浛": "含",
"榍": "谢",
"諳": "安",
"輋": "舍",
"眂": "是",
"鞬": "间",
"漣": "连",
"荬": "买",
"髄": "髓",
"卋": "是",
"汧": "前",
"玍": "尬",
"酴": "图",
"榼": "科",
"刬": "铲",
"瞜": "楼",
"垾": "汉",
"锬": "谈",
"胼": "偏",
"鞲": "勾",
"嵁": "看",
"劏": "汤",
"璢": "刘",
"掓": "书",
"袼": "歌",
"粺": "败",
"驒": "驮",
"燬": "毁",
"焠": "翠",
"蟄": "哲",
"劅": "着",
"疇": "愁",
"偤": "由",
"緥": "宝",
"皛": "小",
"荄": "该",
"娸": "七",
"砫": "助",
"屣": "洗",
"絫": "垒",
"穨": "推",
"緃": "宗",
"銨": "俺",
"厛": "听",
"洑": "福",
"箹": "约",
"蹓": "溜",
"倝": "干",
"瘊": "喉",
"汌": "串",
"懟": "对",
"狳": "鱼",
"鸚": "应",
"泇": "家",
"辮": "变",
"祵": "捆",
"佋": "招",
"狌": "生",
"慜": "敏",
"挱": "撒",
"鑵": "灌",
"瞀": "帽",
"甴": "炸",
"鬏": "纠",
"枻": "意",
"齧": "聂",
"誸": "闲",
"鮰": "回",
"锱": "姿",
"扙": "帐",
"壟": "垄",
"敹": "聊",
"夛": "多",
"豋": "灯",
"楄": "偏",
"帹": "煞",
"鉞": "月",
"莯": "木",
"洓": "色",
"敍": "续",
"鬨": "红",
"藪": "搜",
"幆": "意",
"埡": "呀",
"侞": "如",
"狴": "必",
"蜍": "除",
"鐥": "善",
"讁": "哲",
"蘀": "拓",
"嚶": "应",
"酾": "筛",
"竻": "乐",
"鐓": "对",
"竫": "静",
"覬": "记",
"肀": "玉",
"荖": "老",
"怃": "五",
"渧": "地",
"糬": "鼠",
"靐": "病",
"吲": "引",
"瀟": "消",
"饗": "想",
"纁": "熏",
"巒": "鸾",
"肈": "照",
"饹": "了",
"啀": "埃",
"濰": "维",
"欵": "款",
"葜": "掐",
"椠": "欠",
"恹": "烟",
"亸": "朵",
"荝": "册",
"鍼": "真",
"珛": "秀",
"倢": "节",
"揀": "减",
"跂": "其",
"袑": "绍",
"倓": "谈",
"閙": "闹",
"鱽": "刀",
"絝": "裤",
"檊": "干",
"鼩": "取",
"吀": "灭",
"鱨": "长",
"鉚": "柳",
"禸": "柔",
"掍": "混",
"咹": "恶",
"澴": "环",
"悒": "意",
"貎": "尼",
"坈": "容",
"貽": "宜",
"垯": "哒",
"芼": "帽",
"巉": "缠",
"筢": "爬",
"鞔": "瞒",
"邇": "耳",
"嚙": "聂",
"鄔": "乌",
"玕": "干",
"唦": "沙",
"黹": "指",
"儜": "凝",
"溾": "哀",
"笓": "必",
"瘑": "锅",
"簠": "辅",
"籶": "深",
"痄": "咋",
"憚": "蛋",
"囮": "额",
"躄": "必",
"輓": "碗",
"姽": "鬼",
"傗": "处",
"簩": "劳",
"晸": "整",
"胬": "努",
"姈": "零",
"聹": "凝",
"欷": "西",
"帇": "聂",
"苖": "敌",
"瘅": "单",
"譺": "爱",
"媖": "应",
"顕": "显",
"羖": "古",
"綅": "亲",
"蹰": "除",
"眊": "帽",
"簳": "感",
"粦": "林",
"醵": "巨",
"镎": "拿",
"橈": "扰",
"獀": "搜",
"頷": "汉",
"礫": "利",
"啘": "夜",
"跐": "刺",
"衎": "看",
"柸": "培",
"湚": "印",
"掞": "善",
"肸": "西",
"賑": "镇",
"湣": "敏",
"皊": "零",
"壈": "懒",
"翙": "会",
"匋": "桃",
"暟": "凯",
"辁": "全",
"捑": "责",
"嫄": "原",
"宔": "主",
"岋": "恶",
"逇": "顿",
"兊": "对",
"緌": "瑞",
"耲": "怀",
"铞": "掉",
"聱": "敖",
"飐": "展",
"仹": "风",
"讱": "任",
"昳": "叠",
"臓": "藏",
"謾": "瞒",
"喁": "庸",
"偓": "卧",
"毊": "消",
"甃": "昼",
"飖": "摇",
"鄚": "帽",
"澝": "宁",
"钁": "觉",
"飴": "宜",
"轳": "芦",
"儠": "裂",
"犢": "毒",
"麯": "区",
"皟": "则",
"瓩": "前",
"舨": "板",
"萠": "攀",
"鎔": "容",
"蟪": "会",
"莋": "做",
"姍": "山",
"钂": "躺",
"敔": "雨",
"弙": "乌",
"賶": "仓",
"栿": "福",
"詁": "古",
"鲥": "石",
"燂": "谈",
"胩": "卡",
"檓": "毁",
"厾": "督",
"萻": "安",
"儨": "至",
"鈅": "月",
"稃": "夫",
"簃": "宜",
"楛": "互",
"舢": "山",
"驥": "记",
"芻": "除",
"鍀": "德",
"竮": "平",
"堔": "深",
"鑛": "矿",
"蝻": "男",
"鐙": "凳",
"薆": "爱",
"祦": "无",
"瞤": "润",
"鄗": "号",
"籔": "搜",
"恧": "女",
"皕": "必",
"瀘": "芦",
"釗": "招",
"傒": "西",
"刕": "离",
"軚": "带",
"蟓": "向",
"濩": "或",
"枒": "呀",
"灜": "营",
"蝨": "诗",
"蹻": "绝",
"拃": "眨",
"濓": "连",
"嘡": "汤",
"蹧": "糟",
"奼": "差",
"歛": "憨",
"獺": "塔",
"洜": "落",
"礓": "将",
"倞": "静",
"潏": "玉",
"櫧": "朱",
"梾": "来",
"蚸": "利",
"巘": "眼",
"辵": "绰",
"詇": "样",
"姸": "颜",
"唽": "西",
"覩": "堵",
"鵲": "确",
"侁": "深",
"槗": "桥",
"晙": "俊",
"綯": "桃",
"壴": "助",
"伾": "批",
"儭": "衬",
"壠": "垄",
"塴": "甭",
"鼡": "鼠",
"肭": "那",
"瀍": "缠",
"挌": "格",
"牱": "歌",
"劦": "鞋",
"銫": "色",
"朙": "明",
"耖": "吵",
"妸": "阿",
"觭": "机",
"麤": "粗",
"碞": "颜",
"彔": "路",
"璂": "其",
"氥": "西",
"鑶": "藏",
"侫": "宁",
"禩": "四",
"绖": "叠",
"劂": "觉",
"袆": "灰",
"槚": "假",
"亙": "根",
"菋": "位",
"絪": "因",
"謫": "哲",
"櫟": "利",
"膪": "踹",
"嘫": "然",
"穤": "诺",
"谫": "减",
"餬": "胡",
"晅": "选",
"訢": "心",
"鍢": "父",
"唊": "夹",
"惪": "德",
"仧": "长",
"杧": "忙",
"萳": "男",
"埆": "确",
"蛻": "退",
"楅": "逼",
"髈": "绑",
"楱": "揍",
"朧": "龙",
"鞮": "低",
"狛": "博",
"鐺": "当",
"磞": "砰",
"珨": "侠",
"茤": "记",
"咰": "树",
"欙": "雷",
"帴": "散",
"庳": "必",
"嶏": "配",
"襕": "蓝",
"謌": "歌",
"瀋": "审",
"惗": "聂",
"屚": "漏",
"璈": "敖",
"鉏": "除",
"癬": "选",
"奌": "点",
"荮": "昼",
"鬪": "豆",
"琁": "旋",
"鲻": "姿",
"蟎": "满",
"塙": "确",
"欖": "懒",
"覑": "偏",
"疰": "助",
"瑉": "民",
"朅": "妾",
"枂": "卧",
"蔹": "脸",
"騫": "前",
"檙": "成",
"蕐": "华",
"卺": "紧",
"珴": "额",
"寜": "凝",
"牤": "忙",
"鈐": "钱",
"搨": "踏",
"偝": "被",
"釒": "金",
"劁": "敲",
"璥": "井",
"竾": "持",
"娰": "四",
"軼": "意",
"奓": "扎",
"纍": "雷",
"莮": "南",
"鲣": "间",
"鹁": "博",
"傺": "赤",
"莢": "夹",
"聟": "续",
"仐": "三",
"羕": "样",
"潾": "林",
"謡": "摇",
"吅": "宣",
"倷": "奶",
"迀": "干",
"嫺": "闲",
"堬": "鱼",
"掔": "前",
"蕥": "哑",
"蕎": "桥",
"絙": "环",
"滹": "呼",
"毹": "书",
"惛": "昏",
"逬": "甭",
"愨": "确",
"鶇": "东",
"滠": "设",
"罺": "朝",
"紸": "助",
"胠": "区",
"悇": "图",
"葰": "虽",
"欓": "挡",
"驵": "脏",
"嫪": "烙",
"翃": "红",
"鯽": "贼",
"伓": "批",
"寀": "采",
"揠": "亚",
"脮": "内",
"齮": "以",
"緾": "缠",
"忭": "变",
"棶": "来",
"闁": "包",
"聾": "龙",
"轷": "呼",
"礀": "见",
"斱": "着",
"邏": "罗",
"賸": "胜",
"烴": "听",
"謕": "提",
"棐": "匪",
"廆": "归",
"痳": "林",
"憡": "册",
"乁": "宜",
"萇": "长",
"嵎": "鱼",
"綪": "欠",
"軛": "恶",
"粠": "红",
"羼": "颤",
"痦": "物",
"蟴": "思",
"淃": "倦",
"檒": "风",
"蔀": "不",
"嚸": "点",
"偑": "风",
"鲙": "快",
"傉": "怒",
"纞": "练",
"洚": "降",
"堦": "接",
"驋": "波",
"瓌": "归",
"髎": "聊",
"縴": "欠",
"紈": "完",
"挗": "觉",
"唍": "碗",
"襬": "摆",
"醸": "娘",
"漀": "请",
"祊": "崩",
"礳": "墨",
"鬢": "宾",
"簑": "缩",
"灋": "法",
"扂": "电",
"覷": "去",
"鮃": "平",
"儣": "旷",
"儻": "躺",
"滉": "荒",
"铏": "行",
"蒺": "极",
"啋": "采",
"嬡": "爱",
"錵": "花",
"嚨": "龙",
"扡": "拖",
"譟": "造",
"悧": "利",
"馫": "心",
"彶": "极",
"鲼": "愤",
"瘼": "墨",
"螬": "曹",
"絾": "成",
"餚": "摇",
"轅": "原",
"崯": "银",
"崕": "牙",
"羋": "米",
"捥": "万",
"唢": "锁",
"螵": "飘",
"蹀": "叠",
"莬": "问",
"婗": "尼",
"摢": "互",
"秖": "知",
"胲": "海",
"葇": "柔",
"綷": "翠",
"珗": "先",
"縂": "总",
"錒": "科",
"蔌": "速",
"輦": "年",
"媃": "柔",
"繎": "然",
"饌": "赚",
"糹": "思",
"秠": "批",
"躪": "吝",
"觧": "解",
"潁": "影",
"鼽": "求",
"柾": "就",
"鲐": "台",
"鄫": "增",
"吘": "偶",
"鎓": "瓮",
"磜": "气",
"罽": "记",
"糇": "喉",
"伹": "区",
"慇": "因",
"婞": "性",
"圕": "图",
"珋": "柳",
"簺": "赛",
"梼": "桃",
"鋤": "除",
"柅": "你",
"覦": "鱼",
"乧": "抖",
"壢": "利",
"驃": "标",
"啯": "锅",
"嵨": "物",
"蹠": "直",
"瘯": "促",
"仸": "咬",
"臑": "闹",
"愝": "眼",
"钸": "不",
"姁": "许",
"穠": "农",
"袊": "领",
"謘": "持",
"敱": "埃",
"蓧": "掉",
"洖": "无",
"嬤": "妈",
"鈽": "不",
"瞍": "搜",
"徬": "旁",
"儎": "在",
"唣": "造",
"曢": "了",
"毞": "皮",
"鏞": "庸",
"鼔": "古",
"蒡": "棒",
"枟": "运",
"賨": "从",
"簕": "乐",
"稈": "感",
"湑": "需",
"楙": "帽",
"唞": "抖",
"紦": "八",
"膾": "快",
"閟": "必",
"邉": "编",
"洯": "妾",
"裛": "意",
"鍌": "显",
"籥": "月",
"歓": "欢",
"衊": "灭",
"摱": "慢",
"琋": "西",
"旣": "记",
"睒": "闪",
"翫": "完",
"貰": "是",
"懮": "有",
"岞": "做",
"輟": "绰",
"嗏": "插",
"茇": "拔",
"仚": "先",
"姇": "夫",
"琩": "昌",
"卹": "续",
"偱": "寻",
"筳": "停",
"硓": "老",
"堌": "固",
"垬": "红",
"骒": "客",
"妭": "拔",
"凎": "干",
"橎": "烦",
"粶": "路",
"鞚": "控",
"潕": "五",
"垇": "奥",
"尰": "种",
"蔮": "国",
"燾": "到",
"猄": "精",
"幪": "盟",
"凔": "创",
"畯": "俊",
"紭": "红",
"嬾": "懒",
"垻": "爸",
"殹": "意",
"襛": "农",
"蓣": "玉",
"牿": "固",
"昫": "续",
"廌": "至",
"秈": "先",
"唚": "亲",
"銖": "朱",
"傦": "古",
"潩": "意",
"穉": "至",
"躐": "裂",
"腍": "任",
"帍": "互",
"赇": "求",
"舃": "系",
"曕": "燕",
"犏": "偏",
"緖": "续",
"鍎": "图",
"纻": "助",
"虒": "思",
"瘌": "蜡",
"訚": "银",
"杬": "原",
"蕰": "温",
"樉": "双",
"鏻": "林",
"夆": "逢",
"盨": "许",
"搆": "够",
"怩": "尼",
"偟": "黄",
"嘸": "辅",
"暏": "鼠",
"劻": "框",
"媤": "思",
"瀏": "刘",
"幗": "国",
"洝": "按",
"瑒": "唱",
"垞": "茶",
"禋": "因",
"絔": "摆",
"耵": "丁",
"縊": "意",
"埶": "意",
"鈸": "博",
"閆": "颜",
"曺": "曹",
"孿": "鸾",
"墈": "看",
"筥": "举",
"磉": "桑",
"暚": "摇",
"卄": "念",
"仯": "吵",
"羴": "山",
"萺": "帽",
"縈": "营",
"狝": "显",
"憝": "对",
"洢": "一",
"綻": "战",
"篚": "匪",
"纩": "矿",
"酈": "利",
"秷": "至",
"乿": "至",
"蠪": "龙",
"潚": "速",
"驩": "欢",
"旈": "刘",
"搷": "田",
"冱": "互",
"誫": "镇",
"圞": "鸾",
"瑈": "柔",
"拫": "很",
"垝": "鬼",
"淉": "果",
"悰": "从",
"饞": "缠",
"掎": "几",
"灪": "玉",
"鲚": "记",
"杋": "烦",
"僊": "先",
"峧": "教",
"嵙": "科",
"厖": "旁",
"坣": "唐",
"悜": "成",
"蝧": "应",
"祃": "骂",
"窣": "苏",
"婥": "闹",
"闌": "蓝",
"俫": "来",
"黩": "毒",
"櫶": "显",
"乆": "久",
"韘": "设",
"眍": "口",
"珎": "真",
"勊": "客",
"擭": "卧",
"荈": "喘",
"蕑": "间",
"倀": "昌",
"鄀": "弱",
"郪": "七",
"炑": "木",
"浽": "虽",
"丵": "着",
"媏": "端",
"漖": "教",
"兏": "长",
"鰺": "深",
"屝": "费",
"敮": "侠",
"穣": "嚷",
"偙": "地",
"璆": "求",
"苝": "被",
"縞": "搞",
"灃": "风",
"韮": "久",
"讃": "赞",
"颩": "标",
"鲴": "固",
"秪": "知",
"崌": "居",
"坬": "挂",
"銼": "错",
"忥": "系",
"菛": "门",
"缊": "晕",
"筚": "必",
"轆": "路",
"秞": "由",
"笘": "山",
"釹": "女",
"姴": "裂",
"姱": "夸",
"鎿": "拿",
"燜": "闷",
"茖": "格",
"覲": "进",
"瑅": "提",
"鄜": "夫",
"綃": "消",
"嵂": "绿",
"朓": "挑",
"瘽": "琴",
"枔": "信",
"愶": "鞋",
"籏": "其",
"珄": "生",
"綖": "颜",
"韌": "任",
"枙": "饿",
"苭": "咬",
"餃": "角",
"褢": "怀",
"漨": "逢",
"炌": "开",
"赿": "持",
"圀": "国",
"聺": "茄",
"觖": "觉",
"熒": "营",
"宑": "井",
"嘼": "处",
"侚": "训",
"鮠": "维",
"棌": "菜",
"攣": "鸾",
"粅": "物",
"頞": "恶",
"錀": "伦",
"邚": "如",
"佂": "睁",
"艌": "念",
"妠": "那",
"貙": "出",
"驪": "离",
"疬": "利",
"燼": "进",
"埫": "宠",
"圴": "着",
"炩": "另",
"仒": "冰",
"嫙": "旋",
"觃": "燕",
"鳮": "机",
"燋": "教",
"憇": "气",
"茀": "福",
"嘙": "婆",
"哳": "扎",
"喥": "夺",
"鴇": "宝",
"颋": "挺",
"櫌": "优",
"鵠": "胡",
"姃": "睁",
"羓": "八",
"儐": "彬",
"釿": "金",
"堚": "魂",
"惔": "谈",
"慚": "残",
"寚": "宝",
"臯": "高",
"龗": "零",
"裀": "因",
"橞": "会",
"訝": "亚",
"爍": "硕",
"捃": "俊",
"殽": "肖",
"澱": "电",
"堽": "刚",
"哃": "同",
"浡": "博",
"蝭": "提",
"濏": "色",
"蒱": "葡",
"炶": "闪",
"蝤": "求",
"艅": "鱼",
"鮀": "驮",
"媜": "睁",
"苩": "博",
"鏑": "敌",
"眔": "大",
"羶": "山",
"渁": "冤",
"韁": "将",
"菝": "拔",
"溡": "石",
"晛": "现",
"栳": "老",
"敺": "区",
"楋": "蜡",
"徯": "西",
"緟": "虫",
"朥": "劳",
"閡": "爱",
"晣": "哲",
"踺": "见",
"桭": "真",
"鲺": "诗",
"溋": "营",
"姙": "任",
"犂": "离",
"葎": "绿",
"籾": "尼",
"猸": "梅",
"颟": "慢",
"娖": "绰",
"魜": "人",
"嘮": "劳",
"俁": "雨",
"諗": "审",
"殍": "漂",
"靦": "舔",
"堉": "玉",
"嫈": "应",
"檝": "极",
"寑": "寝",
"珌": "必",
"琹": "琴",
"裈": "昆",
"溘": "客",
"鐲": "着",
"偋": "病",
"尞": "料",
"鱺": "离",
"枹": "包",
"殭": "将",
"裵": "培",
"虍": "呼",
"弸": "朋",
"諺": "燕",
"讒": "缠",
"砞": "墨",
"魴": "房",
"峴": "现",
"儬": "庆",
"玨": "觉",
"炟": "达",
"臔": "现",
"嶧": "意",
"靄": "矮",
"鋐": "红",
"壙": "矿",
"瞷": "见",
"哯": "现",
"稆": "旅",
"虯": "求",
"鷇": "扣",
"鈿": "田",
"斈": "学",
"槡": "丧",
"偔": "恶",
"瑝": "黄",
"卾": "恶",
"姖": "巨",
"苪": "饼",
"坮": "台",
"鏜": "汤",
"粰": "福",
"睪": "意",
"鈭": "姿",
"羆": "皮",
"嫭": "互",
"葁": "将",
"伩": "信",
"苮": "先",
"鄕": "相",
"猇": "消",
"芺": "袄",
"皀": "极",
"齦": "肯",
"筴": "册",
"懽": "欢",
"梠": "旅",
"棈": "欠",
"懺": "颤",
"妏": "问",
"喦": "聂",
"舦": "太",
"爜": "从",
"鈇": "夫",
"廩": "吝",
"蝸": "窝",
"阩": "生",
"滳": "伤",
"驡": "龙",
"筁": "区",
"皐": "高",
"挍": "教",
"篺": "皮",
"絬": "谢",
"姛": "动",
"葷": "昏",
"祹": "桃",
"攷": "考",
"藺": "吝",
"彨": "吃",
"筎": "如",
"婏": "饭",
"澁": "色",
"晻": "按",
"慡": "双",
"溞": "骚",
"拑": "钱",
"釁": "信",
"暔": "南",
"膄": "瘦",
"曄": "夜",
"糢": "魔",
"飭": "赤",
"弌": "一",
"犋": "巨",
"詪": "很",
"朢": "忘",
"敭": "羊",
"榦": "干",
"寕": "凝",
"鈤": "日",
"鱲": "裂",
"瞵": "林",
"憫": "敏",
"聛": "比",
"睘": "穷",
"眅": "攀",
"薗": "原",
"芚": "吞",
"驫": "标",
"畐": "福",
"朏": "匪",
"鲹": "深",
"栻": "是",
"鼯": "无",
"疭": "宗",
"賥": "岁",
"蟞": "憋",
"嘰": "机",
"犾": "银",
"緆": "西",
"嘔": "偶",
"窸": "西",
"鹓": "冤",
"驤": "相",
"姎": "养",
"聍": "凝",
"櫂": "照",
"嫽": "聊",
"醤": "降",
"嶸": "容",
"曵": "夜",
"辚": "林",
"潪": "这",
"牾": "五",
"儗": "你",
"蕡": "坟",
"煠": "炸",
"嚦": "利",
"哊": "右",
"罙": "深",
"勑": "赤",
"阯": "指",
"沷": "发",
"剻": "捧",
"葽": "邀",
"唪": "奉",
"儰": "伟",
"倧": "宗",
"釩": "反",
"魕": "几",
"玭": "贫",
"絘": "次",
"塥": "格",
"棫": "玉",
"鉾": "谋",
"鱔": "善",
"棸": "邹",
"錬": "练",
"巌": "颜",
"蓺": "意",
"羭": "鱼",
"抇": "胡",
"撖": "汉",
"纴": "任",
"暅": "更",
"迚": "达",
"铔": "呀",
"栵": "裂",
"盺": "心",
"綢": "愁",
"慥": "造",
"孭": "灭",
"鸛": "灌",
"摑": "乖",
"輜": "姿",
"厰": "场",
"僣": "铁",
"焄": "熏",
"幖": "标",
"蚦": "然",
"皁": "造",
"帓": "墨",
"驎": "林",
"鴒": "零",
"奡": "奥",
"怊": "超",
"鼷": "西",
"魘": "眼",
"昪": "变",
"湸": "亮",
"鸻": "横",
"掻": "骚",
"霽": "记",
"敩": "笑",
"瘨": "颠",
"骃": "因",
"倰": "愣",
"緳": "鞋",
"疌": "节",
"貮": "二",
"蝟": "位",
"澛": "鲁",
"妴": "院",
"屃": "系",
"厐": "旁",
"柤": "扎",
"玓": "地",
"詬": "够",
"邤": "心",
"侂": "拖",
"蘂": "瑞",
"疂": "叠",
"呧": "底",
"遶": "绕",
"倅": "翠",
"楪": "夜",
"臚": "芦",
"紪": "七",
"舭": "比",
"囸": "日",
"竡": "摆",
"蓂": "明",
"巇": "西",
"筦": "管",
"隄": "低",
"厯": "利",
"桊": "倦",
"紞": "胆",
"杇": "乌",
"弜": "降",
"殞": "允",
"哱": "波",
"縥": "枕",
"喓": "邀",
"庛": "次",
"篸": "惨",
"誧": "不",
"苶": "捏",
"裇": "需",
"痃": "旋",
"糥": "诺",
"毦": "耳",
"溚": "塔",
"泲": "几",
"琺": "发",
"矟": "硕",
"彇": "消",
"緲": "秒",
"澬": "姿",
"柦": "蛋",
"鷸": "玉",
"軆": "体",
"摛": "吃",
"牎": "窗",
"偐": "燕",
"蒈": "凯",
"胕": "辅",
"旪": "鞋",
"欬": "开",
"畻": "成",
"簊": "机",
"塽": "双",
"凨": "风",
"牘": "毒",
"唖": "哑",
"禵": "提",
"墺": "奥",
"藌": "密",
"髫": "条",
"噏": "西",
"扖": "入",
"鹖": "和",
"幎": "密",
"柺": "拐",
"唃": "古",
"駮": "博",
"暪": "闷",
"奻": "暖",
"徦": "假",
"狘": "血",
"閠": "润",
"褆": "提",
"瘖": "因",
"妬": "度",
"霫": "习",
"埅": "房",
"倐": "书",
"阽": "电",
"敾": "善",
"覠": "君",
"攲": "七",
"噚": "寻",
"湥": "突",
"阧": "抖",
"筭": "算",
"鹋": "描",
"耠": "霍",
"湶": "全",
"呫": "贴",
"痋": "腾",
"燴": "会",
"觢": "是",
"裊": "尿",
"璱": "色",
"砮": "努",
"洊": "见",
"掗": "亚",
"槇": "颠",
"赪": "称",
"馂": "俊",
"畵": "话",
"粔": "巨",
"渏": "一",
"癟": "别",
"钘": "行",
"鷍": "消",
"騁": "成",
"螗": "唐",
"惲": "运",
"皝": "荒",
"亴": "右",
"銬": "烤",
"沝": "缀",
"彉": "锅",
"莙": "君",
"艴": "福",
"籘": "腾",
"珒": "金",
"僆": "练",
"紩": "至",
"詫": "差",
"痙": "静",
"糀": "花",
"昄": "板",
"鮁": "波",
"遈": "石",
"沇": "眼",
"襖": "袄",
"鄖": "云",
"餽": "溃",
"崢": "睁",
"姠": "向",
"蒾": "迷",
"遹": "玉",
"衼": "知",
"鲒": "节",
"稙": "知",
"窾": "款",
"莦": "烧",
"柉": "烦",
"廍": "不",
"嫤": "紧",
"瓀": "软",
"巟": "荒",
"汣": "久",
"砆": "夫",
"鄘": "庸",
"獙": "必",
"蚮": "带",
"痖": "哑",
"頡": "鞋",
"餴": "分",
"狉": "批",
"紟": "金",
"儊": "处",
"捚": "摘",
"薺": "记",
"抲": "喝",
"脃": "翠",
"瞙": "墨",
"讖": "衬",
"晹": "意",
"姢": "捐",
"閎": "红",
"櫼": "间",
"瞐": "墨",
"弽": "设",
"唗": "兜",
"唓": "车",
"髖": "宽",
"褝": "单",
"蔄": "慢",
"鎘": "利",
"抰": "养",
"抷": "批",
"鳆": "父",
"餔": "不",
"謟": "掏",
"櫎": "谎",
"汖": "聘",
"縉": "进",
"歀": "款",
"踭": "睁",
"睙": "裂",
"簵": "路",
"鯡": "费",
"躾": "美",
"渙": "换",
"婻": "难",
"弻": "必",
"鼈": "憋",
"綰": "碗",
"釭": "刚",
"刧": "节",
"潡": "顿",
"擓": "快",
"瀼": "嚷",
"烚": "侠",
"炐": "胖",
"垶": "星",
"亹": "伟",
"鴅": "欢",
"襶": "带",
"犪": "奎",
"癩": "赖",
"刄": "任",
"佮": "格",
"戉": "月",
"褖": "团",
"蹺": "敲",
"繻": "需",
"暋": "敏",
"玂": "其",
"鯧": "昌",
"盵": "气",
"贔": "必",
"嚗": "博",
"簀": "则",
"曪": "裸",
"狋": "宜",
"嫹": "描",
"偛": "插",
"嫨": "憨",
"衱": "节",
"纀": "葡",
"丏": "免",
"銏": "善",
"蔦": "尿",
"酂": "搓",
"梜": "家",
"睎": "西",
"礛": "间",
"賔": "彬",
"鯔": "姿",
"挷": "朋",
"辀": "周",
"咅": "剖",
"丠": "秋",
"伃": "鱼",
"翣": "煞",
"泃": "居",
"繀": "岁",
"掜": "意",
"铻": "无",
"颺": "羊",
"潙": "维",
"昽": "龙",
"蕅": "偶",
"鑪": "芦",
"躭": "单",
"骹": "敲",
"眹": "镇",
"厼": "耳",
"蘫": "汉",
"顥": "号",
"栁": "柳",
"屟": "谢",
"眴": "炫",
"紂": "昼",
"鲃": "八",
"泿": "银",
"縝": "陈",
"蒎": "派",
"勠": "路",
"潄": "树",
"煬": "羊",
"奍": "圈",
"搲": "挖",
"臍": "其",
"濶": "扩",
"痷": "安",
"辿": "搀",
"涬": "性",
"渷": "眼",
"搣": "灭",
"杮": "费",
"踇": "母",
"繊": "先",
"鍕": "君",
"淓": "方",
"鸰": "零",
"蒍": "伟",
"琗": "色",
"瀽": "减",
"暣": "气",
"嫆": "容",
"鐚": "呀",
"鴛": "冤",
"杙": "意",
"巺": "训",
"鲕": "而",
"陁": "驮",
"烸": "海",
"薁": "玉",
"捊": "剖",
"蒞": "利",
"掋": "底",
"瀁": "样",
"碏": "确",
"澇": "烙",
"嚿": "或",
"癈": "费",
"衴": "胆",
"鹟": "瓮",
"騑": "飞",
"蔲": "扣",
"醨": "离",
"潬": "善",
"鐳": "雷",
"麑": "尼",
"鬽": "妹",
"婍": "起",
"廼": "奶",
"鬭": "豆",
"塹": "欠",
"鹀": "无",
"縵": "慢",
"赆": "进",
"喯": "喷",
"咡": "二",
"廄": "就",
"軔": "任",
"袃": "拆",
"籟": "赖",
"琿": "魂",
"倗": "朋",
"櫄": "春",
"硈": "恰",
"挃": "至",
"弶": "降",
"禔": "知",
"輾": "展",
"肶": "皮",
"侌": "因",
"箙": "福",
"錛": "奔",
"苽": "姑",
"倁": "知",
"琠": "舔",
"洃": "灰",
"硄": "框",
"詟": "哲",
"蝓": "鱼",
"溍": "进",
"堊": "恶",
"蘘": "嚷",
"秺": "度",
"槅": "格",
"叜": "搜",
"靣": "面",
"赻": "显",
"蔶": "则",
"瘺": "漏",
"晽": "林",
"綆": "梗",
"謢": "撸",
"僢": "喘",
"昋": "贵",
"婌": "熟",
"謐": "密",
"嬋": "缠",
"唲": "而",
"鑊": "或",
"粖": "墨",
"餾": "六",
"楉": "弱",
"櫨": "芦",
"悵": "唱",
"倕": "垂",
"棽": "深",
"蝝": "原",
"釬": "汉",
"盁": "营",
"笶": "使",
"廡": "五",
"鰩": "摇",
"嚞": "哲",
"桻": "风",
"緗": "相",
"斲": "着",
"謋": "或",
"譞": "宣",
"恇": "框",
"畞": "母",
"瀆": "毒",
"巆": "容",
"漧": "干",
"鵑": "捐",
"窛": "扣",
"竪": "树",
"硙": "维",
"飝": "飞",
"釧": "串",
"壵": "壮",
"纘": "钻",
"簭": "是",
"憙": "西",
"晲": "你",
"蝣": "由",
"掆": "刚",
"磘": "摇",
"鐔": "信",
"騏": "其",
"巠": "精",
"藠": "教",
"膋": "聊",
"抅": "居",
"黢": "区",
"殮": "练",
"曀": "意",
"墫": "尊",
"殩": "窜",
"宆": "穷",
"琓": "完",
"櫤": "降",
"蔯": "陈",
"薀": "运",
"睆": "换",
"轡": "配",
"匼": "科",
"樷": "从",
"煿": "博",
"洘": "考",
"祏": "石",
"皦": "角",
"阷": "称",
"鋳": "助",
"詡": "许",
"贍": "善",
"锽": "黄",
"龥": "玉",
"唒": "求",
"悾": "空",
"嵥": "节",
"迆": "宜",
"秴": "和",
"瑍": "换",
"煐": "应",
"惂": "砍",
"蓀": "孙",
"娤": "装",
"脎": "萨",
"皥": "号",
"箰": "损",
"儢": "旅",
"爝": "觉",
"瓟": "博",
"俛": "辅",
"腨": "涮",
"硑": "砰",
"窅": "咬",
"篭": "龙",
"褦": "耐",
"楒": "思",
"翯": "贺",
"饃": "魔",
"榠": "明",
"黓": "意",
"笖": "以",
"蜑": "蛋",
"熲": "窘",
"鮱": "老",
"抪": "不",
"糌": "赞",
"箠": "垂",
"牗": "有",
"縹": "漂",
"嘜": "骂",
"鶸": "弱",
"詓": "曲",
"棑": "排",
"橢": "妥",
"眗": "居",
"炣": "可",
"蓰": "洗",
"繄": "一",
"晵": "起",
"嵆": "机",
"菻": "吝",
"軫": "枕",
"餹": "唐",
"徍": "网",
"刼": "节",
"豷": "意",
"紇": "和",
"蒻": "弱",
"賡": "耕",
"鳪": "哺",
"澣": "换",
"妼": "必",
"楬": "节",
"袕": "学",
"裯": "愁",
"敼": "以",
"柷": "处",
"鑀": "爱",
"湭": "求",
"擩": "乳",
"鴈": "燕",
"苰": "红",
"喌": "周",
"軻": "科",
"鯓": "深",
"撔": "红",
"闉": "因",
"浵": "同",
"摂": "设",
"緘": "间",
"溁": "营",
"軦": "矿",
"湋": "维",
"鶚": "恶",
"蜣": "枪",
"峘": "环",
"嘦": "教",
"絣": "崩",
"銙": "垮",
"丂": "考",
"朷": "刀",
"撾": "窝",
"垏": "绿",
"銻": "提",
"獥": "教",
"惉": "占",
"廕": "印",
"烱": "窘",
"泴": "灌",
"噰": "庸",
"擷": "鞋",
"挴": "美",
"囻": "国",
"厎": "底",
"瑳": "搓",
"盻": "系",
"垰": "卡",
"劚": "竹",
"俙": "西",
"勷": "嚷",
"礚": "科",
"蘗": "薄",
"淢": "玉",
"焮": "信",
"娮": "颜",
"鍺": "朵",
"匄": "概",
"匽": "眼",
"鉍": "必",
"聦": "聪",
"埳": "砍",
"頫": "辅",
"呅": "梅",
"呏": "生",
"溸": "速",
"噝": "思",
"惝": "场",
"搢": "进",
"骕": "速",
"窊": "挖",
"銥": "一",
"阢": "物",
"撗": "逛",
"鎱": "原",
"槺": "康",
"翺": "敖",
"鲌": "爸",
"粯": "现",
"亷": "连",
"骍": "星",
"奣": "瓮",
"騧": "瓜",
"箘": "俊",
"訕": "善",
"唝": "共",
"薳": "伟",
"厽": "垒",
"墽": "敲",
"侢": "带",
"娒": "梅",
"癘": "利",
"頴": "影",
"諴": "闲",
"瀯": "营",
"聨": "连",
"鉱": "矿",
"蘺": "离",
"鮓": "眨",
"蒓": "纯",
"燏": "玉",
"瓛": "环",
"遆": "提",
"矷": "子",
"殣": "进",
"剅": "楼",
"敳": "埃",
"粙": "昼",
"畱": "刘",
"釷": "土",
"麅": "袍",
"觝": "底",
"謗": "棒",
"凲": "干",
"嚰": "魔",
"惈": "果",
"撣": "胆",
"焢": "轰",
"藞": "啦",
"擫": "夜",
"賚": "赖",
"鯙": "纯",
"躉": "蹲",
"姅": "办",
"爼": "组",
"惤": "间",
"圵": "荡",
"葂": "免",
"羛": "意",
"柈": "办",
"敧": "机",
"篜": "睁",
"鯷": "提",
"臸": "知",
"筩": "同",
"氂": "毛",
"騮": "刘",
"歞": "恶",
"孅": "前",
"纒": "缠",
"劐": "霍",
"啣": "闲",
"偞": "谢",
"欥": "意",
"昻": "昂",
"琂": "颜",
"邘": "鱼",
"瓅": "利",
"諠": "宣",
"迋": "忘",
"欱": "喝",
"侹": "挺",
"棪": "眼",
"乢": "概",
"筬": "成",
"喅": "玉",
"礞": "盟",
"盿": "民",
"獟": "要",
"遡": "速",
"弪": "静",
"槪": "概",
"傪": "参",
"鴝": "取",
"刲": "亏",
"狥": "训",
"摡": "概",
"挓": "扎",
"瑮": "利",
"聝": "国",
"瓲": "哇",
"詀": "占",
"滽": "庸",
"鋇": "被",
"儅": "荡",
"獏": "墨",
"硿": "空",
"咍": "孩",
"謿": "朝",
"犅": "刚",
"蹌": "枪",
"铇": "报",
"戤": "概",
"廰": "听",
"謅": "周",
"豄": "毒",
"簹": "当",
"摷": "角",
"栃": "利",
"蟫": "银",
"迖": "达",
"羃": "密",
"籇": "豪",
"鼇": "敖",
"媷": "入",
"罿": "冲",
"糡": "降",
"扐": "乐",
"齶": "恶",
"閼": "恶",
"邲": "必",
"膬": "翠",
"栂": "梅",
"讎": "愁",
"掅": "庆",
"杽": "丑",
"砢": "科",
"暒": "情",
"慼": "七",
"摶": "团",
"锠": "昌",
"僇": "路",
"缾": "平",
"铦": "先",
"禫": "蛋",
"詎": "巨",
"笩": "罚",
"湩": "动",
"廘": "路",
"泂": "窘",
"鴷": "裂",
"駟": "四",
"醡": "咋",
"薔": "强",
"舩": "传",
"膕": "国",
"焔": "燕",
"鲰": "邹",
"繬": "色",
"璫": "当",
"蹍": "年",
"櫥": "除",
"狢": "和",
"錞": "纯",
"筈": "扩",
"璹": "熟",
"踼": "唐",
"魊": "玉",
"抃": "变",
"癹": "拔",
"穓": "意",
"魎": "两",
"崠": "东",
"擿": "踢",
"葢": "概",
"佒": "养",
"秨": "做",
"腃": "溃",
"筣": "离",
"鈀": "靶",
"禗": "思",
"嫿": "话",
"諶": "陈",
"歠": "绰",
"鐟": "赞",
"駢": "偏",
"鐕": "赞",
"夀": "瘦",
"蜾": "果",
"唙": "敌",
"挐": "拿",
"雰": "分",
"蹾": "蹲",
"鏤": "漏",
"酖": "镇",
"剳": "达",
"鴟": "吃",
"鉭": "坦",
"鳘": "敏",
"噀": "训",
"愺": "草",
"諟": "是",
"坰": "窘",
"摣": "扎",
"煚": "窘",
"櫲": "玉",
"椆": "愁",
"筿": "小",
"魆": "需",
"綇": "修",
"宼": "扣",
"祡": "柴",
"俻": "被",
"螋": "搜",
"鳣": "占",
"繛": "绰",
"猙": "睁",
"眎": "是",
"穘": "消",
"菢": "报",
"荙": "达",
"辒": "温",
"譎": "觉",
"矦": "喉",
"縋": "缀",
"旓": "烧",
"盢": "续",
"榞": "原",
"瀀": "优",
"躡": "聂",
"穋": "路",
"屇": "田",
"墰": "谈",
"浭": "耕",
"鉸": "角",
"奤": "哈",
"嶲": "西",
"椑": "杯",
"擧": "举",
"碡": "毒",
"耤": "极",
"剕": "费",
"妶": "闲",
"觤": "鬼",
"滧": "摇",
"朤": "浪",
"銣": "如",
"鯱": "虎",
"厡": "原",
"嗼": "墨",
"簣": "溃",
"鍫": "敲",
"俥": "车",
"唼": "煞",
"溂": "蜡",
"篋": "妾",
"蟌": "聪",
"匸": "系",
"瑸": "彬",
"喼": "接",
"勗": "续",
"唜": "墨",
"陑": "而",
"赼": "姿",
"獰": "凝",
"椪": "碰",
"敇": "册",
"萡": "波",
"蠎": "忙",
"狖": "右",
"緔": "上",
"毉": "一",
"鎣": "营",
"谸": "前",
"娧": "退",
"芉": "干",
"瑔": "全",
"鱟": "后",
"聑": "贴",
"縺": "连",
"慤": "确",
"嗢": "袜",
"豲": "环",
"蔿": "伟",
"襷": "举",
"楤": "耸",
"朒": "女",
"饅": "瞒",
"麕": "君",
"骯": "肮",
"仭": "任",
"飠": "石",
"襜": "搀",
"瑎": "鞋",
"弬": "宜",
"嵒": "颜",
"聵": "溃",
"蘤": "花",
"奐": "换",
"槢": "习",
"飬": "倦",
"蟣": "几",
"鰧": "腾",
"澏": "含",
"礬": "烦",
"抳": "你",
"皃": "帽",
"剗": "铲",
"兠": "兜",
"俤": "地",
"嫗": "玉",
"冁": "铲",
"葒": "红",
"凩": "木",
"廮": "影",
"莑": "朋",
"緤": "谢",
"晠": "胜",
"噣": "昼",
"銲": "汉",
"喛": "换",
"漷": "火",
"碕": "其",
"愙": "客",
"萉": "费",
"啇": "地",
"挀": "掰",
"戇": "壮",
"殯": "宾",
"篥": "利",
"壌": "嚷",
"鞪": "木",
"觔": "金",
"礐": "确",
"糵": "聂",
"犨": "抽",
"噛": "聂",
"闋": "确",
"鳉": "将",
"癵": "鸾",
"愼": "肾",
"萿": "扩",
"猃": "显",
"傃": "速",
"矖": "洗",
"珖": "光",
"劋": "角",
"鉲": "卡",
"苃": "有",
"狪": "同",
"跔": "居",
"眮": "同",
"禆": "必",
"硾": "缀",
"枩": "松",
"牳": "母",
"籮": "罗",
"疈": "屁",
"鏐": "刘",
"晿": "昌",
"嘇": "山",
"赽": "觉",
"瑊": "间",
"侒": "安",
"轂": "古",
"洔": "指",
"璊": "门",
"鹢": "意",
"蓶": "维",
"揜": "眼",
"鈮": "你",
"靷": "引",
"脻": "接",
"阨": "恶",
"冾": "恰",
"懡": "抹",
"淲": "标",
"砯": "平",
"葻": "蓝",
"滒": "歌",
"砐": "恶",
"疐": "至",
"顰": "贫",
"昅": "节",
"鲗": "贼",
"兟": "深",
"獁": "骂",
"艎": "黄",
"瀺": "缠",
"冘": "银",
"勥": "降",
"倠": "虽",
"躞": "谢",
"摐": "窗",
"熇": "贺",
"脴": "匹",
"鈩": "芦",
"蹯": "烦",
"圡": "土",
"飔": "思",
"桟": "战",
"籙": "路",
"祴": "该",
"鬬": "豆",
"軏": "月",
"嚤": "魔",
"烋": "修",
"玼": "此",
"仠": "感",
"焾": "年",
"猂": "汉",
"獦": "格",
"綎": "听",
"幏": "驾",
"欉": "从",
"豑": "至",
"鹙": "秋",
"衘": "闲",
"彣": "文",
"犜": "蹲",
"攼": "干",
"荗": "树",
"緷": "运",
"縳": "倦",
"檁": "吝",
"仾": "低",
"飱": "孙",
"畗": "达",
"皔": "汉",
"咈": "福",
"藹": "矮",
"笭": "零",
"訏": "需",
"殅": "生",
"噭": "教",
"媂": "地",
"禕": "一",
"偦": "许",
"鴎": "欧",
"硉": "路",
"鼕": "东",
"踡": "全",
"哻": "憨",
"櫙": "欧",
"鱮": "续",
"鎅": "借",
"熯": "汉",
"眥": "字",
"騵": "原",
"潒": "荡",
"栟": "奔",
"旉": "夫",
"髣": "访",
"叐": "拔",
"彃": "必",
"蓢": "浪",
"劒": "见",
"譪": "矮",
"糼": "工",
"跼": "局",
"揦": "啦",
"矼": "刚",
"偖": "扯",
"稌": "图",
"萰": "练",
"鐻": "巨",
"鮡": "照",
"麩": "夫",
"漥": "挖",
"汫": "井",
"苲": "眨",
"諎": "则",
"飃": "飘",
"疁": "刘",
"魭": "原",
"蕶": "零",
"枲": "洗",
"琱": "雕",
"敊": "处",
"枬": "占",
"暕": "减",
"呌": "教",
"玜": "红",
"狯": "快",
"樛": "纠",
"邅": "占",
"矴": "定",
"媎": "解",
"儺": "挪",
"湙": "意",
"薲": "贫",
"芔": "会",
"錮": "固",
"棓": "棒",
"籪": "断",
"珷": "五",
"畄": "刘",
"磳": "增",
"媧": "挖",
"翴": "连",
"觫": "速",
"茪": "光",
"灄": "设",
"瑬": "刘",
"廇": "六",
"訌": "红",
"槱": "有",
"紆": "迂",
"兪": "鱼",
"孋": "离",
"櫆": "奎",
"磾": "低",
"諨": "福",
"謔": "血",
"檞": "解",
"鴀": "否",
"夿": "八",
"爫": "找",
"箑": "煞",
"唂": "姑",
"琈": "福",
"沕": "密",
"帊": "怕",
"焺": "生",
"糳": "做",
"芞": "气",
"鬶": "归",
"聢": "定",
"傖": "仓",
"譔": "赚",
"犦": "博",
"淜": "平",
"膤": "雪",
"冡": "盟",
"篴": "敌",
"倎": "舔",
"魷": "由",
"壎": "熏",
"搩": "眨",
"衖": "向",
"挵": "弄",
"壼": "捆",
"箄": "比",
"輗": "尼",
"楳": "梅",
"慴": "设",
"忺": "先",
"勨": "向",
"璝": "归",
"桯": "听",
"幨": "搀",
"熦": "觉",
"赩": "系",
"芓": "字",
"遖": "南",
"镮": "环",
"遝": "踏",
"貲": "姿",
"耞": "家",
"媴": "原",
"祋": "对",
"嘪": "买",
"鉈": "诗",
"捄": "就",
"拤": "恰",
"慯": "伤",
"氆": "普",
"蠏": "谢",
"鰐": "恶",
"鄮": "帽",
"汍": "完",
"黪": "惨",
"塂": "向",
"棁": "捉",
"贗": "燕",
"毪": "木",
"玱": "枪",
"帨": "睡",
"茻": "忙",
"緜": "眠",
"漃": "记",
"蟗": "秋",
"柹": "是",
"啈": "哼",
"鳓": "乐",
"緍": "民",
"狊": "局",
"媯": "归",
"瀅": "营",
"硁": "坑",
"徏": "至",
"巶": "招",
"犤": "排",
"濙": "营",
"謜": "原",
"拸": "宜",
"橲": "洗",
"菍": "聂",
"楿": "相",
"潥": "速",
"埈": "俊",
"縟": "入",
"嚬": "贫",
"羢": "容",
"槾": "慢",
"胘": "闲",
"詧": "茶",
"袏": "做",
"粂": "摘",
"榑": "福",
"岤": "学",
"姷": "右",
"筼": "云",
"蟰": "消",
"磥": "垒",
"娭": "哀",
"莾": "忙",
"冐": "帽",
"霅": "咋",
"雊": "够",
"犌": "家",
"叞": "位",
"臛": "或",
"葄": "做",
"芧": "续",
"珇": "组",
"氀": "驴",
"嚑": "熏",
"惎": "记",
"梹": "彬",
"杅": "鱼",
"錧": "管",
"镴": "蜡",
"娞": "内",
"餑": "波",
"鋯": "告",
"柇": "和",
"髽": "抓",
"癦": "么",
"靭": "任",
"斅": "笑",
"瘎": "陈",
"攺": "以",
"箟": "俊",
"嵿": "顶",
"臫": "角",
"昡": "炫",
"坿": "父",
"舙": "话",
"勀": "客",
"牚": "称",
"潻": "鼠",
"諍": "挣",
"僥": "角",
"臈": "蜡",
"柲": "必",
"罣": "挂",
"瞛": "聪",
"狓": "皮",
"巗": "颜",
"鹐": "前",
"杣": "眠",
"崲": "黄",
"碙": "脑",
"歔": "需",
"蓏": "裸",
"鋋": "缠",
"桼": "七",
"煭": "裂",
"媻": "盘",
"蕟": "发",
"叅": "参",
"瘃": "竹",
"瑫": "掏",
"絛": "掏",
"伨": "训",
"鰾": "标",
"滮": "标",
"廙": "意",
"稾": "搞",
"沴": "利",
"哵": "八",
"渄": "飞",
"璄": "井",
"鶉": "纯",
"爩": "玉",
"鱒": "尊",
"漶": "换",
"頬": "夹",
"夣": "梦",
"渰": "眼",
"釔":
gitextract_cimg12e7/
├── .github/
│ └── FUNDING.yml
├── .gitignore
├── ChatTTS/
│ ├── __init__.py
│ ├── config/
│ │ ├── __init__.py
│ │ └── config.py
│ ├── core.py
│ ├── experimental/
│ │ └── llm.py
│ ├── infer/
│ │ └── api.py
│ ├── model/
│ │ ├── __init__.py
│ │ ├── cuda/
│ │ │ ├── __init__.py
│ │ │ ├── patch.py
│ │ │ └── te_llama.py
│ │ ├── dvae.py
│ │ ├── gpt.py
│ │ ├── processors.py
│ │ └── tokenizer.py
│ ├── norm.py
│ ├── res/
│ │ ├── __init__.py
│ │ ├── homophones_map.json
│ │ └── sha256_map.json
│ └── utils/
│ ├── __init__.py
│ ├── dl.py
│ ├── download.py
│ ├── gpu.py
│ ├── gpu_utils.py
│ ├── infer_utils.py
│ ├── io.py
│ ├── io_utils.py
│ └── log.py
├── Dockerfile.cpu
├── Dockerfile.gpu
├── LICENSE
├── README.md
├── README_EN.md
├── app.py
├── asset/
│ └── 模型下载说明.txt
├── cover-pt.py
├── docker-compose.cpu.yaml
├── docker-compose.gpu.yaml
├── faq.md
├── ffmpeg/
│ └── ffmpeg下载.txt
├── pyproject.toml
├── requirements.txt
├── run.bat
├── run.py
├── runtest.bat
├── start.bat
├── static/
│ └── js/
│ └── layer/
│ ├── layer.js
│ ├── mobile/
│ │ ├── layer.js
│ │ └── need/
│ │ └── layer.css
│ └── theme/
│ └── default/
│ └── layer.css
├── templates/
│ ├── index.html
│ └── indexen.html
├── test.py
├── tools/
│ ├── __init__.py
│ ├── audio/
│ │ ├── __init__.py
│ │ └── np.py
│ ├── checksum/
│ │ ├── main.go
│ │ └── tmpl.go
│ ├── llm/
│ │ ├── __init__.py
│ │ └── llm.py
│ ├── logger/
│ │ ├── __init__.py
│ │ └── log.py
│ ├── normalizer/
│ │ ├── __init__.py
│ │ ├── en.py
│ │ └── zh.py
│ └── seeder/
│ ├── __init__.py
│ └── ctx.py
└── uilib/
├── __init__.py
├── cfg.py
├── utils.py
└── zh_normalization/
├── README.md
├── __init__.py
├── char_convert.py
├── chronology.py
├── constants.py
├── num.py
├── phonecode.py
├── quantifier.py
└── text_normlization.py
SYMBOL INDEX (218 symbols across 38 files)
FILE: ChatTTS/config/config.py
class Path (line 5) | class Path:
class Decoder (line 14) | class Decoder:
class VQ (line 23) | class VQ:
class DVAE (line 31) | class DVAE:
class GPT (line 50) | class GPT:
class FeatureExtractorInitArgs (line 65) | class FeatureExtractorInitArgs:
class FeatureExtractor (line 74) | class FeatureExtractor:
class BackboneInitArgs (line 80) | class BackboneInitArgs:
class Backbone (line 88) | class Backbone:
class FourierHeadInitArgs (line 94) | class FourierHeadInitArgs:
class FourierHead (line 102) | class FourierHead:
class Vocos (line 108) | class Vocos:
class Config (line 115) | class Config:
FILE: ChatTTS/core.py
class Chat (line 31) | class Chat:
method __init__ (line 32) | def __init__(self, logger=logging.getLogger(__name__)):
method has_loaded (line 50) | def has_loaded(self, use_decoder=False):
method download_models (line 69) | def download_models(
method load (line 125) | def load(
method unload (line 149) | def unload(self):
method sample_random_speaker (line 160) | def sample_random_speaker(self) -> str:
method sample_audio_speaker (line 164) | def sample_audio_speaker(self, wav: Union[np.ndarray, torch.Tensor]) -...
method _sample_random_speaker (line 170) | def _sample_random_speaker(self) -> torch.Tensor:
class RefineTextParams (line 180) | class RefineTextParams:
class InferCodeParams (line 192) | class InferCodeParams(RefineTextParams):
method infer (line 204) | def infer(
method interrupt (line 235) | def interrupt(self):
method _load (line 239) | def _load(
method _infer (line 340) | def _infer(
method _encode_spk_emb (line 421) | def _encode_spk_emb(spk_emb: torch.Tensor) -> str:
method _vocos_decode (line 434) | def _vocos_decode(self, spec: torch.Tensor) -> np.ndarray:
method _decode_to_wavs (line 441) | def _decode_to_wavs(
method _infer_code (line 470) | def _infer_code(
method _refine_text (line 562) | def _refine_text(
FILE: ChatTTS/experimental/llm.py
class llm_api (line 25) | class llm_api:
method __init__ (line 26) | def __init__(self, api_key, base_url, model):
method call (line 32) | def call(self, user_question, temperature = 0.3, prompt_version='kimi'...
FILE: ChatTTS/infer/api.py
function infer_code (line 7) | def infer_code(
function refine_text (line 77) | def refine_text(
FILE: ChatTTS/model/cuda/patch.py
class LlamaRMSNorm (line 4) | class LlamaRMSNorm(torch.nn.Module):
method __init__ (line 5) | def __init__(self, hidden_size, eps=1e-6):
method forward (line 13) | def forward(self, hidden_states: torch.Tensor):
FILE: ChatTTS/model/cuda/te_llama.py
function replace_decoder (line 29) | def replace_decoder(te_decoder_cls, llama_rms_norm_cls):
class TELlamaDecoderLayer (line 50) | class TELlamaDecoderLayer(te.pytorch.TransformerLayer):
method __init__ (line 61) | def __init__(self, config, *args, **kwargs):
method forward (line 81) | def forward(self, hidden_states, *args, attention_mask, **kwargs):
class TELlamaModel (line 96) | class TELlamaModel:
method __new__ (line 106) | def __new__(cls, config: LlamaConfig):
method from_state_dict (line 114) | def from_state_dict(
function _replace_params (line 134) | def _replace_params(hf_state_dict, te_state_dict, config):
FILE: ChatTTS/model/dvae.py
class ConvNeXtBlock (line 13) | class ConvNeXtBlock(nn.Module):
method __init__ (line 14) | def __init__(
method forward (line 45) | def forward(self, x: torch.Tensor, cond=None) -> torch.Tensor:
class GFSQ (line 68) | class GFSQ(nn.Module):
method __init__ (line 70) | def __init__(
method _embed (line 86) | def _embed(self, x: torch.Tensor):
method __call__ (line 98) | def __call__(self, x: torch.Tensor) -> torch.Tensor:
method forward (line 101) | def forward(self, x: torch.Tensor) -> torch.Tensor:
class DVAEDecoder (line 130) | class DVAEDecoder(nn.Module):
method __init__ (line 131) | def __init__(
method forward (line 162) | def forward(self, x: torch.Tensor, conditioning=None) -> torch.Tensor:
class MelSpectrogramFeatures (line 174) | class MelSpectrogramFeatures(torch.nn.Module):
method __init__ (line 175) | def __init__(
method __call__ (line 196) | def __call__(self, audio: torch.Tensor) -> torch.Tensor:
method forward (line 199) | def forward(self, audio: torch.Tensor) -> torch.Tensor:
class DVAE (line 205) | class DVAE(nn.Module):
method __init__ (line 206) | def __init__(
method __repr__ (line 240) | def __repr__(self) -> str:
method __call__ (line 245) | def __call__(
method forward (line 251) | def forward(
FILE: ChatTTS/model/gpt.py
class GPT (line 22) | class GPT(nn.Module):
method __init__ (line 23) | def __init__(
method from_pretrained (line 86) | def from_pretrained(self, file_path: str):
class Context (line 109) | class Context:
method __init__ (line 110) | def __init__(self):
method set (line 113) | def set(self, v: bool):
method get (line 116) | def get(self) -> bool:
method _build_llama (line 119) | def _build_llama(
method prepare (line 141) | def prepare(self, compile=False):
method __call__ (line 151) | def __call__(
method forward (line 159) | def forward(self, input_ids: torch.Tensor, text_mask: torch.Tensor) ->...
class _GenerationInputs (line 189) | class _GenerationInputs:
method to (line 198) | def to(self, device: torch.device, dtype: torch.dtype):
method _prepare_generation_inputs (line 208) | def _prepare_generation_inputs(
class GenerationOutputs (line 318) | class GenerationOutputs:
method destroy (line 323) | def destroy(self):
method _prepare_generation_outputs (line 328) | def _prepare_generation_outputs(
method generate (line 356) | def generate(
FILE: ChatTTS/model/processors.py
class CustomRepetitionPenaltyLogitsProcessorRepeat (line 6) | class CustomRepetitionPenaltyLogitsProcessorRepeat:
method __init__ (line 8) | def __init__(self, penalty: float, max_input_ids: int, past_window: int):
method __call__ (line 18) | def __call__(
function gen_logits (line 38) | def gen_logits(
FILE: ChatTTS/model/tokenizer.py
class Tokenizer (line 20) | class Tokenizer:
method __init__ (line 21) | def __init__(
method encode (line 37) | def encode(
method _decode_spk_emb (line 132) | def _decode_spk_emb(spk_emb: str) -> np.ndarray:
method apply_spk_emb (line 143) | def apply_spk_emb(
method _decode_prompt (line 171) | def _decode_prompt(prompt: str) -> torch.Tensor:
method _encode_prompt (line 187) | def _encode_prompt(prompt: torch.Tensor) -> str:
method _encode_spk_emb (line 204) | def _encode_spk_emb(spk_emb: torch.Tensor) -> str:
FILE: ChatTTS/norm.py
function _find_index (line 14) | def _find_index(table: np.ndarray, val: np.uint16):
function _fast_replace (line 22) | def _fast_replace(
class Normalizer (line 37) | class Normalizer:
method __init__ (line 38) | def __init__(self, map_file_path: str, logger=logging.getLogger(__name...
method __call__ (line 129) | def __call__(
method register (line 159) | def register(self, name: str, normalizer: Callable[[str], str]) -> bool:
method unregister (line 174) | def unregister(self, name: str):
method destroy (line 178) | def destroy(self):
method _load_homophones_map (line 182) | def _load_homophones_map(self, map_file_path: str) -> np.ndarray:
method _count_invalid_characters (line 191) | def _count_invalid_characters(self, s: str):
method _apply_half2full_map (line 196) | def _apply_half2full_map(self, text: str) -> str:
method _apply_character_map (line 199) | def _apply_character_map(self, text: str) -> str:
method _detect_language (line 202) | def _detect_language(self, sentence: str) -> Literal["zh", "en"]:
FILE: ChatTTS/utils/dl.py
function sha256 (line 12) | def sha256(fileno: int) -> str:
function check_model (line 19) | def check_model(
function check_all_assets (line 46) | def check_all_assets(base_dir: Path, sha256_map: Dict[str, str], update=...
function download_and_extract_tar_gz (line 68) | def download_and_extract_tar_gz(url: str, folder: str):
function download_and_extract_zip (line 82) | def download_and_extract_zip(url: str, folder: str):
function download_dns_yaml (line 96) | def download_dns_yaml(url: str, folder: str):
function download_all_assets (line 104) | def download_all_assets(tmpdir: str, version="0.2.6"):
FILE: ChatTTS/utils/download.py
function sha256 (line 11) | def sha256(f) -> str:
function check_model (line 19) | def check_model(
function check_all_assets (line 47) | def check_all_assets(update=False) -> bool:
function download_and_extract_tar_gz (line 87) | def download_and_extract_tar_gz(url: str, folder: str):
function download_and_extract_zip (line 101) | def download_and_extract_zip(url: str, folder: str):
function download_dns_yaml (line 115) | def download_dns_yaml(url: str, folder: str):
function download_all_assets (line 123) | def download_all_assets(tmpdir: str, version="0.2.5"):
FILE: ChatTTS/utils/gpu.py
function select_device (line 6) | def select_device(min_memory=2047, experimental=False):
FILE: ChatTTS/utils/gpu_utils.py
function select_device (line 5) | def select_device(min_memory=2048):
FILE: ChatTTS/utils/infer_utils.py
class CustomRepetitionPenaltyLogitsProcessorRepeat (line 9) | class CustomRepetitionPenaltyLogitsProcessorRepeat():
method __init__ (line 11) | def __init__(self, penalty: float, max_input_ids, past_window):
method __call__ (line 19) | def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTen...
class CustomRepetitionPenaltyLogitsProcessor (line 30) | class CustomRepetitionPenaltyLogitsProcessor():
method __init__ (line 32) | def __init__(self, penalty: float, max_input_ids, past_window):
method __call__ (line 40) | def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTen...
class HomophonesReplacer (line 51) | class HomophonesReplacer:
method __init__ (line 69) | def __init__(self, map_file_path):
method load_homophones_map (line 72) | def load_homophones_map(self, map_file_path):
method replace (line 77) | def replace(self, text):
function count_invalid_characters (line 86) | def count_invalid_characters(s):
function detect_language (line 93) | def detect_language(sentence):
function apply_half2full_map (line 173) | def apply_half2full_map(text):
function apply_character_map (line 177) | def apply_character_map(text):
FILE: ChatTTS/utils/io.py
function get_latest_modified_file (line 9) | def get_latest_modified_file(directory):
function del_all (line 22) | def del_all(d: Union[dict, list]):
FILE: ChatTTS/utils/io_utils.py
function get_latest_modified_file (line 5) | def get_latest_modified_file(directory):
FILE: ChatTTS/utils/log.py
class Logger (line 5) | class Logger:
method __init__ (line 6) | def __init__(self, logger=logging.getLogger(Path(__file__).parent.name)):
method set_logger (line 9) | def set_logger(self, logger: logging.Logger):
method get_logger (line 12) | def get_logger(self) -> logging.Logger:
FILE: app.py
function static_files (line 122) | def static_files(filename):
function index (line 127) | def index():
function tts (line 156) | def tts():
function clear_wavs (line 391) | def clear_wavs():
FILE: run.py
function save_wav_file (line 17) | def save_wav_file(wav, index):
function main (line 28) | def main():
FILE: static/js/layer/layer.js
function e (line 2) | function e(){var e=a.cancel&&a.cancel(t.index,n);e===!1||r.close(t.index)}
function o (line 2) | function o(e,t,i){var n=new Image;return n.src=e,n.complete?t(n):(n.onlo...
FILE: tools/audio/np.py
function unsafe_float_to_int16 (line 6) | def unsafe_float_to_int16(audio: np.ndarray) -> np.ndarray:
FILE: tools/checksum/main.go
function main (line 11) | func main() {
FILE: tools/checksum/tmpl.go
constant jsontmpl (line 18) | jsontmpl = `{
FILE: tools/llm/llm.py
class ChatOpenAI (line 55) | class ChatOpenAI:
method __init__ (line 56) | def __init__(self, api_key, base_url, model):
method call (line 63) | def call(self, user_question, temperature=0.3, prompt_version="kimi", ...
FILE: tools/logger/log.py
class Formatter (line 37) | class Formatter(logging.Formatter):
method __init__ (line 38) | def __init__(self, color=platform.system().lower() != "windows"):
method format (line 43) | def format(self, record: logging.LogRecord):
function get_logger (line 55) | def get_logger(name: str, lv=logging.INFO, remove_exist=False, format_ro...
FILE: tools/normalizer/en.py
function normalizer_en_nemo_text (line 5) | def normalizer_en_nemo_text() -> Callable[[str], str]:
FILE: tools/normalizer/zh.py
function normalizer_zh_tn (line 4) | def normalizer_zh_tn() -> Callable[[str], str]:
FILE: tools/seeder/ctx.py
class TorchSeedContext (line 4) | class TorchSeedContext:
method __init__ (line 5) | def __init__(self, seed):
method __enter__ (line 9) | def __enter__(self):
method __exit__ (line 13) | def __exit__(self, type, value, traceback):
FILE: uilib/cfg.py
function get_executable_path (line 5) | def get_executable_path():
FILE: uilib/utils.py
function openweb (line 13) | def openweb(url):
function get_parameter (line 20) | def get_parameter(request, param, default, cast_type):
function num_to_english (line 33) | def num_to_english(num):
function get_lang (line 96) | def get_lang(text):
function fraction_to_words (line 104) | def fraction_to_words(match):
function num2text (line 113) | def num2text(text):
function remove_brackets (line 141) | def remove_brackets(text):
function split_text (line 151) | def split_text(text_list):
function split_text_by_punctuation (line 183) | def split_text_by_punctuation(text):
function ClearWav (line 216) | def ClearWav(directory):
function load_speaker (line 239) | def load_speaker(name):
function get_speakers (line 254) | def get_speakers():
function is_network (line 262) | def is_network():
function is_chinese_os (line 274) | def is_chinese_os():
function modelscope_status (line 305) | def modelscope_status():
FILE: uilib/zh_normalization/char_convert.py
function tranditional_to_simplified (line 30) | def tranditional_to_simplified(text: str) -> str:
function simplified_to_traditional (line 35) | def simplified_to_traditional(text: str) -> str:
FILE: uilib/zh_normalization/chronology.py
function _time_num2str (line 22) | def _time_num2str(num_string: str) -> str:
function replace_time (line 45) | def replace_time(match) -> str:
function replace_date (line 92) | def replace_date(match) -> str:
function replace_date2 (line 117) | def replace_date2(match) -> str:
FILE: uilib/zh_normalization/num.py
function replace_frac (line 37) | def replace_frac(match) -> str:
function replace_percentage (line 58) | def replace_percentage(match) -> str:
function replace_negative_num (line 78) | def replace_negative_num(match) -> str:
function replace_default_num (line 98) | def replace_default_num(match):
function replace_positive_quantifier (line 117) | def replace_positive_quantifier(match) -> str:
function replace_number (line 135) | def replace_number(match) -> str:
function replace_range (line 161) | def replace_range(match) -> str:
function _get_value (line 175) | def _get_value(value_string: str, use_zero: bool=True) -> List[str]:
function verbalize_cardinal (line 193) | def verbalize_cardinal(value_string: str) -> str:
function verbalize_digit (line 210) | def verbalize_digit(value_string: str, alt_one=False) -> str:
function num2str (line 218) | def num2str(value_string: str) -> str:
FILE: uilib/zh_normalization/phonecode.py
function phone2str (line 33) | def phone2str(phone_string: str, mobile=True) -> str:
function replace_phone (line 46) | def replace_phone(match) -> str:
function replace_mobile (line 56) | def replace_mobile(match) -> str:
FILE: uilib/zh_normalization/quantifier.py
function replace_temperature (line 42) | def replace_temperature(match) -> str:
function replace_measure (line 59) | def replace_measure(sentence) -> str:
FILE: uilib/zh_normalization/text_normlization.py
class TextNormalizer (line 53) | class TextNormalizer():
method __init__ (line 54) | def __init__(self):
method _split (line 57) | def _split(self, text: str, lang="zh") -> List[str]:
method _post_replace (line 107) | def _post_replace(self, sentence: str) -> str:
method num_to_chinese (line 156) | def num_to_chinese(self,num):
method normalize_sentence (line 200) | def normalize_sentence(self, sentence: str) -> str:
method normalize (line 265) | def normalize(self, text: str) -> List[str]:
Condensed preview — 80 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (635K chars).
[
{
"path": ".github/FUNDING.yml",
"chars": 86,
"preview": "# These are supported funding model platforms\n\ncustom: https://ko-fi.com/jianchang512\n"
},
{
"path": ".gitignore",
"chars": 197,
"preview": "*.log\n*.srt\n.idea\n\nmodels/*\ndev\nvenv\ndist\nsource\nbuild\n__pycache__\n*.spec\n*.ui\n*.bak\n*.aac\n*.pt\n# *.wav\npack.bat\ngitcmd."
},
{
"path": "ChatTTS/__init__.py",
"chars": 23,
"preview": "from .core import Chat\n"
},
{
"path": "ChatTTS/config/__init__.py",
"chars": 27,
"preview": "from .config import Config\n"
},
{
"path": "ChatTTS/config/config.py",
"chars": 2662,
"preview": "from dataclasses import dataclass\n\n\n@dataclass(repr=False, eq=False)\nclass Path:\n vocos_ckpt_path: str = \"asset/Vocos"
},
{
"path": "ChatTTS/core.py",
"chars": 19714,
"preview": "import os\nimport logging\nimport tempfile\nfrom dataclasses import dataclass, asdict\nfrom typing import Literal, Optional,"
},
{
"path": "ChatTTS/experimental/llm.py",
"chars": 2116,
"preview": "\nfrom openai import OpenAI\n \nprompt_dict = {\n 'kimi': [ {\"role\": \"system\", \"content\": \"你是 Kimi，由 Moonshot AI 提供的人工智能助"
},
{
"path": "ChatTTS/infer/api.py",
"chars": 4337,
"preview": "\nimport torch\nimport torch.nn.functional as F\nfrom transformers.generation import TopKLogitsWarper, TopPLogitsWarper\nfro"
},
{
"path": "ChatTTS/model/__init__.py",
"chars": 112,
"preview": "from .dvae import DVAE\nfrom .gpt import GPT\nfrom .processors import gen_logits\nfrom .tokenizer import Tokenizer\n"
},
{
"path": "ChatTTS/model/cuda/__init__.py",
"chars": 35,
"preview": "from .te_llama import TELlamaModel\n"
},
{
"path": "ChatTTS/model/cuda/patch.py",
"chars": 686,
"preview": "import torch\n\n\nclass LlamaRMSNorm(torch.nn.Module):\n def __init__(self, hidden_size, eps=1e-6):\n \"\"\"\n L"
},
{
"path": "ChatTTS/model/cuda/te_llama.py",
"chars": 7445,
"preview": "# Copyright (c) 2022-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# See LICENSE for license information"
},
{
"path": "ChatTTS/model/dvae.py",
"chars": 8412,
"preview": "import math\nfrom typing import List, Optional, Literal, Tuple\n\nimport numpy as np\nimport pybase16384 as b14\nimport torch"
},
{
"path": "ChatTTS/model/gpt.py",
"chars": 23540,
"preview": "import platform\nfrom dataclasses import dataclass\nimport logging\nfrom typing import Union, List, Optional, Tuple\nimport "
},
{
"path": "ChatTTS/model/processors.py",
"chars": 1939,
"preview": "import torch\nimport torch.nn.functional as F\nfrom transformers.generation import TopKLogitsWarper, TopPLogitsWarper\n\n\ncl"
},
{
"path": "ChatTTS/model/tokenizer.py",
"chars": 6936,
"preview": "import os\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n\"\"\"\nhttps://stackoverflow.com/questions/62691279/how-to-disabl"
},
{
"path": "ChatTTS/norm.py",
"chars": 7243,
"preview": "import json\nimport logging\nimport re\nfrom typing import Dict, Tuple, List, Literal, Callable, Optional\nimport sys\n\nfrom "
},
{
"path": "ChatTTS/res/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "ChatTTS/res/homophones_map.json",
"chars": 229952,
"preview": "{\n \"粡\": \"同\",\n \"為\": \"位\",\n \"瀹\": \"月\",\n \"滆\": \"格\",\n \"摲\": \"颤\",\n \"渹\": \"轰\",\n \"於\": \"鱼\",\n \"満\": \"满\",\n \"鍑"
},
{
"path": "ChatTTS/res/sha256_map.json",
"chars": 602,
"preview": "{\n\t\"sha256_asset_Decoder_pt\" : \"9964e36e840f0e3a748c5f716fe6de6490d2135a5f5155f4a642d51860e2ec38\",\n\t\"sha256_asset_DVAE"
},
{
"path": "ChatTTS/utils/__init__.py",
"chars": 159,
"preview": "from .dl import check_all_assets, download_all_assets\nfrom .gpu import select_device\nfrom .io import get_latest_modified"
},
{
"path": "ChatTTS/utils/dl.py",
"chars": 5619,
"preview": "import os\nfrom pathlib import Path\nimport hashlib\nimport requests\nfrom io import BytesIO\nfrom typing import Dict\nfrom mm"
},
{
"path": "ChatTTS/utils/download.py",
"chars": 5902,
"preview": "import os\nfrom pathlib import Path\nimport hashlib\nimport requests\nfrom io import BytesIO\nimport logging\n\nlogger = loggin"
},
{
"path": "ChatTTS/utils/gpu.py",
"chars": 1540,
"preview": "import torch\n\nfrom .log import logger\n\n\ndef select_device(min_memory=2047, experimental=False):\n if torch.cuda.is_ava"
},
{
"path": "ChatTTS/utils/gpu_utils.py",
"chars": 1109,
"preview": "\nimport torch\nimport logging\n\ndef select_device(min_memory=2048):\n logger = logging.getLogger(__name__)\n if torch."
},
{
"path": "ChatTTS/utils/infer_utils.py",
"chars": 5246,
"preview": "\nimport re\nimport torch\nimport torch.nn.functional as F\nimport os\nimport json\n\n \nclass CustomRepetitionPenaltyLogitsP"
},
{
"path": "ChatTTS/utils/io.py",
"chars": 1192,
"preview": "import os\nimport logging\nfrom typing import Union\nfrom dataclasses import is_dataclass\n\nfrom .log import logger\n\n\ndef ge"
},
{
"path": "ChatTTS/utils/io_utils.py",
"chars": 384,
"preview": "\nimport os\nimport logging\n\ndef get_latest_modified_file(directory):\n logger = logging.getLogger(__name__)\n \n fi"
},
{
"path": "ChatTTS/utils/log.py",
"chars": 335,
"preview": "import logging\nfrom pathlib import Path\n\n\nclass Logger:\n def __init__(self, logger=logging.getLogger(Path(__file__).p"
},
{
"path": "Dockerfile.cpu",
"chars": 223,
"preview": "FROM pytorch/torchserve:0.11.0-cpu as builder\r\n\r\nUSER root\r\n\r\nRUN apt-get update && apt-get install -y ffmpeg\r\n\r\nWORKDIR"
},
{
"path": "Dockerfile.gpu",
"chars": 212,
"preview": "FROM pytorch/torchserve:0.11.0-gpu as builder\n\nUSER root\n\nRUN apt-get update && apt-get install -y ffmpeg\n\nWORKDIR /app\n"
},
{
"path": "LICENSE",
"chars": 17489,
"preview": "# Attribution-NonCommercial-NoDerivatives 4.0 International\n\n> *Creative Commons Corporation (“Creative Commons”) is not"
},
{
"path": "README.md",
"chars": 7683,
"preview": "\n[English README](README_EN.md) | [打赏项目](https://github.com/jianchang512/ChatTTS-ui/issues/122) | [Discord Discussion Gr"
},
{
"path": "README_EN.md",
"chars": 10023,
"preview": "\n[简体中文](README.md) | [Discord Discussion Group](https://discord.gg/y9gUweVCCJ) | [Support the Project](https://github.co"
},
{
"path": "app.py",
"chars": 12106,
"preview": "import os\nimport re\nimport sys\n\nif sys.platform == \"darwin\":\n os.environ[\"PYTORCH_ENABLE_MPS_FALLBACK\"] = \"1\"\nimport "
},
{
"path": "asset/模型下载说明.txt",
"chars": 150,
"preview": "如果无法下载模型，请去下载 https://github.com/jianchang512/ChatTTS-ui/releases/download/v1.0/all-models.7z\n\n\n下载后解压后，会看到asset文件夹，该文件夹"
},
{
"path": "cover-pt.py",
"chars": 2510,
"preview": "'''\n0.96版本后，因ChatTTS内核升级，已无法直接使用从该站点下载的pt文件。\n\nhttps://modelscope.cn/studios/ttwwwaa/ChatTTS_Speaker\n\n因此增加该转换脚本。\n\n执行 pyt"
},
{
"path": "docker-compose.cpu.yaml",
"chars": 340,
"preview": "services:\r\n chat-tts-ui:\r\n build:\r\n context: .\r\n dockerfile: Dockerfile.cpu\r\n container_name: chat-tts-"
},
{
"path": "docker-compose.gpu.yaml",
"chars": 491,
"preview": "services:\n chat-tts-ui:\n build:\n context: .\n dockerfile: Dockerfile.gpu\n container_name: chat-tts-ui\n "
},
{
"path": "faq.md",
"chars": 3126,
"preview": "# 常见问题与报错\n\n\n**注意：不同机器使用相同种子生成的音频音色可能不同，同一机器使用相同种子多次生成的音频音色也可能变化。**\n\n\n**升级到0.96版后报错**\n\n答： 0.96版起，源码部署必须先安装ffmpeg \n\n0.96版起"
},
{
"path": "ffmpeg/ffmpeg下载.txt",
"chars": 252,
"preview": "Windows源码部署需下载 ffmpeg.exe 放在这里 \nhttps://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2023-11-30-12-55/ffmp"
},
{
"path": "pyproject.toml",
"chars": 2063,
"preview": "[tool.poetry]\nname = \"chattts-ui\"\nversion = \"0.1.0\"\ndescription = \"一个简单的本地网页界面，直接使用ChatTTS将文字合成为语音，同时支持对外提供API接口。\"\nautho"
},
{
"path": "requirements.txt",
"chars": 346,
"preview": "Flask\nipython\nmodelscope\nnumpy==1.26.4\nnumba\neinops\ntqdm\nomegaconf>=2.3.0\ntorch>=2.1.0\npython-dotenv\nrequests\nsoundfile\n"
},
{
"path": "run.bat",
"chars": 49,
"preview": "@echo off\n\n.\\venv\\scripts\\python.exe app.py\npause"
},
{
"path": "run.py",
"chars": 2253,
"preview": "import os, sys\n\nif sys.platform == \"darwin\":\n os.environ[\"PYTORCH_ENABLE_MPS_FALLBACK\"] = \"1\"\n\nnow_dir = os.getcwd()\n"
},
{
"path": "runtest.bat",
"chars": 50,
"preview": "@echo off\n\n.\\venv\\scripts\\python.exe test.py\npause"
},
{
"path": "start.bat",
"chars": 78,
"preview": "@echo off\ncd /d D:\\ChatTTS-ui\ncall .\\venv\\Scripts\\activate\npython app.py\npause"
},
{
"path": "static/js/layer/layer.js",
"chars": 22724,
"preview": "/*! layer-v3.5.1 Web 通用弹出层组件 MIT License */\n ;!function(e,t){\"use strict\";var i,n,a=e.layui&&layui.define,o={getPath:fun"
},
{
"path": "static/js/layer/mobile/layer.js",
"chars": 3256,
"preview": "/*! layer mobile-v2.0.0 Web 通用弹出层组件 MIT License */\n ;!function(e){\"use strict\";var t=document,n=\"querySelectorAll\",i=\"ge"
},
{
"path": "static/js/layer/mobile/need/layer.css",
"chars": 5260,
"preview": ".layui-m-layer{position:relative;z-index:19891014}.layui-m-layer *{-webkit-box-sizing:content-box;-moz-box-sizing:conten"
},
{
"path": "static/js/layer/theme/default/layer.css",
"chars": 14271,
"preview": ".layui-layer-imgbar,.layui-layer-imgtit a,.layui-layer-tab .layui-layer-title span,.layui-layer-title{text-overflow:elli"
},
{
"path": "templates/index.html",
"chars": 11456,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n <meta charset=\"UTF-8\">\n <meta name=\"viewport\" content=\"width=device-width"
},
{
"path": "templates/indexen.html",
"chars": 11197,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n <meta charset=\"UTF-8\">\n <meta name=\"viewport\" content=\"width=device-width"
},
{
"path": "test.py",
"chars": 1801,
"preview": "import os\nimport re\nimport sys\nif sys.platform == \"darwin\":\n os.environ[\"PYTORCH_ENABLE_MPS_FALLBACK\"] = \"1\"\nimport i"
},
{
"path": "tools/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "tools/audio/__init__.py",
"chars": 38,
"preview": "from .np import unsafe_float_to_int16\n"
},
{
"path": "tools/audio/np.py",
"chars": 332,
"preview": "import numpy as np\nfrom numba import jit\n\n\n@jit\ndef unsafe_float_to_int16(audio: np.ndarray) -> np.ndarray:\n \"\"\"\n "
},
{
"path": "tools/checksum/main.go",
"chars": 608,
"preview": "package main\n\nimport (\n\t\"crypto/sha256\"\n\t\"encoding/hex\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n)\n\nfunc main() {\n\tvar buf [32]byte\n\th := sha2"
},
{
"path": "tools/checksum/tmpl.go",
"chars": 702,
"preview": "package main\n\nvar files = [...]string{\n\t\"asset/Decoder.pt\",\n\t\"asset/DVAE.pt\",\n\t\"asset/GPT.pt\",\n\t\"asset/spk_stat.pt\",\n\t\"a"
},
{
"path": "tools/llm/__init__.py",
"chars": 28,
"preview": "from .llm import ChatOpenAI\n"
},
{
"path": "tools/llm/llm.py",
"chars": 2437,
"preview": "from openai import OpenAI\n\nprompt_dict = {\n \"kimi\": [\n {\n \"role\": \"system\",\n \"content\": "
},
{
"path": "tools/logger/__init__.py",
"chars": 28,
"preview": "from .log import get_logger\n"
},
{
"path": "tools/logger/log.py",
"chars": 2403,
"preview": "import platform\nimport logging\nfrom datetime import datetime, timezone\n\nlogging.getLogger(\"numba\").setLevel(logging.WARN"
},
{
"path": "tools/normalizer/__init__.py",
"chars": 73,
"preview": "from .en import normalizer_en_nemo_text\nfrom .zh import normalizer_zh_tn\n"
},
{
"path": "tools/normalizer/en.py",
"chars": 336,
"preview": "from typing import Callable\nfrom functools import partial\n\n\ndef normalizer_en_nemo_text() -> Callable[[str], str]:\n f"
},
{
"path": "tools/normalizer/zh.py",
"chars": 162,
"preview": "from typing import Callable\n\n\ndef normalizer_zh_tn() -> Callable[[str], str]:\n from tn.chinese.normalizer import Norm"
},
{
"path": "tools/seeder/__init__.py",
"chars": 34,
"preview": "from .ctx import TorchSeedContext\n"
},
{
"path": "tools/seeder/ctx.py",
"chars": 329,
"preview": "import torch\n\n\nclass TorchSeedContext:\n def __init__(self, seed):\n self.seed = seed\n self.state = None\n"
},
{
"path": "uilib/__init__.py",
"chars": 13,
"preview": "VERSION='1.0'"
},
{
"path": "uilib/cfg.py",
"chars": 1089,
"preview": "from pathlib import Path\nimport sys\nimport os\n\ndef get_executable_path():\n # 这个函数会返回可执行文件所在的目录\n if getattr(sys, 'f"
},
{
"path": "uilib/utils.py",
"chars": 10101,
"preview": "import os,sys\nimport requests\nimport time\nimport re\nimport webbrowser\nfrom pathlib import Path\nimport pandas as pd\n# ref"
},
{
"path": "uilib/zh_normalization/README.md",
"chars": 762,
"preview": "## Supported NSW (Non-Standard-Word) Normalization\n\n|NSW type|raw|normalized|\n|:--|:-|:-|\n|serial number|电影中梁朝伟扮演的陈永仁的编号"
},
{
"path": "uilib/zh_normalization/__init__.py",
"chars": 643,
"preview": "# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the "
},
{
"path": "uilib/zh_normalization/char_convert.py",
"chars": 23075,
"preview": "# coding=utf-8\n# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Ve"
},
{
"path": "uilib/zh_normalization/chronology.py",
"chars": 3551,
"preview": "# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the "
},
{
"path": "uilib/zh_normalization/constants.py",
"chars": 2215,
"preview": "# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the "
},
{
"path": "uilib/zh_normalization/num.py",
"chars": 6450,
"preview": "# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the "
},
{
"path": "uilib/zh_normalization/phonecode.py",
"chars": 1867,
"preview": "# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the "
},
{
"path": "uilib/zh_normalization/quantifier.py",
"chars": 1685,
"preview": "# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the "
},
{
"path": "uilib/zh_normalization/text_normlization.py",
"chars": 9998,
"preview": "# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the "
}
]
About this extraction
This page contains the full source code of the jianchang512/ChatTTS-ui GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 80 files (523.4 KB), approximately 253.5k tokens, and a symbol index with 218 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.