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
================================================
{
    "粡": "同",
    "為": "位",
    "瀹": "月",
    "滆": "格",
    "摲": "颤",
    "渹": "轰",
    "於": "鱼",
    "満": "满",
    "鍑": "父",
    "與": "雨",
    "阃": "捆",
    "橹": "鲁",
    "骞": "前",
    "岀": "出",
    "铓": "忙",
    "杩": "骂",
    "鍞": "坑",
    "擼": "鲁",
    "後": "后",
    "來": "来",
    "喔": "哦",
    "會": "会",
    "爰": "原",
    "煡": "进",
    "鐗": "减",
    "個": "个",
    "澶": "缠",
    "時": "石",
    "噢": "哦",
    "铚": "至",
    "栧": "意",
    "浘": "伟",
    "這": "这",
    "穞": "旅",
    "妳": "你",
    "佷": "很",
    "對": "对",
    "並": "病",
    "國": "国",
    "戠": "知",
    "笟": "姑",
    "唔": "无",
    "勫": "翻",
    "徃": "网",
    "還": "孩",
    "將": "将",
    "閮": "停",
    "屽": "汉",
    "過": "过",
    "網": "网",
    "紅": "红",
    "說": "说",
    "開": "开",
    "區": "区",
    "該": "该",
    "從": "从",
    "鑹": "窜",
    "硗": "敲",
    "內": "内",
    "涘": "四",
    "屄": "逼",
    "種": "种",
    "爾": "耳",
    "讓": "让",
    "搧": "山",
    "甯": "凝",
    "晢": "哲",
    "愛": "爱",
    "吖": "呀",
    "沒": "梅",
    "長": "长",
    "線": "现",
    "熱": "热",
    "肏": "操",
    "鎶": "歌",
    "傚": "笑",
    "無": "无",
    "號": "号",
    "兩": "两",
    "榫": "损",
    "強": "强",
    "瓒": "赞",
    "發": "发",
    "機": "机",
    "達": "达",
    "圖": "图",
    "稱": "称",
    "則": "则",
    "間": "间",
    "馬": "马",
    "點": "点",
    "級": "极",
    "輪": "伦",
    "壹": "一",
    "東": "东",
    "鍚": "羊",
    "給": "给",
    "學": "学",
    "數": "树",
    "軍": "君",
    "當": "当",
    "嗎": "吗",
    "爲": "位",
    "鏂": "欧",
    "場": "场",
    "寮": "聊",
    "鏈": "练",
    "獎": "讲",
    "約": "约",
    "現": "现",
    "裏": "李",
    "縣": "现",
    "阌": "文",
    "婬": "银",
    "們": "们",
    "萬": "万",
    "亞": "亚",
    "經": "精",
    "艹": "草",
    "張": "张",
    "隊": "对",
    "進": "进",
    "帶": "带",
    "镩": "窜",
    "曽": "层",
    "麽": "魔",
    "閲": "月",
    "賽": "赛",
    "鐮": "连",
    "見": "见",
    "書": "书",
    "祂": "他",
    "鐭": "玉",
    "龍": "龙",
    "犳": "着",
    "墝": "敲",
    "門": "门",
    "連": "连",
    "嘅": "凯",
    "處": "处",
    "設": "设",
    "屬": "鼠",
    "戹": "恶",
    "員": "原",
    "體": "体",
    "車": "车",
    "裡": "李",
    "羅": "罗",
    "憺": "蛋",
    "頭": "头",
    "類": "泪",
    "戰": "战",
    "話": "话",
    "動": "动",
    "麼": "么",
    "組": "组",
    "別": "别",
    "嚕": "鲁",
    "請": "请",
    "許": "许",
    "總": "总",
    "島": "导",
    "華": "华",
    "卻": "确",
    "編": "编",
    "業": "夜",
    "鐜": "堆",
    "師": "诗",
    "雙": "双",
    "準": "准",
    "黃": "黄",
    "涁": "肾",
    "報": "报",
    "倫": "伦",
    "視": "是",
    "選": "选",
    "揄": "鱼",
    "鍙": "互",
    "純": "纯",
    "樻": "溃",
    "幾": "几",
    "濈": "极",
    "辦": "办",
    "應": "应",
    "極": "极",
    "柊": "中",
    "納": "那",
    "铰": "角",
    "蹇": "减",
    "係": "系",
    "掑": "其",
    "飾": "是",
    "闱": "维",
    "團": "团",
    "歳": "岁",
    "變": "变",
    "陳": "陈",
    "娍": "成",
    "義": "意",
    "兒": "而",
    "碼": "马",
    "條": "条",
    "轉": "转",
    "難": "南",
    "曜": "要",
    "邊": "编",
    "項": "向",
    "積": "机",
    "滿": "满",
    "幹": "干",
    "奧": "奥",
    "裝": "装",
    "町": "听",
    "哜": "记",
    "笫": "子",
    "絑": "朱",
    "風": "风",
    "黨": "挡",
    "晟": "成",
    "闃": "去",
    "蘭": "蓝",
    "樣": "样",
    "魚": "鱼",
    "較": "教",
    "聲": "生",
    "戝": "贼",
    "單": "单",
    "氣": "气",
    "獲": "或",
    "語": "雨",
    "樂": "乐",
    "實": "石",
    "親": "亲",
    "沖": "冲",
    "鎮": "镇",
    "阒": "去",
    "褚": "楚",
    "玖": "久",
    "樓": "楼",
    "楽": "乐",
    "闾": "驴",
    "夠": "够",
    "嬪": "贫",
    "宮": "工",
    "殇": "伤",
    "劉": "刘",
    "舉": "举",
    "尻": "烤",
    "園": "原",
    "傳": "传",
    "蹙": "促",
    "聯": "连",
    "維": "维",
    "鐵": "铁",
    "宸": "陈",
    "砲": "炮",
    "試": "是",
    "導": "导",
    "製": "至",
    "勝": "胜",
    "萊": "来",
    "絕": "觉",
    "僅": "紧",
    "聖": "胜",
    "睇": "地",
    "隨": "随",
    "浜": "帮",
    "慾": "玉",
    "億": "意",
    "屆": "借",
    "硒": "西",
    "電": "电",
    "玥": "月",
    "權": "全",
    "殺": "沙",
    "埚": "锅",
    "買": "买",
    "創": "创",
    "雲": "云",
    "記": "记",
    "臺": "台",
    "誰": "谁",
    "夢": "梦",
    "關": "关",
    "荜": "必",
    "叁": "三",
    "層": "层",
    "寶": "宝",
    "寫": "写",
    "問": "问",
    "啲": "低",
    "備": "被",
    "靑": "青",
    "務": "物",
    "灏": "号",
    "镑": "棒",
    "佢": "取",
    "諾": "诺",
    "鍧": "轰",
    "葉": "夜",
    "節": "节",
    "樹": "树",
    "舊": "就",
    "煜": "玉",
    "飛": "飞",
    "歲": "岁",
    "擊": "机",
    "灣": "弯",
    "蘇": "苏",
    "調": "掉",
    "產": "铲",
    "謝": "谢",
    "髮": "发",
    "冇": "帽",
    "劇": "巨",
    "優": "优",
    "費": "费",
    "铬": "个",
    "姦": "间",
    "廣": "广",
    "論": "论",
    "锰": "猛",
    "眾": "重",
    "遠": "远",
    "絲": "思",
    "灬": "标",
    "麗": "利",
    "覃": "谈",
    "烬": "进",
    "魯": "鲁",
    "橋": "桥",
    "钴": "古",
    "館": "管",
    "辊": "滚",
    "讀": "毒",
    "統": "统",
    "筆": "比",
    "蕩": "荡",
    "橫": "横",
    "盡": "紧",
    "錢": "钱",
    "柟": "南",
    "賞": "赏",
    "贰": "二",
    "題": "提",
    "戶": "互",
    "奷": "前",
    "泓": "红",
    "嘭": "砰",
    "楊": "羊",
    "計": "记",
    "薩": "萨",
    "陣": "镇",
    "茗": "明",
    "專": "专",
    "鬆": "松",
    "庫": "裤",
    "焱": "燕",
    "銉": "玉",
    "滅": "灭",
    "闄": "咬",
    "澤": "则",
    "梓": "子",
    "鄉": "相",
    "側": "册",
    "質": "至",
    "佔": "战",
    "復": "父",
    "剛": "刚",
    "吳": "无",
    "洩": "谢",
    "巳": "四",
    "鍦": "诗",
    "漢": "汉",
    "異": "意",
    "終": "中",
    "聽": "听",
    "職": "直",
    "標": "标",
    "賛": "赞",
    "咁": "干",
    "離": "离",
    "歡": "欢",
    "劍": "见",
    "靈": "零",
    "運": "运",
    "榛": "真",
    "叧": "寡",
    "歐": "欧",
    "領": "领",
    "搽": "茶",
    "換": "换",
    "绫": "零",
    "餘": "鱼",
    "椿": "春",
    "瀬": "赖",
    "萫": "向",
    "溆": "续",
    "藥": "要",
    "頂": "顶",
    "徵": "睁",
    "吋": "寸",
    "環": "环",
    "玮": "伟",
    "結": "节",
    "陽": "羊",
    "據": "巨",
    "興": "性",
    "詞": "瓷",
    "貝": "被",
    "敗": "败",
    "陸": "路",
    "儘": "紧",
    "亂": "乱",
    "紀": "记",
    "貴": "贵",
    "議": "意",
    "術": "树",
    "詩": "诗",
    "銀": "银",
    "锏": "减",
    "叻": "乐",
    "捻": "年",
    "嬴": "营",
    "確": "确",
    "砼": "同",
    "載": "在",
    "乜": "灭",
    "盅": "中",
    "頓": "顿",
    "鲲": "昆",
    "廠": "场",
    "钑": "萨",
    "姧": "间",
    "盤": "盘",
    "衛": "位",
    "讬": "拖",
    "獸": "瘦",
    "駐": "助",
    "発": "发",
    "盃": "杯",
    "喏": "诺",
    "镢": "觉",
    "黒": "黑",
    "僕": "葡",
    "偈": "记",
    "週": "周",
    "绾": "碗",
    "蓋": "概",
    "锺": "中",
    "溫": "温",
    "齊": "其",
    "幫": "帮",
    "斷": "断",
    "姝": "书",
    "飚": "标",
    "堝": "锅",
    "璟": "井",
    "祢": "迷",
    "乇": "拖",
    "藍": "蓝",
    "況": "矿",
    "昱": "玉",
    "綫": "现",
    "傷": "伤",
    "鐘": "中",
    "臧": "脏",
    "栾": "鸾",
    "鏄": "团",
    "囗": "维",
    "涧": "见",
    "護": "互",
    "罡": "刚",
    "浗": "求",
    "輕": "青",
    "馀": "鱼",
    "額": "额",
    "隻": "知",
    "湪": "团",
    "臨": "林",
    "奚": "西",
    "锛": "奔",
    "婧": "静",
    "錯": "错",
    "順": "顺",
    "浠": "西",
    "芮": "瑞",
    "続": "续",
    "奪": "夺",
    "預": "玉",
    "須": "需",
    "孫": "孙",
    "淩": "零",
    "賣": "卖",
    "細": "系",
    "顯": "显",
    "頁": "夜",
    "灞": "爸",
    "邬": "乌",
    "昇": "生",
    "茲": "姿",
    "彈": "蛋",
    "実": "石",
    "贏": "营",
    "狀": "壮",
    "營": "营",
    "菁": "精",
    "勢": "是",
    "畫": "话",
    "讚": "赞",
    "價": "驾",
    "闆": "板",
    "壓": "呀",
    "螭": "吃",
    "獨": "毒",
    "麥": "卖",
    "資": "姿",
    "牠": "他",
    "針": "真",
    "瑪": "马",
    "遊": "由",
    "講": "讲",
    "決": "觉",
    "説": "说",
    "喺": "习",
    "豔": "燕",
    "繼": "记",
    "姉": "子",
    "傑": "节",
    "斮": "错",
    "歸": "归",
    "歷": "利",
    "譯": "意",
    "鄭": "挣",
    "沢": "则",
    "錄": "路",
    "槍": "枪",
    "廳": "听",
    "趙": "照",
    "霏": "飞",
    "咻": "修",
    "鍏": "维",
    "貓": "猫",
    "殑": "情",
    "觀": "关",
    "慱": "团",
    "盧": "芦",
    "讜": "挡",
    "祇": "其",
    "扠": "插",
    "欸": "哀",
    "圍": "维",
    "炜": "伟",
    "缃": "相",
    "絶": "觉",
    "銈": "机",
    "綱": "刚",
    "態": "太",
    "騎": "其",
    "莊": "装",
    "麵": "面",
    "顔": "颜",
    "櫠": "费",
    "烏": "乌",
    "腳": "角",
    "談": "谈",
    "钼": "木",
    "寬": "宽",
    "榮": "容",
    "镉": "格",
    "莪": "额",
    "啐": "翠",
    "濠": "豪",
    "續": "续",
    "聞": "文",
    "钨": "乌",
    "蕙": "会",
    "課": "客",
    "嚒": "么",
    "毓": "玉",
    "漸": "见",
    "黶": "眼",
    "寧": "凝",
    "簡": "减",
    "養": "养",
    "湯": "汤",
    "垣": "原",
    "證": "挣",
    "旡": "记",
    "際": "记",
    "鈥": "火",
    "減": "减",
    "莳": "石",
    "韓": "含",
    "锭": "定",
    "凱": "凯",
    "響": "想",
    "珏": "觉",
    "伱": "你",
    "砷": "深",
    "禮": "李",
    "覺": "觉",
    "劵": "倦",
    "泠": "零",
    "濮": "葡",
    "諸": "朱",
    "艦": "见",
    "祗": "知",
    "醫": "一",
    "豐": "风",
    "卐": "万",
    "複": "父",
    "慶": "庆",
    "訂": "定",
    "賴": "赖",
    "谙": "安",
    "旳": "地",
    "織": "知",
    "硼": "朋",
    "鳥": "尿",
    "晁": "朝",
    "葭": "家",
    "鄰": "林",
    "涊": "年",
    "誠": "成",
    "爭": "睁",
    "補": "捕",
    "妺": "墨",
    "冊": "册",
    "笺": "间",
    "樽": "尊",
    "臉": "脸",
    "圩": "维",
    "塊": "快",
    "瑛": "应",
    "岱": "带",
    "紝": "任",
    "緒": "续",
    "識": "石",
    "円": "原",
    "巻": "倦",
    "負": "父",
    "枰": "平",
    "緊": "紧",
    "歆": "心",
    "敵": "敌",
    "鐐": "聊",
    "昃": "责",
    "藝": "意",
    "瀛": "营",
    "叟": "搜",
    "隼": "损",
    "翎": "零",
    "恁": "嫩",
    "専": "专",
    "願": "院",
    "気": "气",
    "埠": "不",
    "蔺": "吝",
    "參": "参",
    "轧": "亚",
    "睨": "逆",
    "铀": "由",
    "恵": "会",
    "採": "采",
    "仟": "前",
    "謂": "位",
    "韋": "维",
    "佘": "蛇",
    "鰭": "其",
    "岡": "刚",
    "込": "迂",
    "戲": "系",
    "捲": "卷",
    "煨": "微",
    "捌": "八",
    "飯": "饭",
    "黍": "鼠",
    "鎴": "习",
    "擡": "台",
    "紙": "指",
    "鎵": "家",
    "閫": "捆",
    "咲": "笑",
    "銆": "墨",
    "筱": "小",
    "軟": "软",
    "敤": "可",
    "啜": "踹",
    "顧": "固",
    "儀": "宜",
    "迩": "耳",
    "髙": "高",
    "賱": "允",
    "庾": "雨",
    "評": "平",
    "昀": "云",
    "責": "则",
    "併": "病",
    "喙": "会",
    "踫": "碰",
    "婕": "节",
    "逹": "达",
    "溴": "秀",
    "煸": "编",
    "铣": "洗",
    "鐧": "间",
    "倉": "仓",
    "稥": "相",
    "輝": "灰",
    "驚": "精",
    "翊": "意",
    "坶": "母",
    "様": "样",
    "遷": "前",
    "農": "农",
    "綠": "绿",
    "鸢": "冤",
    "鑽": "钻",
    "帛": "博",
    "忓": "干",
    "蔣": "讲",
    "緣": "原",
    "媓": "黄",
    "炁": "气",
    "镌": "捐",
    "钖": "羊",
    "輛": "亮",
    "壊": "坏",
    "钒": "烦",
    "厝": "错",
    "鋼": "刚",
    "馗": "奎",
    "釆": "变",
    "聿": "玉",
    "娆": "扰",
    "褃": "肯",
    "噴": "喷",
    "匯": "会",
    "嚴": "颜",
    "雞": "机",
    "莘": "深",
    "蛹": "永",
    "垸": "院",
    "晔": "夜",
    "谥": "是",
    "舐": "是",
    "孑": "节",
    "峯": "风",
    "镪": "枪",
    "圓": "原",
    "渇": "可",
    "剌": "啦",
    "涜": "毒",
    "掛": "挂",
    "測": "册",
    "貼": "贴",
    "睬": "采",
    "適": "是",
    "珈": "家",
    "徳": "德",
    "轄": "侠",
    "兇": "胸",
    "認": "任",
    "嶅": "敖",
    "惡": "恶",
    "嬫": "容",
    "鍛": "断",
    "狃": "纽",
    "協": "鞋",
    "査": "扎",
    "劃": "话",
    "巽": "训",
    "練": "练",
    "貨": "或",
    "嗳": "哀",
    "範": "饭",
    "寤": "物",
    "簽": "前",
    "祯": "真",
    "卅": "萨",
    "郜": "告",
    "趕": "感",
    "湫": "角",
    "晉": "进",
    "揚": "羊",
    "廟": "庙",
    "脫": "拖",
    "濃": "农",
    "竴": "村",
    "啖": "蛋",
    "醐": "胡",
    "椁": "果",
    "妤": "鱼",
    "衆": "重",
    "昶": "场",
    "讷": "呢",
    "鮑": "报",
    "钜": "巨",
    "鐢": "烦",
    "祐": "右",
    "勮": "巨",
    "戀": "练",
    "颦": "贫",
    "嚯": "或",
    "璁": "聪",
    "壞": "坏",
    "琰": "眼",
    "勐": "猛",
    "靜": "静",
    "鐨": "费",
    "诇": "胸",
    "呎": "尺",
    "顆": "科",
    "戦": "战",
    "闀": "红",
    "瑄": "宣",
    "賢": "闲",
    "賀": "贺",
    "訪": "访",
    "氲": "晕",
    "锉": "错",
    "隅": "鱼",
    "陰": "因",
    "獕": "催",
    "呂": "旅",
    "厍": "设",
    "嗗": "挖",
    "監": "间",
    "媽": "妈",
    "曉": "小",
    "嬢": "娘",
    "涼": "良",
    "牝": "聘",
    "娑": "缩",
    "瘠": "极",
    "剐": "寡",
    "懷": "怀",
    "谛": "地",
    "尋": "寻",
    "閣": "格",
    "俾": "比",
    "镭": "雷",
    "婦": "父",
    "圃": "普",
    "乛": "呀",
    "勞": "劳",
    "腚": "定",
    "貫": "灌",
    "錦": "紧",
    "癣": "选",
    "頒": "班",
    "丅": "下",
    "賷": "机",
    "蓟": "记",
    "嬩": "鱼",
    "蓮": "连",
    "遒": "求",
    "忻": "心",
    "鍒": "柔",
    "堇": "紧",
    "輸": "书",
    "荿": "成",
    "菈": "拉",
    "豬": "朱",
    "谌": "陈",
    "珮": "配",
    "贮": "助",
    "閭": "驴",
    "凊": "庆",
    "贊": "赞",
    "徹": "撤",
    "札": "炸",
    "産": "铲",
    "焗": "局",
    "俪": "利",
    "呷": "嘎",
    "喬": "桥",
    "檔": "荡",
    "雖": "虽",
    "歎": "探",
    "闇": "按",
    "襲": "习",
    "嶨": "学",
    "凈": "静",
    "敕": "赤",
    "執": "直",
    "噸": "蹲",
    "枓": "抖",
    "飲": "引",
    "毗": "皮",
    "猢": "胡",
    "膘": "标",
    "廢": "费",
    "遺": "宜",
    "筠": "云",
    "壇": "谈",
    "敝": "必",
    "枧": "减",
    "犟": "降",
    "奮": "愤",
    "钡": "被",
    "財": "才",
    "塬": "原",
    "忚": "西",
    "孬": "脑",
    "氩": "亚",
    "槿": "紧",
    "钯": "靶",
    "髒": "脏",
    "夔": "奎",
    "曆": "利",
    "腦": "脑",
    "泤": "四",
    "浚": "俊",
    "嶂": "帐",
    "輻": "福",
    "杷": "爬",
    "轶": "意",
    "嘬": "踹",
    "燈": "灯",
    "髻": "记",
    "伧": "仓",
    "揩": "开",
    "娉": "平",
    "險": "显",
    "珞": "落",
    "剜": "弯",
    "構": "够",
    "濟": "记",
    "脈": "卖",
    "紗": "沙",
    "侑": "右",
    "頻": "贫",
    "誌": "至",
    "齒": "尺",
    "鍐": "宗",
    "幔": "慢",
    "姫": "机",
    "擬": "你",
    "伝": "云",
    "糸": "密",
    "抜": "拔",
    "宓": "密",
    "騷": "骚",
    "衝": "冲",
    "姣": "教",
    "規": "归",
    "蓓": "被",
    "謀": "谋",
    "毀": "毁",
    "譜": "普",
    "寵": "宠",
    "遑": "黄",
    "畀": "必",
    "銮": "鸾",
    "帋": "指",
    "箐": "庆",
    "搶": "抢",
    "锑": "踢",
    "鮮": "先",
    "缁": "姿",
    "阚": "罕",
    "掸": "胆",
    "桜": "应",
    "誤": "物",
    "瓤": "嚷",
    "蕭": "消",
    "噌": "层",
    "槌": "垂",
    "輔": "辅",
    "鏡": "静",
    "泷": "龙",
    "鳃": "塞",
    "椴": "断",
    "尙": "上",
    "雉": "至",
    "褌": "昆",
    "楔": "些",
    "邨": "村",
    "珩": "行",
    "溟": "明",
    "隱": "引",
    "氐": "低",
    "紋": "文",
    "冼": "显",
    "绥": "随",
    "淬": "翠",
    "抻": "陈",
    "馮": "逢",
    "贲": "奔",
    "駛": "使",
    "邝": "矿",
    "祼": "灌",
    "柘": "这",
    "斛": "胡",
    "掬": "居",
    "蕪": "无",
    "畢": "必",
    "鬥": "豆",
    "憑": "平",
    "習": "习",
    "檢": "减",
    "輯": "极",
    "坳": "奥",
    "購": "够",
    "啟": "起",
    "築": "助",
    "霁": "记",
    "釋": "是",
    "槼": "归",
    "弼": "必",
    "邰": "台",
    "蹶": "觉",
    "績": "机",
    "煦": "续",
    "嚟": "离",
    "対": "对",
    "緯": "伟",
    "矾": "烦",
    "賈": "假",
    "棄": "气",
    "瓯": "欧",
    "樾": "月",
    "徑": "静",
    "煙": "烟",
    "洟": "替",
    "殘": "残",
    "浔": "寻",
    "磬": "庆",
    "叴": "求",
    "闈": "维",
    "攝": "设",
    "稞": "科",
    "绉": "昼",
    "岫": "秀",
    "辭": "瓷",
    "増": "增",
    "塚": "种",
    "吣": "亲",
    "褋": "叠",
    "鷹": "应",
    "鳳": "奉",
    "燒": "烧",
    "瓴": "零",
    "鐡": "铁",
    "觸": "处",
    "氫": "青",
    "汛": "训",
    "跡": "机",
    "繞": "绕",
    "镙": "罗",
    "旻": "民",
    "咂": "匝",
    "玦": "觉",
    "噫": "一",
    "桿": "感",
    "爺": "爷",
    "卟": "捕",
    "訓": "训",
    "湴": "办",
    "沅": "原",
    "姹": "差",
    "嵇": "机",
    "滢": "营",
    "蟥": "黄",
    "缙": "进",
    "浼": "美",
    "顏": "颜",
    "垚": "摇",
    "獄": "玉",
    "堅": "间",
    "轟": "轰",
    "櫈": "凳",
    "戍": "树",
    "斬": "展",
    "瓚": "赞",
    "揖": "一",
    "帥": "帅",
    "扈": "互",
    "诪": "周",
    "呤": "另",
    "汆": "窜",
    "疣": "由",
    "亜": "亚",
    "軸": "轴",
    "昴": "帽",
    "箸": "助",
    "鑳": "见",
    "濕": "诗",
    "賓": "彬",
    "膣": "至",
    "瀨": "赖",
    "偉": "伟",
    "珺": "俊",
    "亓": "其",
    "啓": "起",
    "沣": "风",
    "澹": "蛋",
    "曳": "夜",
    "蒯": "快",
    "痂": "家",
    "爛": "烂",
    "階": "接",
    "彧": "玉",
    "蜃": "肾",
    "噙": "琴",
    "褉": "谢",
    "鄧": "凳",
    "壽": "瘦",
    "鷄": "机",
    "郗": "西",
    "偎": "微",
    "鈴": "零",
    "衿": "金",
    "俟": "其",
    "劑": "记",
    "賲": "宝",
    "蟲": "虫",
    "広": "广",
    "囍": "洗",
    "洵": "寻",
    "競": "静",
    "槃": "盘",
    "鶴": "贺",
    "锗": "者",
    "潤": "润",
    "殒": "允",
    "苓": "零",
    "縮": "缩",
    "厜": "嘴",
    "禌": "姿",
    "铳": "冲",
    "嶺": "领",
    "醚": "迷",
    "菀": "碗",
    "鹽": "颜",
    "癡": "吃",
    "宥": "右",
    "註": "助",
    "濂": "连",
    "薨": "轰",
    "鲛": "教",
    "舂": "冲",
    "棟": "动",
    "颉": "节",
    "閑": "闲",
    "淺": "浅",
    "彜": "宜",
    "捱": "埃",
    "齡": "零",
    "銷": "消",
    "慘": "惨",
    "滛": "银",
    "荃": "全",
    "辇": "年",
    "錶": "表",
    "審": "审",
    "訊": "训",
    "繪": "会",
    "軌": "鬼",
    "吶": "那",
    "勁": "进",
    "貞": "真",
    "讘": "聂",
    "雒": "落",
    "锆": "告",
    "妣": "比",
    "潞": "路",
    "吠": "费",
    "魈": "消",
    "鄢": "烟",
    "栫": "见",
    "倆": "俩",
    "嚐": "长",
    "佈": "不",
    "陂": "杯",
    "虛": "需",
    "诲": "会",
    "銅": "同",
    "谒": "夜",
    "埴": "直",
    "瘀": "迂",
    "噘": "绝",
    "違": "维",
    "鄌": "唐",
    "膷": "相",
    "骊": "离",
    "囯": "国",
    "暫": "赞",
    "鉄": "直",
    "処": "楚",
    "拚": "判",
    "錫": "西",
    "郦": "利",
    "嘢": "也",
    "閃": "闪",
    "仝": "同",
    "讛": "意",
    "潔": "节",
    "曞": "利",
    "濱": "彬",
    "耢": "烙",
    "邁": "卖",
    "鍾": "中",
    "讫": "气",
    "紹": "绍",
    "趺": "夫",
    "祎": "一",
    "緻": "至",
    "唿": "呼",
    "犲": "柴",
    "煳": "胡",
    "賵": "奉",
    "膠": "教",
    "噉": "蛋",
    "愬": "速",
    "恆": "横",
    "彥": "燕",
    "団": "团",
    "夥": "火",
    "锟": "昆",
    "琏": "脸",
    "綋": "红",
    "獻": "现",
    "戸": "互",
    "雜": "杂",
    "獅": "诗",
    "霧": "物",
    "憲": "现",
    "撃": "机",
    "贈": "赠",
    "飨": "想",
    "櫻": "应",
    "岬": "假",
    "卍": "万",
    "逄": "旁",
    "氳": "晕",
    "蒽": "恩",
    "祿": "路",
    "鐏": "尊",
    "遜": "训",
    "変": "变",
    "濯": "着",
    "擺": "摆",
    "垠": "银",
    "淨": "静",
    "煊": "宣",
    "軳": "袍",
    "旌": "精",
    "殁": "墨",
    "嶋": "导",
    "鍗": "提",
    "皋": "高",
    "骋": "成",
    "谞": "需",
    "譽": "玉",
    "蟻": "以",
    "搴": "前",
    "訴": "速",
    "鯉": "李",
    "蟿": "气",
    "獾": "欢",
    "菡": "汉",
    "丟": "丢",
    "偌": "弱",
    "嗄": "啊",
    "钺": "月",
    "崏": "民",
    "濉": "虽",
    "忿": "愤",
    "硌": "个",
    "璎": "应",
    "铄": "硕",
    "獒": "敖",
    "鋒": "风",
    "踞": "巨",
    "炀": "羊",
    "壯": "壮",
    "汙": "乌",
    "関": "关",
    "捨": "舍",
    "粵": "月",
    "琨": "昆",
    "颍": "影",
    "賜": "次",
    "夲": "掏",
    "郢": "影",
    "淚": "泪",
    "赊": "舍",
    "礎": "楚",
    "豊": "李",
    "夾": "家",
    "芈": "米",
    "穩": "稳",
    "诰": "告",
    "翌": "意",
    "閉": "必",
    "鳴": "明",
    "鍋": "锅",
    "垅": "垄",
    "鎖": "锁",
    "潃": "修",
    "缦": "慢",
    "爐": "芦",
    "嗟": "接",
    "縱": "宗",
    "摺": "哲",
    "鋪": "瀑",
    "昰": "是",
    "箓": "路",
    "澧": "李",
    "馥": "父",
    "侗": "动",
    "歩": "不",
    "毎": "美",
    "瑨": "进",
    "秆": "感",
    "姒": "四",
    "椽": "传",
    "蹤": "宗",
    "鹹": "闲",
    "畦": "其",
    "挿": "插",
    "掣": "撤",
    "綾": "零",
    "鏉": "瘦",
    "軒": "宣",
    "芠": "文",
    "齋": "摘",
    "岄": "月",
    "昝": "赞",
    "潛": "钱",
    "伢": "牙",
    "鐪": "鲁",
    "蕃": "翻",
    "恥": "尺",
    "討": "讨",
    "厠": "册",
    "箩": "罗",
    "彡": "山",
    "弁": "变",
    "貢": "共",
    "鴻": "红",
    "氬": "亚",
    "墻": "强",
    "芾": "费",
    "亳": "博",
    "鸩": "镇",
    "牆": "强",
    "譚": "谈",
    "鲧": "滚",
    "铖": "成",
    "氡": "东",
    "蕞": "最",
    "汚": "乌",
    "缨": "应",
    "埙": "熏",
    "饷": "想",
    "闊": "扩",
    "铱": "一",
    "钤": "钱",
    "漲": "长",
    "擢": "着",
    "殼": "咳",
    "饧": "唐",
    "枳": "指",
    "埂": "梗",
    "賊": "贼",
    "働": "动",
    "哂": "审",
    "鬲": "格",
    "弋": "意",
    "斫": "着",
    "瞇": "眯",
    "槊": "硕",
    "託": "拖",
    "嗬": "喝",
    "龜": "归",
    "锶": "思",
    "潵": "洒",
    "唸": "念",
    "杈": "插",
    "箕": "机",
    "崥": "皮",
    "濆": "坟",
    "繫": "系",
    "騰": "腾",
    "銘": "明",
    "蚩": "吃",
    "椤": "罗",
    "隗": "奎",
    "笅": "角",
    "祕": "密",
    "滾": "滚",
    "怛": "达",
    "檫": "茶",
    "療": "聊",
    "稅": "睡",
    "韻": "运",
    "皎": "角",
    "鍊": "练",
    "総": "总",
    "渑": "免",
    "铵": "俺",
    "椹": "肾",
    "舫": "访",
    "盜": "到",
    "遲": "持",
    "龐": "旁",
    "騙": "片",
    "煩": "烦",
    "溝": "勾",
    "俅": "求",
    "缐": "现",
    "飄": "飘",
    "颚": "恶",
    "雎": "居",
    "泗": "四",
    "賳": "灾",
    "褰": "前",
    "閒": "闲",
    "驗": "燕",
    "酆": "风",
    "炝": "呛",
    "犇": "奔",
    "猷": "由",
    "籌": "愁",
    "胫": "静",
    "塵": "陈",
    "荻": "敌",
    "暝": "明",
    "訾": "姿",
    "牒": "叠",
    "蟽": "达",
    "屍": "诗",
    "餌": "耳",
    "舖": "瀑",
    "铌": "尼",
    "劭": "绍",
    "熘": "溜",
    "盂": "鱼",
    "燮": "谢",
    "呔": "呆",
    "悅": "月",
    "尕": "尬",
    "彌": "迷",
    "獵": "裂",
    "恙": "样",
    "烃": "听",
    "涎": "闲",
    "岙": "奥",
    "貉": "豪",
    "铉": "炫",
    "崗": "岗",
    "鋁": "旅",
    "豕": "使",
    "蠻": "瞒",
    "俠": "侠",
    "桢": "真",
    "讗": "鞋",
    "镗": "汤",
    "埸": "意",
    "萼": "恶",
    "酔": "最",
    "餵": "位",
    "嬌": "教",
    "擋": "挡",
    "損": "损",
    "钽": "坦",
    "髯": "然",
    "幣": "必",
    "紒": "记",
    "囡": "喃",
    "淖": "闹",
    "覽": "懒",
    "氖": "奶",
    "轲": "科",
    "虬": "求",
    "鍥": "妾",
    "衾": "亲",
    "璜": "黄",
    "嵘": "容",
    "隣": "林",
    "揿": "亲",
    "拋": "抛",
    "峁": "帽",
    "莅": "利",
    "勬": "捐",
    "沱": "驮",
    "嗮": "赛",
    "绺": "柳",
    "甑": "赠",
    "鍵": "见",
    "篑": "溃",
    "迴": "回",
    "憩": "气",
    "図": "图",
    "証": "挣",
    "铟": "因",
    "愮": "摇",
    "粿": "果",
    "衹": "指",
    "牽": "前",
    "巿": "福",
    "棲": "七",
    "橾": "书",
    "晩": "碗",
    "録": "路",
    "豺": "柴",
    "璨": "灿",
    "诐": "必",
    "洺": "明",
    "颢": "号",
    "鬧": "闹",
    "艖": "插",
    "賺": "赚",
    "婀": "阿",
    "淦": "干",
    "绡": "消",
    "迳": "静",
    "悶": "闷",
    "艷": "燕",
    "勳": "熏",
    "蜇": "遮",
    "蒼": "仓",
    "笣": "包",
    "欤": "鱼",
    "嬲": "尿",
    "旸": "羊",
    "売": "卖",
    "蓦": "墨",
    "喪": "丧",
    "褔": "父",
    "颔": "汉",
    "苒": "染",
    "隠": "引",
    "觞": "伤",
    "兗": "眼",
    "弾": "蛋",
    "嬬": "如",
    "泑": "优",
    "姘": "拼",
    "琮": "从",
    "廋": "搜",
    "阍": "昏",
    "椋": "良",
    "嗕": "入",
    "囩": "云",
    "纾": "书",
    "絵": "会",
    "鐝": "觉",
    "祙": "妹",
    "堀": "哭",
    "铋": "必",
    "桉": "安",
    "礦": "矿",
    "鐫": "捐",
    "祚": "做",
    "幇": "帮",
    "滦": "鸾",
    "仞": "任",
    "鎻": "锁",
    "阕": "确",
    "彲": "吃",
    "傾": "青",
    "箬": "弱",
    "熶": "窜",
    "皴": "村",
    "馊": "搜",
    "湄": "梅",
    "骐": "其",
    "镓": "家",
    "靛": "电",
    "悪": "恶",
    "徕": "来",
    "鯰": "年",
    "駅": "意",
    "龋": "曲",
    "筵": "颜",
    "洙": "朱",
    "犼": "吼",
    "廿": "念",
    "霭": "矮",
    "鲎": "后",
    "芶": "狗",
    "呯": "平",
    "塗": "图",
    "妝": "装",
    "鹄": "古",
    "佚": "意",
    "嘁": "七",
    "樑": "良",
    "薦": "见",
    "嗚": "乌",
    "勸": "劝",
    "楮": "楚",
    "砣": "驮",
    "葳": "微",
    "棰": "垂",
    "舷": "闲",
    "菅": "间",
    "誘": "右",
    "夊": "虽",
    "頗": "坡",
    "潼": "同",
    "畈": "饭",
    "琬": "碗",
    "佸": "活",
    "邺": "夜",
    "姵": "配",
    "郵": "由",
    "儲": "楚",
    "鑑": "见",
    "旃": "占",
    "躍": "月",
    "珉": "民",
    "皬": "和",
    "苡": "以",
    "贻": "宜",
    "鹜": "物",
    "駕": "驾",
    "馔": "赚",
    "濛": "盟",
    "仺": "仓",
    "鍔": "恶",
    "遞": "地",
    "鈺": "玉",
    "災": "灾",
    "偸": "偷",
    "邕": "庸",
    "诤": "挣",
    "蜱": "皮",
    "砾": "利",
    "禛": "真",
    "翳": "意",
    "潋": "练",
    "钚": "不",
    "醴": "李",
    "紐": "纽",
    "殳": "书",
    "偃": "眼",
    "碴": "茶",
    "猶": "由",
    "偽": "伟",
    "嚌": "记",
    "谂": "审",
    "蜞": "其",
    "刪": "山",
    "婳": "话",
    "镒": "意",
    "慮": "绿",
    "菏": "和",
    "癥": "睁",
    "褍": "端",
    "樺": "话",
    "唵": "俺",
    "沤": "欧",
    "恣": "字",
    "欽": "亲",
    "栎": "利",
    "堜": "练",
    "潆": "营",
    "掃": "扫",
    "鎏": "刘",
    "汨": "密",
    "傝": "探",
    "繚": "聊",
    "唎": "利",
    "瀵": "愤",
    "賮": "进",
    "墜": "缀",
    "峒": "动",
    "曌": "照",
    "萘": "耐",
    "剋": "客",
    "鼐": "耐",
    "睑": "减",
    "楹": "营",
    "乗": "成",
    "讞": "燕",
    "謎": "迷",
    "鏃": "族",
    "魑": "吃",
    "卮": "知",
    "輩": "被",
    "賭": "堵",
    "菸": "烟",
    "醬": "降",
    "淵": "冤",
    "铯": "色",
    "煉": "练",
    "蔵": "脏",
    "杓": "标",
    "燊": "深",
    "渌": "路",
    "哋": "叠",
    "琚": "居",
    "榀": "品",
    "襹": "诗",
    "虢": "国",
    "瑗": "院",
    "睢": "虽",
    "繳": "角",
    "诘": "极",
    "罵": "骂",
    "铍": "批",
    "埄": "崩",
    "膑": "宾",
    "挶": "居",
    "鱸": "芦",
    "遙": "摇",
    "粈": "柔",
    "擾": "扰",
    "擔": "单",
    "罷": "爸",
    "潰": "溃",
    "炅": "窘",
    "诓": "框",
    "戕": "枪",
    "恔": "角",
    "壘": "垒",
    "遽": "巨",
    "鴨": "呀",
    "邴": "饼",
    "硪": "卧",
    "纭": "云",
    "虱": "诗",
    "揮": "灰",
    "狍": "袍",
    "堑": "欠",
    "廈": "煞",
    "囬": "回",
    "澍": "树",
    "诳": "狂",
    "飏": "羊",
    "磚": "专",
    "脳": "脑",
    "枋": "方",
    "浄": "静",
    "囿": "右",
    "讙": "欢",
    "眞": "真",
    "搾": "咋",
    "钭": "偷",
    "慳": "前",
    "谯": "桥",
    "倏": "书",
    "凪": "指",
    "唛": "骂",
    "缶": "否",
    "痈": "庸",
    "脣": "纯",
    "縛": "父",
    "憂": "优",
    "糧": "良",
    "螯": "敖",
    "畼": "唱",
    "翦": "减",
    "溼": "诗",
    "鐣": "称",
    "娌": "李",
    "釐": "离",
    "妫": "归",
    "蟺": "善",
    "墦": "烦",
    "钕": "女",
    "玑": "机",
    "钏": "串",
    "卩": "节",
    "堥": "毛",
    "氰": "情",
    "谗": "缠",
    "銳": "瑞",
    "璩": "取",
    "尐": "节",
    "樞": "书",
    "寳": "宝",
    "巖": "颜",
    "貸": "带",
    "绦": "掏",
    "銇": "泪",
    "疝": "善",
    "铑": "老",
    "膽": "胆",
    "詠": "永",
    "曬": "筛",
    "粲": "灿",
    "栀": "知",
    "钎": "前",
    "疃": "团",
    "愽": "博",
    "窮": "穷",
    "窩": "窝",
    "铡": "炸",
    "暢": "唱",
    "剎": "沙",
    "鵬": "朋",
    "搵": "问",
    "湧": "永",
    "笆": "八",
    "緩": "缓",
    "偻": "楼",
    "邈": "秒",
    "衞": "位",
    "郃": "和",
    "钷": "坡",
    "胄": "昼",
    "晞": "西",
    "泮": "判",
    "滁": "除",
    "霰": "现",
    "桁": "横",
    "掼": "灌",
    "闖": "闯",
    "撥": "波",
    "呖": "利",
    "嚇": "下",
    "棹": "照",
    "怏": "样",
    "埭": "带",
    "絡": "落",
    "镞": "族",
    "癒": "玉",
    "洌": "裂",
    "蹚": "汤",
    "収": "收",
    "涞": "来",
    "亻": "人",
    "綜": "宗",
    "懸": "旋",
    "燚": "意",
    "蓼": "了",
    "洇": "因",
    "痢": "利",
    "庢": "至",
    "濋": "楚",
    "帯": "带",
    "咝": "思",
    "罰": "罚",
    "彎": "弯",
    "讟": "毒",
    "阡": "前",
    "鍜": "侠",
    "膻": "山",
    "颡": "桑",
    "赓": "耕",
    "詳": "翔",
    "槎": "茶",
    "桷": "觉",
    "懋": "帽",
    "冫": "冰",
    "秸": "接",
    "醮": "教",
    "氽": "吞",
    "讴": "欧",
    "兂": "赞",
    "嵐": "蓝",
    "鸷": "至",
    "郞": "狼",
    "囉": "罗",
    "魃": "拔",
    "鼋": "原",
    "籠": "龙",
    "铧": "华",
    "撲": "铺",
    "擁": "庸",
    "莤": "速",
    "畲": "舍",
    "晌": "赏",
    "姮": "横",
    "儇": "宣",
    "澪": "零",
    "壅": "庸",
    "驅": "区",
    "禪": "缠",
    "靥": "夜",
    "詔": "照",
    "嗰": "葛",
    "鬃": "宗",
    "尓": "耳",
    "亟": "极",
    "糁": "三",
    "擤": "醒",
    "竜": "龙",
    "羸": "雷",
    "錾": "赞",
    "瑠": "刘",
    "湊": "凑",
    "楣": "梅",
    "巜": "快",
    "苫": "山",
    "芃": "朋",
    "罒": "网",
    "僮": "同",
    "哞": "某",
    "宀": "眠",
    "単": "单",
    "鎯": "狼",
    "媞": "是",
    "謙": "前",
    "愍": "敏",
    "虺": "灰",
    "鑰": "要",
    "樘": "唐",
    "沵": "米",
    "骅": "华",
    "菓": "果",
    "锝": "德",
    "醯": "西",
    "凍": "动",
    "钹": "博",
    "遼": "聊",
    "悌": "替",
    "餅": "饼",
    "瞋": "陈",
    "矽": "系",
    "蹟": "机",
    "奂": "换",
    "楓": "风",
    "撿": "减",
    "峤": "教",
    "佃": "电",
    "墒": "伤",
    "倖": "性",
    "蠍": "些",
    "眀": "明",
    "漿": "将",
    "檯": "台",
    "羣": "群",
    "疊": "叠",
    "佺": "全",
    "扦": "前",
    "蕈": "训",
    "吽": "轰",
    "嘆": "探",
    "涪": "福",
    "賤": "见",
    "珥": "耳",
    "孛": "被",
    "簋": "鬼",
    "苕": "勺",
    "鎰": "意",
    "藐": "秒",
    "氱": "养",
    "涸": "和",
    "撫": "辅",
    "閽": "昏",
    "畝": "母",
    "芩": "琴",
    "嘗": "长",
    "猹": "茶",
    "彘": "至",
    "聰": "聪",
    "淸": "青",
    "泫": "炫",
    "観": "关",
    "醜": "丑",
    "桅": "维",
    "瑷": "爱",
    "莜": "由",
    "庣": "挑",
    "癿": "茄",
    "氚": "穿",
    "眦": "字",
    "堃": "昆",
    "篙": "高",
    "瘋": "风",
    "淙": "从",
    "耒": "垒",
    "煅": "断",
    "穂": "岁",
    "鉆": "搀",
    "凜": "吝",
    "鐸": "夺",
    "獩": "会",
    "乄": "五",
    "阗": "田",
    "罂": "应",
    "蘅": "横",
    "啱": "颜",
    "瑭": "唐",
    "芪": "其",
    "屼": "物",
    "鬚": "需",
    "洧": "伟",
    "傢": "家",
    "阇": "督",
    "閘": "炸",
    "搖": "摇",
    "氘": "刀",
    "逑": "求",
    "镬": "或",
    "娛": "鱼",
    "嫒": "爱",
    "縫": "奉",
    "傘": "三",
    "嵋": "梅",
    "焓": "含",
    "蠀": "刺",
    "蠡": "离",
    "湟": "黄",
    "逯": "路",
    "袂": "妹",
    "耆": "其",
    "鉅": "巨",
    "褟": "他",
    "妗": "进",
    "綿": "眠",
    "賦": "父",
    "穔": "黄",
    "谝": "偏",
    "邙": "忙",
    "炔": "贵",
    "琇": "秀",
    "钅": "金",
    "篤": "堵",
    "嵴": "几",
    "穀": "古",
    "両": "两",
    "彙": "会",
    "铨": "全",
    "畑": "田",
    "祜": "互",
    "涙": "泪",
    "撷": "鞋",
    "牍": "毒",
    "刂": "刀",
    "夐": "胸",
    "吔": "也",
    "貘": "墨",
    "啻": "赤",
    "鎷": "马",
    "締": "地",
    "鏁": "锁",
    "舄": "系",
    "稔": "忍",
    "児": "而",
    "懶": "懒",
    "忤": "五",
    "貪": "贪",
    "艙": "仓",
    "铊": "他",
    "鱗": "林",
    "隷": "利",
    "蠹": "度",
    "骜": "奥",
    "砦": "寨",
    "垌": "动",
    "涐": "额",
    "湍": "团",
    "埕": "成",
    "镧": "蓝",
    "獐": "张",
    "綁": "绑",
    "铼": "来",
    "脩": "修",
    "岷": "民",
    "効": "笑",
    "駿": "俊",
    "廚": "除",
    "褘": "灰",
    "嫱": "强",
    "刈": "意",
    "孺": "如",
    "恚": "会",
    "灘": "贪",
    "貧": "贫",
    "綦": "其",
    "爨": "窜",
    "闂": "红",
    "顼": "需",
    "摀": "五",
    "滃": "瓮",
    "閿": "文",
    "溧": "利",
    "獣": "瘦",
    "紛": "分",
    "竦": "耸",
    "菽": "书",
    "莒": "举",
    "婐": "我",
    "畿": "机",
    "蚬": "显",
    "峋": "寻",
    "栢": "摆",
    "隸": "利",
    "缗": "民",
    "孓": "觉",
    "阆": "狼",
    "泺": "落",
    "霈": "配",
    "忝": "舔",
    "兖": "眼",
    "饯": "见",
    "戯": "呼",
    "呰": "子",
    "甙": "带",
    "嫚": "慢",
    "綴": "缀",
    "镄": "费",
    "癞": "赖",
    "迨": "带",
    "绔": "裤",
    "腆": "舔",
    "肅": "速",
    "臥": "卧",
    "圻": "其",
    "瘘": "漏",
    "屢": "旅",
    "酢": "促",
    "辻": "石",
    "擴": "扩",
    "撳": "亲",
    "従": "从",
    "憶": "意",
    "鯨": "精",
    "貿": "帽",
    "珣": "寻",
    "嵬": "维",
    "碩": "硕",
    "艶": "燕",
    "壩": "爸",
    "穎": "影",
    "曷": "和",
    "銜": "闲",
    "硐": "动",
    "韫": "运",
    "寛": "宽",
    "颀": "其",
    "谟": "魔",
    "滟": "燕",
    "笄": "机",
    "碁": "其",
    "閥": "罚",
    "缑": "勾",
    "鍝": "鱼",
    "钌": "了",
    "苌": "长",
    "豢": "换",
    "閩": "敏",
    "骶": "底",
    "棂": "零",
    "鹞": "要",
    "鑒": "见",
    "瓊": "穷",
    "儍": "傻",
    "愠": "运",
    "屙": "阿",
    "孖": "妈",
    "钿": "电",
    "兲": "天",
    "锷": "恶",
    "轭": "恶",
    "珪": "归",
    "礡": "博",
    "叕": "着",
    "丌": "机",
    "壺": "胡",
    "蛭": "至",
    "墎": "锅",
    "帏": "维",
    "徇": "训",
    "詢": "寻",
    "笪": "达",
    "吥": "不",
    "殛": "极",
    "杲": "搞",
    "滬": "互",
    "診": "枕",
    "隹": "追",
    "磙": "滚",
    "堣": "鱼",
    "乺": "锁",
    "苋": "现",
    "雹": "薄",
    "啶": "定",
    "繇": "摇",
    "凫": "福",
    "抟": "团",
    "沄": "云",
    "翕": "西",
    "玎": "丁",
    "鏍": "罗",
    "僑": "桥",
    "虧": "亏",
    "篁": "黄",
    "瑀": "雨",
    "嵊": "胜",
    "柰": "耐",
    "婺": "物",
    "洹": "环",
    "喰": "参",
    "钇": "以",
    "镊": "聂",
    "褲": "裤",
    "腓": "肥",
    "蕲": "其",
    "檄": "习",
    "笉": "寝",
    "陟": "至",
    "珲": "灰",
    "矇": "盟",
    "讻": "胸",
    "佗": "驮",
    "轸": "枕",
    "垴": "脑",
    "崧": "松",
    "揾": "问",
    "铈": "是",
    "渾": "魂",
    "丼": "井",
    "尛": "魔",
    "頌": "宋",
    "凼": "荡",
    "挛": "鸾",
    "鍖": "尘",
    "吡": "比",
    "挈": "妾",
    "佾": "意",
    "黱": "带",
    "俎": "组",
    "赭": "者",
    "趨": "区",
    "嬭": "奶",
    "撐": "称",
    "磯": "机",
    "臟": "藏",
    "滄": "仓",
    "薜": "必",
    "觚": "姑",
    "旖": "以",
    "艏": "手",
    "苻": "福",
    "経": "精",
    "獭": "塔",
    "纏": "缠",
    "纔": "才",
    "鑾": "鸾",
    "赟": "晕",
    "亍": "处",
    "芫": "颜",
    "呓": "意",
    "蓁": "真",
    "馳": "持",
    "禍": "或",
    "扞": "感",
    "帳": "帐",
    "氙": "先",
    "缈": "秒",
    "擘": "掰",
    "庖": "袍",
    "骧": "相",
    "訣": "觉",
    "墊": "电",
    "瀧": "龙",
    "嫰": "嫩",
    "刖": "月",
    "禦": "玉",
    "姩": "念",
    "尅": "客",
    "剣": "见",
    "醅": "培",
    "锕": "啊",
    "圪": "歌",
    "雛": "除",
    "鑲": "相",
    "繩": "生",
    "玠": "借",
    "掾": "院",
    "倌": "关",
    "笏": "互",
    "螫": "是",
    "茆": "毛",
    "瑁": "帽",
    "疽": "居",
    "県": "现",
    "擇": "则",
    "頃": "请",
    "绶": "瘦",
    "舛": "喘",
    "唌": "闲",
    "偵": "真",
    "欄": "蓝",
    "谪": "哲",
    "転": "转",
    "恽": "运",
    "谶": "衬",
    "褜": "袍",
    "恸": "痛",
    "萁": "其",
    "娈": "鸾",
    "飽": "宝",
    "饴": "宜",
    "丷": "八",
    "孃": "娘",
    "紮": "匝",
    "綉": "透",
    "羟": "抢",
    "鎬": "号",
    "鍟": "生",
    "囘": "回",
    "賬": "帐",
    "鄞": "银",
    "钍": "土",
    "闢": "屁",
    "錘": "垂",
    "郏": "夹",
    "脘": "碗",
    "鳅": "秋",
    "靚": "静",
    "楦": "炫",
    "膩": "逆",
    "辯": "变",
    "岢": "可",
    "鈈": "批",
    "燧": "岁",
    "債": "寨",
    "楸": "秋",
    "曠": "矿",
    "娚": "南",
    "龇": "姿",
    "绀": "干",
    "剡": "善",
    "慣": "灌",
    "腸": "长",
    "傩": "挪",
    "曈": "同",
    "蝾": "容",
    "歴": "利",
    "帰": "归",
    "磔": "哲",
    "郧": "云",
    "侶": "旅",
    "漁": "鱼",
    "佶": "极",
    "冨": "父",
    "臌": "古",
    "醪": "劳",
    "樯": "强",
    "魍": "网",
    "槸": "意",
    "佹": "鬼",
    "蝦": "虾",
    "鯛": "雕",
    "逅": "后",
    "鸫": "东",
    "鹳": "灌",
    "硷": "减",
    "嚩": "魔",
    "篠": "小",
    "锲": "妾",
    "沭": "树",
    "嚥": "燕",
    "乂": "意",
    "矬": "搓",
    "锘": "诺",
    "诮": "巧",
    "绠": "梗",
    "庠": "翔",
    "餓": "恶",
    "稜": "棱",
    "祉": "指",
    "掴": "乖",
    "噁": "饿",
    "薬": "要",
    "厩": "就",
    "籤": "前",
    "囱": "聪",
    "萸": "鱼",
    "読": "毒",
    "囹": "零",
    "擠": "几",
    "颏": "科",
    "繆": "谋",
    "栄": "容",
    "綺": "起",
    "穰": "嚷",
    "疔": "丁",
    "莼": "纯",
    "凃": "图",
    "叢": "从",
    "镝": "低",
    "鞑": "达",
    "蹼": "普",
    "槬": "话",
    "償": "长",
    "簟": "电",
    "腈": "精",
    "庹": "妥",
    "嗵": "通",
    "鎺": "组",
    "粍": "哲",
    "蘋": "平",
    "窈": "咬",
    "郄": "妾",
    "钲": "睁",
    "屾": "深",
    "旎": "你",
    "桡": "扰",
    "鹬": "玉",
    "暈": "晕",
    "蘿": "罗",
    "艂": "逢",
    "赉": "赖",
    "聶": "聂",
    "嶈": "枪",
    "瞑": "明",
    "焐": "物",
    "鏅": "修",
    "踵": "种",
    "滓": "子",
    "楗": "见",
    "巔": "颠",
    "碓": "对",
    "琊": "牙",
    "碛": "气",
    "嫵": "五",
    "庡": "以",
    "釣": "掉",
    "钬": "火",
    "厳": "颜",
    "冦": "扣",
    "襦": "如",
    "卝": "矿",
    "雫": "哪",
    "諡": "是",
    "苆": "切",
    "訷": "深",
    "咭": "机",
    "璘": "林",
    "喚": "换",
    "锨": "先",
    "惇": "蹲",
    "緑": "绿",
    "氭": "东",
    "玚": "唱",
    "柞": "咋",
    "锴": "凯",
    "毖": "必",
    "馐": "修",
    "湁": "赤",
    "鄣": "张",
    "儆": "井",
    "芘": "皮",
    "俚": "李",
    "埝": "念",
    "喑": "因",
    "觥": "工",
    "囟": "信",
    "肓": "荒",
    "蠛": "灭",
    "黜": "处",
    "歙": "设",
    "狹": "侠",
    "鬻": "玉",
    "亀": "归",
    "柢": "底",
    "誕": "蛋",
    "啮": "聂",
    "谰": "蓝",
    "亊": "是",
    "佽": "次",
    "亅": "觉",
    "峇": "八",
    "闩": "拴",
    "棢": "网",
    "圧": "呀",
    "樁": "装",
    "觪": "星",
    "夋": "群",
    "鋆": "云",
    "瀰": "迷",
    "呶": "脑",
    "氺": "水",
    "葯": "要",
    "圏": "圈",
    "螟": "明",
    "乀": "福",
    "攜": "鞋",
    "仵": "五",
    "粳": "精",
    "郅": "至",
    "爿": "盘",
    "醣": "唐",
    "濤": "掏",
    "荑": "提",
    "沨": "风",
    "臬": "聂",
    "垱": "荡",
    "榷": "确",
    "啭": "赚",
    "鐩": "岁",
    "钃": "竹",
    "膚": "夫",
    "潺": "缠",
    "跖": "直",
    "薙": "替",
    "闳": "红",
    "玳": "带",
    "铷": "如",
    "腴": "鱼",
    "幵": "间",
    "呒": "五",
    "鹗": "恶",
    "蟬": "缠",
    "戢": "极",
    "荇": "性",
    "欑": "攒",
    "誅": "朱",
    "鍘": "炸",
    "雠": "愁",
    "趐": "血",
    "陞": "生",
    "滘": "教",
    "攤": "贪",
    "値": "直",
    "槑": "梅",
    "牸": "字",
    "塩": "颜",
    "绗": "行",
    "賯": "胸",
    "笕": "减",
    "籃": "蓝",
    "寢": "寝",
    "垟": "羊",
    "鱷": "恶",
    "篦": "必",
    "鑻": "判",
    "俦": "愁",
    "眚": "省",
    "呋": "夫",
    "駒": "居",
    "胔": "字",
    "鑄": "助",
    "驷": "四",
    "楫": "极",
    "绌": "处",
    "漉": "路",
    "崝": "睁",
    "撚": "年",
    "唳": "利",
    "瑩": "营",
    "滝": "龙",
    "猊": "尼",
    "彀": "够",
    "焼": "烧",
    "笂": "完",
    "闘": "豆",
    "猗": "一",
    "嗐": "害",
    "叒": "弱",
    "凇": "松",
    "碲": "地",
    "菰": "姑",
    "堺": "借",
    "虻": "盟",
    "誼": "意",
    "珯": "老",
    "裾": "居",
    "憐": "连",
    "袢": "判",
    "姀": "和",
    "滙": "会",
    "検": "减",
    "溏": "唐",
    "髪": "发",
    "焘": "到",
    "槔": "高",
    "龅": "包",
    "魉": "两",
    "櫃": "贵",
    "拏": "拿",
    "脲": "尿",
    "缟": "搞",
    "媪": "袄",
    "厲": "利",
    "堯": "摇",
    "臘": "蜡",
    "兕": "四",
    "踅": "学",
    "箅": "必",
    "圉": "雨",
    "婠": "弯",
    "悭": "前",
    "敘": "续",
    "夂": "指",
    "褨": "锁",
    "笈": "极",
    "亾": "王",
    "鲢": "连",
    "賰": "春",
    "騒": "骚",
    "怿": "意",
    "稲": "到",
    "昐": "分",
    "樸": "普",
    "笳": "家",
    "疥": "借",
    "験": "燕",
    "箇": "个",
    "逋": "不",
    "欹": "一",
    "痾": "阿",
    "埵": "朵",
    "鵝": "额",
    "嗥": "豪",
    "砟": "眨",
    "誊": "腾",
    "茔": "营",
    "贇": "晕",
    "屮": "撤",
    "笞": "吃",
    "剝": "波",
    "闼": "踏",
    "鉛": "前",
    "钣": "板",
    "綝": "陈",
    "杪": "秒",
    "翀": "冲",
    "腭": "恶",
    "郤": "系",
    "僦": "就",
    "閱": "月",
    "钪": "抗",
    "鑿": "凿",
    "齣": "出",
    "舸": "葛",
    "汜": "四",
    "熷": "增",
    "崑": "昆",
    "僖": "西",
    "丄": "上",
    "厭": "燕",
    "諭": "玉",
    "枞": "聪",
    "烝": "睁",
    "嬰": "应",
    "咥": "系",
    "蚓": "引",
    "诜": "深",
    "溱": "琴",
    "犻": "博",
    "缄": "间",
    "鸮": "消",
    "篾": "灭",
    "菘": "松",
    "饒": "扰",
    "兘": "使",
    "唻": "赖",
    "鰻": "瞒",
    "璺": "问",
    "叡": "瑞",
    "劢": "卖",
    "湜": "石",
    "辶": "绰",
    "罅": "下",
    "窨": "熏",
    "檩": "吝",
    "罴": "皮",
    "邾": "朱",
    "黙": "墨",
    "鄒": "邹",
    "桖": "血",
    "婓": "飞",
    "缱": "浅",
    "荏": "忍",
    "洄": "回",
    "霂": "木",
    "睺": "喉",
    "頸": "井",
    "芰": "记",
    "掽": "碰",
    "蛏": "称",
    "琯": "管",
    "蔸": "兜",
    "倬": "捉",
    "覚": "觉",
    "烜": "选",
    "薮": "搜",
    "捰": "我",
    "眇": "秒",
    "阝": "父",
    "嶼": "雨",
    "峽": "侠",
    "纛": "到",
    "郷": "相",
    "绱": "上",
    "稟": "饼",
    "飼": "四",
    "嶄": "展",
    "彵": "妥",
    "勵": "利",
    "镲": "差",
    "豎": "树",
    "鄯": "善",
    "脅": "鞋",
    "崮": "固",
    "嗌": "爱",
    "鄱": "婆",
    "墀": "持",
    "颳": "瓜",
    "漯": "落",
    "蓑": "缩",
    "賠": "培",
    "疖": "接",
    "豈": "起",
    "绋": "福",
    "隈": "微",
    "洳": "入",
    "哙": "快",
    "鹂": "离",
    "瑤": "摇",
    "汊": "差",
    "麴": "区",
    "蜚": "飞",
    "絨": "容",
    "谉": "审",
    "釘": "丁",
    "勻": "云",
    "觴": "伤",
    "岘": "现",
    "骈": "偏",
    "壆": "学",
    "櫣": "连",
    "妪": "玉",
    "薹": "台",
    "鲈": "芦",
    "跶": "达",
    "坭": "尼",
    "姪": "直",
    "洮": "桃",
    "箧": "妾",
    "挹": "意",
    "囝": "减",
    "乩": "机",
    "芑": "起",
    "乚": "引",
    "睏": "困",
    "腫": "种",
    "偲": "猜",
    "荥": "行",
    "擲": "至",
    "蛔": "回",
    "讣": "父",
    "膦": "吝",
    "餮": "贴",
    "嶽": "月",
    "倨": "巨",
    "砭": "编",
    "牀": "床",
    "濞": "必",
    "謹": "紧",
    "腎": "肾",
    "圌": "传",
    "苜": "木",
    "肱": "工",
    "胴": "动",
    "纟": "思",
    "犽": "亚",
    "肼": "井",
    "酊": "丁",
    "綏": "虽",
    "籐": "腾",
    "渉": "设",
    "缯": "增",
    "悆": "玉",
    "锔": "居",
    "欏": "罗",
    "謇": "减",
    "橐": "驮",
    "霎": "煞",
    "殄": "舔",
    "禇": "者",
    "鉤": "勾",
    "噠": "答",
    "郇": "环",
    "蕖": "取",
    "戆": "杠",
    "勭": "同",
    "勖": "续",
    "婭": "亚",
    "咛": "凝",
    "燦": "灿",
    "肟": "卧",
    "抺": "妹",
    "弭": "米",
    "趸": "蹲",
    "蝕": "石",
    "浞": "着",
    "臎": "翠",
    "垵": "俺",
    "笱": "狗",
    "邛": "穷",
    "応": "应",
    "墮": "堕",
    "墳": "坟",
    "擞": "搜",
    "蚺": "然",
    "绐": "带",
    "髁": "科",
    "蹁": "偏",
    "簾": "连",
    "厶": "思",
    "頼": "赖",
    "苄": "变",
    "噤": "进",
    "鈞": "君",
    "蓖": "必",
    "廻": "回",
    "臵": "格",
    "慄": "利",
    "紘": "红",
    "柩": "就",
    "垩": "恶",
    "蠅": "营",
    "冏": "窘",
    "槭": "七",
    "幷": "病",
    "緝": "机",
    "纡": "迂",
    "鷲": "就",
    "迤": "宜",
    "芏": "度",
    "昉": "访",
    "沔": "免",
    "叵": "坡",
    "郯": "谈",
    "桠": "呀",
    "翹": "巧",
    "忄": "心",
    "驽": "努",
    "埧": "巨",
    "佥": "前",
    "蕤": "瑞",
    "笥": "四",
    "楃": "卧",
    "颞": "聂",
    "骓": "追",
    "嗪": "琴",
    "旒": "刘",
    "岜": "八",
    "偣": "烟",
    "禳": "嚷",
    "恫": "动",
    "権": "全",
    "匚": "方",
    "愆": "前",
    "牖": "有",
    "钐": "山",
    "鲟": "寻",
    "栞": "看",
    "诌": "周",
    "仉": "长",
    "坼": "撤",
    "鯊": "沙",
    "販": "饭",
    "硎": "行",
    "赍": "机",
    "洎": "记",
    "杌": "物",
    "鈔": "超",
    "遴": "林",
    "圜": "环",
    "齢": "零",
    "貳": "二",
    "瘿": "影",
    "镕": "容",
    "呭": "意",
    "憿": "角",
    "芎": "琼",
    "絞": "角",
    "頜": "和",
    "肫": "准",
    "颛": "专",
    "訳": "意",
    "鬱": "玉",
    "醌": "昆",
    "哝": "农",
    "紡": "访",
    "尢": "由",
    "忖": "存",
    "炘": "心",
    "铒": "耳",
    "磴": "凳",
    "諧": "鞋",
    "缳": "环",
    "纥": "歌",
    "嚧": "芦",
    "貶": "扁",
    "窯": "摇",
    "嬗": "善",
    "郸": "单",
    "襠": "当",
    "崙": "伦",
    "彊": "降",
    "氿": "鬼",
    "幛": "帐",
    "绻": "犬",
    "骢": "聪",
    "镛": "庸",
    "孀": "双",
    "粄": "板",
    "裨": "必",
    "荪": "孙",
    "礙": "爱",
    "胪": "芦",
    "戞": "夹",
    "脿": "标",
    "逖": "替",
    "螅": "西",
    "鏀": "鲁",
    "蘆": "芦",
    "萆": "必",
    "吚": "一",
    "麸": "夫",
    "矍": "觉",
    "燔": "烦",
    "浥": "意",
    "碣": "节",
    "椟": "毒",
    "鞯": "间",
    "荠": "记",
    "镫": "凳",
    "堍": "兔",
    "拰": "您",
    "芣": "福",
    "啫": "者",
    "揸": "扎",
    "狎": "侠",
    "咤": "咋",
    "郓": "运",
    "傛": "永",
    "悩": "脑",
    "呑": "吞",
    "攞": "罗",
    "菟": "图",
    "洰": "巨",
    "崆": "空",
    "屐": "机",
    "竽": "鱼",
    "嗾": "搜",
    "鳩": "纠",
    "俿": "虎",
    "艸": "草",
    "豸": "至",
    "攔": "蓝",
    "绂": "福",
    "儷": "利",
    "衲": "那",
    "苘": "请",
    "砜": "风",
    "洐": "行",
    "骖": "参",
    "琍": "离",
    "瘥": "拆",
    "佞": "宁",
    "彳": "赤",
    "龘": "达",
    "砀": "荡",
    "庝": "同",
    "盍": "和",
    "烀": "呼",
    "峄": "意",
    "穑": "色",
    "阊": "昌",
    "臋": "吞",
    "硖": "侠",
    "嗫": "聂",
    "苴": "居",
    "龔": "工",
    "誇": "夸",
    "槓": "杠",
    "愪": "云",
    "呙": "锅",
    "莛": "停",
    "鏆": "灌",
    "卣": "有",
    "聃": "单",
    "閻": "颜",
    "滀": "处",
    "怙": "互",
    "诒": "宜",
    "喫": "吃",
    "缂": "客",
    "枱": "台",
    "镱": "意",
    "薫": "熏",
    "讵": "巨",
    "橛": "觉",
    "蚧": "借",
    "蘊": "运",
    "庑": "五",
    "飧": "孙",
    "瑣": "锁",
    "惘": "网",
    "淪": "伦",
    "汅": "免",
    "儋": "单",
    "醭": "哺",
    "蟮": "善",
    "撘": "答",
    "癍": "班",
    "矸": "干",
    "苼": "生",
    "嘌": "票",
    "杼": "助",
    "婁": "楼",
    "铙": "脑",
    "荭": "红",
    "恏": "号",
    "捭": "摆",
    "羨": "现",
    "痩": "瘦",
    "缡": "离",
    "姞": "极",
    "閔": "敏",
    "棗": "早",
    "谡": "速",
    "糞": "愤",
    "颯": "萨",
    "緬": "免",
    "舁": "鱼",
    "敓": "夺",
    "谲": "觉",
    "龊": "绰",
    "艱": "间",
    "炆": "文",
    "庋": "鬼",
    "鈎": "勾",
    "逕": "静",
    "箜": "空",
    "荊": "精",
    "蠃": "裸",
    "稗": "败",
    "湉": "田",
    "婼": "绰",
    "蟼": "井",
    "蚶": "憨",
    "岽": "东",
    "眭": "虽",
    "塆": "弯",
    "呮": "气",
    "崁": "看",
    "斿": "由",
    "慊": "欠",
    "窉": "饼",
    "噂": "尊",
    "碇": "定",
    "楝": "练",
    "鱂": "将",
    "鈣": "概",
    "憣": "翻",
    "酽": "燕",
    "毬": "求",
    "汎": "饭",
    "徼": "角",
    "瑯": "狼",
    "揆": "奎",
    "揺": "摇",
    "铘": "爷",
    "芗": "相",
    "觐": "进",
    "蛩": "穷",
    "荳": "豆",
    "鋸": "巨",
    "镹": "久",
    "霊": "零",
    "镋": "躺",
    "濁": "着",
    "閤": "格",
    "珙": "拱",
    "袪": "区",
    "蚨": "福",
    "榧": "匪",
    "軽": "至",
    "冂": "窘",
    "畹": "碗",
    "坻": "持",
    "怍": "做",
    "滷": "鲁",
    "锒": "狼",
    "囷": "群",
    "胱": "光",
    "耄": "帽",
    "娠": "深",
    "熸": "间",
    "孒": "觉",
    "冴": "互",
    "砻": "龙",
    "沩": "维",
    "攵": "铺",
    "澀": "色",
    "怆": "创",
    "煥": "换",
    "氷": "冰",
    "侪": "柴",
    "弔": "掉",
    "妘": "云",
    "奁": "连",
    "鰓": "塞",
    "栉": "至",
    "啉": "林",
    "贠": "原",
    "濬": "俊",
    "荘": "装",
    "鼍": "驮",
    "俷": "费",
    "堛": "必",
    "萩": "秋",
    "蔭": "因",
    "髡": "昆",
    "鋈": "物",
    "鈪": "恶",
    "忕": "是",
    "铕": "有",
    "瘁": "翠",
    "嫑": "薄",
    "絆": "办",
    "帙": "至",
    "藁": "搞",
    "芴": "物",
    "済": "记",
    "觳": "胡",
    "黉": "红",
    "渃": "弱",
    "纖": "先",
    "贅": "缀",
    "埗": "不",
    "茭": "教",
    "鋅": "心",
    "搿": "格",
    "虜": "鲁",
    "鹕": "胡",
    "戜": "叠",
    "紳": "深",
    "瓙": "到",
    "谖": "宣",
    "锎": "开",
    "駁": "博",
    "蒌": "楼",
    "隍": "黄",
    "谀": "鱼",
    "葶": "停",
    "鏋": "满",
    "灑": "洒",
    "詈": "利",
    "堿": "减",
    "夼": "旷",
    "鑷": "聂",
    "弢": "掏",
    "塍": "成",
    "旂": "其",
    "羧": "缩",
    "帱": "愁",
    "墾": "肯",
    "鸪": "姑",
    "潴": "朱",
    "鏊": "奥",
    "睌": "满",
    "傥": "躺",
    "胍": "瓜",
    "萋": "七",
    "赀": "姿",
    "俣": "雨",
    "邳": "批",
    "讝": "占",
    "暱": "逆",
    "鲵": "尼",
    "亽": "极",
    "嚭": "匹",
    "赜": "则",
    "暾": "吞",
    "噑": "豪",
    "罟": "古",
    "燙": "烫",
    "奬": "讲",
    "醢": "海",
    "朮": "树",
    "骛": "物",
    "辺": "编",
    "勪": "觉",
    "溲": "搜",
    "憤": "愤",
    "覧": "懒",
    "暉": "灰",
    "儏": "灿",
    "闕": "确",
    "蒐": "搜",
    "斃": "必",
    "樨": "西",
    "鳕": "雪",
    "檠": "情",
    "媺": "美",
    "懼": "巨",
    "莖": "精",
    "葑": "风",
    "裎": "成",
    "俶": "处",
    "肜": "容",
    "鏌": "墨",
    "龢": "和",
    "闅": "文",
    "诨": "混",
    "龑": "眼",
    "镨": "普",
    "凖": "准",
    "艉": "伟",
    "濫": "烂",
    "仩": "长",
    "仮": "反",
    "碜": "尘",
    "牯": "古",
    "飆": "标",
    "眄": "免",
    "髂": "恰",
    "辔": "配",
    "滯": "至",
    "滗": "必",
    "浈": "真",
    "啗": "蛋",
    "冮": "刚",
    "璠": "烦",
    "瞞": "瞒",
    "絢": "炫",
    "跹": "先",
    "戗": "枪",
    "苣": "巨",
    "噹": "当",
    "泬": "觉",
    "蛸": "烧",
    "狻": "酸",
    "唁": "燕",
    "耋": "叠",
    "睜": "睁",
    "訫": "信",
    "剞": "机",
    "啝": "和",
    "夌": "零",
    "頑": "完",
    "琭": "路",
    "曛": "熏",
    "觯": "至",
    "廪": "吝",
    "弒": "是",
    "殓": "练",
    "繰": "早",
    "兌": "对",
    "鳐": "摇",
    "祧": "挑",
    "擄": "鲁",
    "茑": "尿",
    "檚": "楚",
    "浃": "家",
    "驕": "教",
    "営": "营",
    "蘖": "聂",
    "脇": "鞋",
    "侓": "路",
    "刋": "欠",
    "齑": "机",
    "稹": "枕",
    "鬣": "裂",
    "艿": "奶",
    "钆": "嘎",
    "鎗": "枪",
    "顛": "颠",
    "雩": "鱼",
    "麂": "几",
    "糺": "纠",
    "鍍": "度",
    "圬": "乌",
    "疋": "匹",
    "陉": "行",
    "婂": "眠",
    "戣": "奎",
    "毘": "皮",
    "玢": "彬",
    "摭": "直",
    "瘢": "班",
    "苁": "聪",
    "戻": "替",
    "嶇": "区",
    "惢": "锁",
    "荛": "扰",
    "諫": "见",
    "獬": "谢",
    "辂": "路",
    "楀": "雨",
    "錠": "定",
    "喾": "裤",
    "盪": "荡",
    "罍": "雷",
    "釀": "娘",
    "谿": "西",
    "濾": "绿",
    "榉": "举",
    "訥": "呢",
    "璽": "洗",
    "袛": "低",
    "冧": "林",
    "椐": "居",
    "詰": "节",
    "玹": "旋",
    "彂": "发",
    "笮": "则",
    "暍": "椰",
    "熳": "慢",
    "佤": "瓦",
    "閏": "润",
    "饔": "庸",
    "旆": "配",
    "貅": "修",
    "陬": "邹",
    "猱": "脑",
    "迓": "亚",
    "嗞": "姿",
    "頔": "敌",
    "酎": "昼",
    "緋": "飞",
    "铪": "哈",
    "懲": "成",
    "舎": "设",
    "聡": "聪",
    "髭": "姿",
    "礻": "是",
    "蘧": "取",
    "攴": "铺",
    "箨": "拓",
    "罨": "眼",
    "垓": "该",
    "勰": "鞋",
    "漬": "字",
    "蠟": "蜡",
    "鄄": "倦",
    "缷": "谢",
    "哕": "会",
    "圮": "匹",
    "诎": "区",
    "埽": "懆",
    "羙": "高",
    "廂": "相",
    "侔": "谋",
    "顎": "恶",
    "摈": "宾",
    "竄": "窜",
    "恿": "永",
    "侩": "快",
    "氤": "因",
    "鐖": "机",
    "蔥": "聪",
    "鹵": "鲁",
    "焜": "昆",
    "谘": "姿",
    "骠": "标",
    "攪": "角",
    "蟀": "帅",
    "錐": "追",
    "悛": "圈",
    "蠂": "设",
    "鎸": "捐",
    "枌": "坟",
    "瀕": "彬",
    "埤": "皮",
    "鲞": "想",
    "徴": "睁",
    "淆": "肖",
    "偠": "咬",
    "諒": "亮",
    "懇": "肯",
    "吿": "告",
    "暁": "小",
    "茏": "龙",
    "猭": "穿",
    "朊": "软",
    "俜": "平",
    "诿": "伟",
    "俳": "排",
    "倻": "椰",
    "勯": "单",
    "槁": "搞",
    "蚵": "和",
    "瓠": "互",
    "渫": "谢",
    "鲷": "雕",
    "葺": "气",
    "镏": "刘",
    "嶝": "凳",
    "鳎": "塔",
    "翮": "和",
    "禤": "宣",
    "钋": "坡",
    "搠": "硕",
    "攬": "懒",
    "踐": "见",
    "蛉": "零",
    "帑": "躺",
    "埌": "浪",
    "耪": "旁",
    "煄": "种",
    "衽": "任",
    "晧": "号",
    "犴": "按",
    "鲂": "房",
    "跬": "魁",
    "蠁": "想",
    "洸": "光",
    "傜": "摇",
    "隰": "习",
    "喟": "溃",
    "錨": "毛",
    "剰": "胜",
    "襪": "袜",
    "锇": "额",
    "伲": "逆",
    "忔": "气",
    "匏": "袍",
    "繡": "秀",
    "弐": "二",
    "衄": "女",
    "鎧": "凯",
    "陲": "垂",
    "驛": "意",
    "滂": "旁",
    "谮": "怎",
    "髹": "修",
    "璿": "旋",
    "龕": "看",
    "嗉": "速",
    "铥": "丢",
    "詣": "意",
    "蝽": "春",
    "堟": "赚",
    "甦": "苏",
    "匐": "福",
    "厣": "眼",
    "嶆": "曹",
    "媸": "吃",
    "煖": "暖",
    "殤": "伤",
    "倮": "裸",
    "簌": "速",
    "寔": "石",
    "捩": "裂",
    "竇": "豆",
    "鮋": "由",
    "珵": "成",
    "呬": "系",
    "萜": "贴",
    "吇": "子",
    "梱": "捆",
    "笹": "踢",
    "妁": "硕",
    "瑱": "镇",
    "旯": "啦",
    "窪": "挖",
    "槄": "掏",
    "圹": "矿",
    "儡": "垒",
    "缌": "思",
    "鹛": "梅",
    "敎": "教",
    "撈": "捞",
    "徂": "促",
    "呺": "消",
    "彖": "团",
    "枨": "成",
    "舘": "管",
    "宬": "成",
    "鲠": "梗",
    "鈦": "太",
    "椂": "路",
    "噺": "心",
    "鞞": "饼",
    "蠓": "猛",
    "悻": "性",
    "蓠": "离",
    "泅": "求",
    "妧": "万",
    "镡": "缠",
    "嗘": "机",
    "瞽": "古",
    "酃": "零",
    "衪": "宜",
    "覓": "密",
    "誦": "宋",
    "蠈": "贼",
    "粋": "翠",
    "缧": "雷",
    "柽": "称",
    "剤": "记",
    "匦": "鬼",
    "鞣": "柔",
    "澆": "教",
    "梃": "挺",
    "潅": "灌",
    "癢": "养",
    "冪": "密",
    "溦": "微",
    "沬": "妹",
    "鮨": "意",
    "暐": "伟",
    "囵": "伦",
    "雱": "旁",
    "浯": "无",
    "瀾": "蓝",
    "蛴": "其",
    "躇": "除",
    "镆": "墨",
    "侀": "行",
    "熺": "西",
    "窬": "鱼",
    "疴": "科",
    "薈": "会",
    "仂": "乐",
    "霑": "占",
    "铽": "特",
    "媾": "够",
    "逭": "换",
    "黾": "敏",
    "燐": "林",
    "酞": "太",
    "钄": "蓝",
    "哌": "派",
    "粧": "装",
    "鄹": "邹",
    "仼": "王",
    "柝": "拓",
    "渦": "窝",
    "翥": "助",
    "缬": "鞋",
    "纮": "红",
    "蘼": "迷",
    "黥": "情",
    "堞": "叠",
    "鲇": "年",
    "嬖": "必",
    "柙": "侠",
    "箻": "绿",
    "硃": "朱",
    "怹": "贪",
    "諱": "会",
    "埘": "石",
    "鍩": "舔",
    "菹": "居",
    "愀": "巧",
    "隳": "灰",
    "垜": "朵",
    "犺": "抗",
    "螢": "营",
    "觜": "姿",
    "矚": "主",
    "侖": "伦",
    "觊": "记",
    "蠲": "捐",
    "燿": "要",
    "坵": "秋",
    "嬿": "燕",
    "崱": "责",
    "怄": "欧",
    "跗": "夫",
    "诔": "垒",
    "鴉": "呀",
    "饑": "机",
    "睞": "赖",
    "悳": "德",
    "襯": "衬",
    "垁": "至",
    "滲": "肾",
    "柁": "堕",
    "玒": "红",
    "屛": "平",
    "篪": "持",
    "籼": "先",
    "崘": "伦",
    "佉": "区",
    "囲": "通",
    "癮": "引",
    "倜": "替",
    "胝": "知",
    "徭": "摇",
    "讠": "颜",
    "荽": "虽",
    "偆": "春",
    "鵰": "雕",
    "嗙": "旁",
    "宄": "鬼",
    "镘": "慢",
    "鼉": "驮",
    "殲": "间",
    "伋": "极",
    "諜": "叠",
    "莴": "窝",
    "儂": "农",
    "佻": "挑",
    "銎": "穷",
    "疳": "干",
    "犵": "歌",
    "嫫": "魔",
    "娡": "至",
    "褕": "鱼",
    "漤": "懒",
    "帔": "配",
    "澘": "山",
    "旄": "毛",
    "锍": "柳",
    "豇": "将",
    "栌": "芦",
    "垧": "赏",
    "閾": "玉",
    "晳": "西",
    "賗": "串",
    "夁": "一",
    "粜": "跳",
    "拊": "辅",
    "暸": "聊",
    "褛": "旅",
    "瘗": "意",
    "鍓": "极",
    "羰": "汤",
    "儵": "书",
    "賍": "脏",
    "驢": "驴",
    "嘏": "古",
    "蚣": "工",
    "鎼": "下",
    "鍪": "谋",
    "兝": "分",
    "梟": "消",
    "懔": "吝",
    "繖": "三",
    "臿": "插",
    "峩": "额",
    "篩": "筛",
    "猓": "果",
    "泐": "乐",
    "撄": "应",
    "鈍": "顿",
    "绁": "谢",
    "驍": "消",
    "褫": "尺",
    "瑋": "伟",
    "閨": "归",
    "覗": "四",
    "秣": "墨",
    "挙": "举",
    "瓿": "不",
    "繃": "崩",
    "豳": "彬",
    "噓": "需",
    "埒": "裂",
    "涠": "维",
    "涑": "速",
    "僞": "伟",
    "儉": "减",
    "黼": "辅",
    "贛": "干",
    "窕": "挑",
    "揹": "杯",
    "涴": "卧",
    "峿": "雨",
    "盌": "碗",
    "囨": "偏",
    "痱": "费",
    "淏": "号",
    "蓐": "入",
    "湅": "练",
    "穢": "会",
    "綔": "互",
    "潑": "坡",
    "酐": "干",
    "莠": "有",
    "摳": "口",
    "鈉": "那",
    "頤": "宜",
    "谠": "挡",
    "聙": "精",
    "詐": "咋",
    "勛": "熏",
    "榖": "古",
    "竊": "妾",
    "兎": "兔",
    "尥": "料",
    "囓": "聂",
    "逡": "群",
    "鸱": "吃",
    "筮": "是",
    "嘯": "笑",
    "巛": "穿",
    "嚜": "么",
    "払": "反",
    "絃": "闲",
    "顫": "颤",
    "抔": "剖",
    "嶷": "宜",
    "鳜": "贵",
    "鱈": "雪",
    "攏": "垄",
    "僉": "前",
    "皤": "婆",
    "廬": "芦",
    "陜": "侠",
    "锪": "霍",
    "僳": "速",
    "鞒": "桥",
    "薤": "谢",
    "霪": "银",
    "詭": "鬼",
    "戙": "动",
    "扃": "窘",
    "罘": "福",
    "鎂": "美",
    "胗": "真",
    "絹": "倦",
    "鼖": "坟",
    "祅": "邀",
    "躏": "吝",
    "寃": "冤",
    "冹": "福",
    "囪": "聪",
    "橼": "原",
    "豨": "西",
    "鸬": "芦",
    "閬": "浪",
    "餍": "燕",
    "瑧": "真",
    "犭": "犬",
    "氾": "饭",
    "邶": "被",
    "嬱": "欠",
    "酹": "泪",
    "擗": "匹",
    "塎": "永",
    "缢": "意",
    "鹼": "减",
    "涫": "灌",
    "栲": "考",
    "謊": "谎",
    "胙": "做",
    "馃": "果",
    "厓": "牙",
    "呿": "去",
    "継": "记",
    "驟": "昼",
    "闍": "督",
    "襙": "操",
    "婱": "闲",
    "湡": "鱼",
    "劼": "节",
    "疠": "利",
    "窓": "窗",
    "媵": "硬",
    "槠": "朱",
    "縁": "原",
    "仏": "佛",
    "駭": "害",
    "跎": "驮",
    "宍": "肉",
    "袴": "裤",
    "硶": "尘",
    "駱": "落",
    "躔": "缠",
    "朐": "取",
    "茕": "穷",
    "逶": "微",
    "亶": "胆",
    "媄": "美",
    "暦": "利",
    "瓘": "灌",
    "洨": "肖",
    "綄": "环",
    "尪": "汪",
    "脹": "帐",
    "跫": "穷",
    "肊": "意",
    "氹": "荡",
    "鎳": "聂",
    "哚": "朵",
    "戋": "间",
    "哿": "葛",
    "骘": "至",
    "钀": "聂",
    "菔": "福",
    "冭": "太",
    "渶": "应",
    "溷": "混",
    "沚": "指",
    "蛘": "羊",
    "碚": "被",
    "筌": "全",
    "鵺": "夜",
    "挲": "撒",
    "钫": "方",
    "铩": "沙",
    "撓": "脑",
    "贽": "至",
    "绨": "提",
    "觇": "搀",
    "炪": "捉",
    "崾": "咬",
    "堋": "朋",
    "仃": "丁",
    "骟": "善",
    "晷": "鬼",
    "塱": "浪",
    "浐": "铲",
    "殂": "促",
    "缒": "缀",
    "叏": "怪",
    "珰": "当",
    "綸": "伦",
    "倣": "访",
    "薑": "将",
    "朂": "续",
    "蔔": "博",
    "銃": "冲",
    "悕": "西",
    "恂": "寻",
    "鴿": "歌",
    "糾": "纠",
    "睃": "缩",
    "耧": "楼",
    "胛": "假",
    "嘧": "密",
    "帼": "国",
    "髀": "必",
    "镥": "鲁",
    "嘹": "聊",
    "茈": "瓷",
    "狁": "允",
    "颙": "庸",
    "樗": "出",
    "狷": "倦",
    "劬": "取",
    "袤": "帽",
    "栊": "龙",
    "儓": "台",
    "郫": "皮",
    "铗": "夹",
    "莨": "浪",
    "赕": "胆",
    "砉": "或",
    "楯": "顿",
    "壱": "一",
    "聴": "听",
    "謠": "摇",
    "螈": "原",
    "炲": "台",
    "甾": "灾",
    "櫺": "零",
    "螽": "中",
    "阄": "纠",
    "禎": "真",
    "叆": "爱",
    "佧": "卡",
    "儸": "罗",
    "攢": "赞",
    "蚴": "右",
    "轎": "教",
    "垆": "芦",
    "饫": "玉",
    "紑": "否",
    "崤": "肖",
    "蕏": "除",
    "縄": "生",
    "踔": "戳",
    "墠": "善",
    "墁": "慢",
    "繭": "减",
    "徨": "黄",
    "掤": "冰",
    "銹": "秀",
    "琌": "零",
    "衤": "一",
    "俢": "修",
    "魨": "吞",
    "骝": "刘",
    "橥": "朱",
    "戡": "看",
    "晡": "不",
    "耜": "四",
    "姤": "够",
    "匜": "宜",
    "鈾": "由",
    "盞": "展",
    "緹": "提",
    "隕": "允",
    "敠": "多",
    "汏": "大",
    "罠": "民",
    "埏": "山",
    "擝": "蒙",
    "斝": "假",
    "噾": "因",
    "鳔": "标",
    "诹": "邹",
    "悊": "哲",
    "侽": "南",
    "榘": "举",
    "鲔": "伟",
    "瞓": "愤",
    "蝼": "楼",
    "驲": "日",
    "蓥": "营",
    "泖": "帽",
    "涒": "吞",
    "妯": "轴",
    "晝": "昼",
    "睚": "牙",
    "篼": "兜",
    "簫": "消",
    "屦": "巨",
    "熻": "西",
    "擱": "歌",
    "鄴": "夜",
    "殻": "巧",
    "岣": "狗",
    "嚮": "向",
    "嗍": "缩",
    "煺": "退",
    "苊": "恶",
    "鷺": "路",
    "蜮": "玉",
    "脽": "谁",
    "葸": "洗",
    "邗": "含",
    "锞": "客",
    "夤": "银",
    "竈": "造",
    "锜": "其",
    "傭": "庸",
    "鎭": "镇",
    "朩": "等",
    "悽": "七",
    "簷": "颜",
    "踣": "博",
    "臾": "鱼",
    "掮": "钱",
    "榊": "神",
    "攉": "霍",
    "脔": "鸾",
    "歺": "恶",
    "罾": "增",
    "洶": "胸",
    "毌": "灌",
    "耱": "墨",
    "挻": "山",
    "陝": "闪",
    "纜": "懒",
    "枥": "利",
    "畠": "田",
    "浍": "会",
    "嬨": "瓷",
    "茍": "记",
    "淝": "肥",
    "椼": "眼",
    "濊": "会",
    "瀞": "静",
    "鳙": "庸",
    "竑": "红",
    "灝": "号",
    "呪": "昼",
    "踰": "鱼",
    "菖": "昌",
    "冩": "写",
    "蜆": "现",
    "滏": "辅",
    "汩": "古",
    "勅": "赤",
    "墿": "意",
    "垕": "后",
    "酩": "命",
    "觌": "敌",
    "縷": "旅",
    "鶯": "应",
    "愰": "荒",
    "綵": "采",
    "呴": "许",
    "脛": "静",
    "垎": "贺",
    "蓿": "须",
    "胨": "动",
    "坜": "利",
    "刳": "哭",
    "鸺": "修",
    "巣": "朝",
    "獴": "猛",
    "尒": "耳",
    "皯": "感",
    "茳": "将",
    "虿": "拆",
    "馭": "玉",
    "蠔": "豪",
    "愦": "溃",
    "泭": "福",
    "鏢": "标",
    "秫": "熟",
    "鲳": "昌",
    "筘": "扣",
    "瘕": "假",
    "喎": "歪",
    "岿": "亏",
    "睥": "屁",
    "軀": "区",
    "菴": "安",
    "曘": "如",
    "煕": "西",
    "捜": "搜",
    "苾": "必",
    "桤": "七",
    "籹": "女",
    "甏": "甭",
    "缣": "间",
    "釦": "扣",
    "娿": "阿",
    "犸": "骂",
    "偗": "省",
    "鉢": "波",
    "聼": "听",
    "崟": "银",
    "塢": "物",
    "琤": "称",
    "髌": "宾",
    "砹": "爱",
    "笁": "竹",
    "髟": "标",
    "姟": "该",
    "孥": "努",
    "艽": "教",
    "莣": "王",
    "脢": "梅",
    "澔": "号",
    "伕": "夫",
    "砘": "顿",
    "儛": "五",
    "紺": "干",
    "盄": "招",
    "懆": "草",
    "輥": "滚",
    "鬘": "瞒",
    "痠": "酸",
    "樼": "真",
    "哓": "消",
    "脬": "抛",
    "価": "四",
    "伉": "抗",
    "蕓": "云",
    "偅": "重",
    "扱": "西",
    "乸": "哪",
    "盉": "和",
    "漭": "忙",
    "鸞": "鸾",
    "窺": "亏",
    "搗": "导",
    "愔": "因",
    "蓍": "诗",
    "幄": "卧",
    "赧": "男",
    "饩": "系",
    "醃": "烟",
    "鑼": "罗",
    "鞏": "拱",
    "噯": "哀",
    "姳": "命",
    "崃": "来",
    "痍": "宜",
    "儑": "岸",
    "喹": "奎",
    "坉": "吞",
    "鏇": "炫",
    "鲅": "爸",
    "笾": "编",
    "鲋": "父",
    "悫": "确",
    "鹍": "昆",
    "禚": "着",
    "筇": "穷",
    "檑": "雷",
    "斎": "摘",
    "鎚": "垂",
    "鳶": "冤",
    "镔": "彬",
    "綬": "瘦",
    "愎": "必",
    "苎": "助",
    "郐": "快",
    "楁": "和",
    "诖": "挂",
    "崐": "昆",
    "荸": "鼻",
    "韪": "伟",
    "皺": "昼",
    "骣": "铲",
    "谇": "岁",
    "瘰": "裸",
    "岃": "任",
    "銓": "全",
    "鑺": "取",
    "粬": "区",
    "飑": "标",
    "輿": "鱼",
    "褴": "蓝",
    "轍": "哲",
    "旀": "妹",
    "硏": "颜",
    "泩": "生",
    "畛": "枕",
    "龉": "雨",
    "骱": "借",
    "冖": "密",
    "褞": "允",
    "鮎": "年",
    "殚": "单",
    "暻": "井",
    "嫻": "闲",
    "覇": "爸",
    "啞": "哑",
    "堙": "因",
    "黟": "一",
    "耥": "汤",
    "褏": "秀",
    "悝": "亏",
    "蚋": "瑞",
    "籴": "敌",
    "鏖": "敖",
    "掱": "爬",
    "俬": "思",
    "撻": "踏",
    "蝰": "奎",
    "鉻": "落",
    "粢": "姿",
    "脨": "促",
    "肄": "意",
    "駆": "区",
    "炤": "照",
    "酡": "驮",
    "鬍": "胡",
    "愷": "凯",
    "遅": "持",
    "鈊": "心",
    "遄": "传",
    "绲": "滚",
    "馓": "三",
    "烔": "同",
    "靼": "达",
    "畾": "雷",
    "跣": "显",
    "湳": "男",
    "榇": "衬",
    "蠊": "连",
    "砵": "波",
    "禿": "突",
    "秕": "比",
    "鋰": "李",
    "絷": "直",
    "歯": "尺",
    "懐": "怀",
    "燠": "玉",
    "卌": "系",
    "坌": "笨",
    "浬": "李",
    "堠": "后",
    "弝": "爸",
    "夶": "比",
    "筲": "烧",
    "瑢": "容",
    "龀": "衬",
    "墘": "钱",
    "炱": "台",
    "夈": "摘",
    "蝮": "父",
    "筅": "显",
    "熾": "赤",
    "欐": "利",
    "艡": "当",
    "渟": "停",
    "郾": "眼",
    "跞": "利",
    "鄺": "矿",
    "闡": "铲",
    "惱": "脑",
    "鳯": "奉",
    "曇": "谈",
    "硯": "燕",
    "脥": "浅",
    "庒": "装",
    "寲": "宜",
    "輒": "哲",
    "欎": "玉",
    "淒": "七",
    "盥": "灌",
    "婃": "从",
    "沆": "行",
    "庅": "魔",
    "亼": "极",
    "羈": "机",
    "跄": "枪",
    "瘳": "抽",
    "雑": "杂",
    "氅": "场",
    "饣": "石",
    "欒": "鸾",
    "柵": "山",
    "芄": "完",
    "槻": "归",
    "垨": "手",
    "骺": "喉",
    "岈": "牙",
    "椛": "花",
    "傕": "觉",
    "裟": "沙",
    "穦": "拼",
    "鈹": "批",
    "埍": "卷",
    "蒉": "溃",
    "甕": "瓮",
    "嗻": "遮",
    "涚": "睡",
    "鐑": "妾",
    "癜": "电",
    "濄": "锅",
    "悎": "号",
    "薷": "如",
    "觏": "够",
    "斂": "脸",
    "廁": "册",
    "喈": "接",
    "囦": "冤",
    "暘": "羊",
    "槲": "胡",
    "眬": "龙",
    "鲮": "零",
    "镦": "对",
    "庥": "修",
    "袷": "夹",
    "噍": "教",
    "裥": "减",
    "趼": "减",
    "坫": "电",
    "岺": "零",
    "愭": "其",
    "缏": "变",
    "锸": "插",
    "尨": "忙",
    "畨": "攀",
    "愩": "工",
    "縢": "腾",
    "秊": "年",
    "搥": "垂",
    "駡": "骂",
    "芨": "机",
    "玘": "起",
    "廾": "拱",
    "谳": "燕",
    "誐": "额",
    "茌": "持",
    "貯": "助",
    "眏": "养",
    "漈": "记",
    "賃": "吝",
    "垡": "罚",
    "鹣": "间",
    "诂": "古",
    "鏟": "铲",
    "鉗": "钱",
    "獗": "觉",
    "洿": "乌",
    "棨": "起",
    "燉": "顿",
    "閪": "色",
    "槙": "颠",
    "蠖": "或",
    "龠": "月",
    "鑱": "缠",
    "綍": "福",
    "倥": "空",
    "戥": "等",
    "圄": "雨",
    "鼗": "桃",
    "哾": "说",
    "鏽": "秀",
    "僱": "固",
    "睍": "现",
    "鉀": "假",
    "裼": "替",
    "鷗": "欧",
    "晫": "着",
    "涏": "挺",
    "濇": "色",
    "櫒": "萨",
    "鱻": "先",
    "籺": "和",
    "嫘": "雷",
    "傧": "彬",
    "卬": "昂",
    "枡": "生",
    "菂": "地",
    "鸸": "而",
    "屺": "起",
    "簲": "排",
    "閰": "局",
    "峓": "宜",
    "枃": "进",
    "裢": "连",
    "囙": "因",
    "脗": "稳",
    "祆": "先",
    "奭": "是",
    "舡": "传",
    "痼": "固",
    "骀": "带",
    "貊": "墨",
    "皵": "确",
    "贶": "矿",
    "祓": "福",
    "謦": "请",
    "銭": "钱",
    "褎": "秀",
    "鮫": "教",
    "秾": "农",
    "憷": "处",
    "魟": "红",
    "亰": "精",
    "蔟": "促",
    "匂": "胸",
    "湰": "龙",
    "仳": "匹",
    "歃": "煞",
    "嬅": "话",
    "栬": "最",
    "辏": "凑",
    "鬯": "唱",
    "岍": "前",
    "逦": "李",
    "檻": "砍",
    "庀": "匹",
    "艚": "曹",
    "辎": "姿",
    "裉": "肯",
    "媗": "宣",
    "鲭": "青",
    "琻": "金",
    "褑": "院",
    "扆": "以",
    "駌": "冤",
    "撴": "蹲",
    "箌": "到",
    "蔘": "深",
    "堢": "宝",
    "敫": "角",
    "尯": "溃",
    "嵛": "鱼",
    "甗": "眼",
    "朠": "应",
    "砑": "亚",
    "凵": "浅",
    "鍣": "招",
    "庁": "听",
    "縻": "迷",
    "惀": "伦",
    "峠": "恰",
    "彐": "记",
    "鸹": "瓜",
    "煋": "星",
    "廛": "缠",
    "茚": "印",
    "倶": "巨",
    "櫛": "至",
    "僾": "爱",
    "芲": "花",
    "畋": "田",
    "婄": "剖",
    "蠶": "残",
    "轺": "摇",
    "迕": "物",
    "曟": "陈",
    "廝": "思",
    "揞": "俺",
    "煒": "伟",
    "紵": "助",
    "褡": "答",
    "燄": "燕",
    "袓": "巨",
    "朶": "朵",
    "摻": "灿",
    "煇": "灰",
    "澌": "思",
    "甪": "路",
    "鉯": "以",
    "蒹": "间",
    "偘": "砍",
    "鰍": "秋",
    "彫": "雕",
    "椀": "碗",
    "燭": "竹",
    "伈": "信",
    "抎": "允",
    "瓑": "利",
    "葙": "相",
    "伥": "昌",
    "玏": "乐",
    "鲆": "平",
    "鞴": "被",
    "狆": "重",
    "鈕": "纽",
    "芟": "山",
    "筯": "助",
    "癲": "颠",
    "菫": "紧",
    "搮": "利",
    "鈳": "科",
    "芤": "口",
    "晥": "碗",
    "婲": "花",
    "笸": "坡",
    "骉": "标",
    "儶": "会",
    "戓": "歌",
    "鹱": "互",
    "姌": "染",
    "咴": "灰",
    "玆": "姿",
    "絀": "处",
    "栥": "姿",
    "煶": "是",
    "膰": "烦",
    "鲊": "眨",
    "舳": "竹",
    "帻": "则",
    "塅": "断",
    "塄": "棱",
    "敉": "米",
    "黠": "侠",
    "挊": "弄",
    "孳": "姿",
    "紬": "愁",
    "夎": "错",
    "嚅": "如",
    "黧": "离",
    "冚": "砍",
    "矧": "审",
    "揷": "插",
    "忉": "刀",
    "胂": "肾",
    "馴": "寻",
    "菿": "到",
    "鳏": "关",
    "欍": "就",
    "儴": "嚷",
    "瞢": "盟",
    "杺": "心",
    "赳": "纠",
    "祌": "重",
    "瘛": "赤",
    "驺": "邹",
    "茛": "根",
    "磲": "取",
    "搦": "诺",
    "朹": "鬼",
    "掙": "睁",
    "讐": "愁",
    "襞": "必",
    "忮": "至",
    "祫": "侠",
    "膮": "消",
    "瀉": "谢",
    "偪": "逼",
    "鍃": "霍",
    "呡": "稳",
    "誣": "乌",
    "苧": "凝",
    "莸": "由",
    "滌": "敌",
    "罱": "懒",
    "鵜": "提",
    "穫": "或",
    "烎": "银",
    "簦": "灯",
    "鐒": "劳",
    "犱": "几",
    "猟": "裂",
    "铫": "掉",
    "檗": "薄",
    "繕": "善",
    "伄": "掉",
    "鎽": "风",
    "篌": "喉",
    "甍": "盟",
    "麣": "颜",
    "鲽": "叠",
    "麺": "面",
    "毴": "逼",
    "矯": "角",
    "脶": "罗",
    "軋": "亚",
    "粝": "利",
    "廴": "引",
    "贖": "熟",
    "厷": "工",
    "潲": "绍",
    "浤": "红",
    "咘": "不",
    "栱": "拱",
    "咑": "答",
    "垲": "凯",
    "崦": "烟",
    "湀": "鬼",
    "轾": "至",
    "渀": "笨",
    "悗": "瞒",
    "酲": "成",
    "劓": "意",
    "簒": "窜",
    "僪": "局",
    "廨": "谢",
    "鸲": "取",
    "幝": "铲",
    "跏": "家",
    "躜": "钻",
    "荦": "落",
    "隴": "垄",
    "憍": "教",
    "闶": "康",
    "鞫": "居",
    "仫": "木",
    "艄": "烧",
    "缽": "波",
    "圝": "鸾",
    "脰": "豆",
    "窳": "雨",
    "襻": "判",
    "舻": "芦",
    "囑": "主",
    "槳": "讲",
    "鼙": "皮",
    "畚": "本",
    "刎": "稳",
    "皲": "君",
    "皞": "号",
    "莩": "福",
    "仡": "歌",
    "廃": "费",
    "挾": "鞋",
    "姏": "瞒",
    "籲": "玉",
    "迺": "奶",
    "拝": "败",
    "鳊": "编",
    "圯": "宜",
    "遘": "够",
    "乣": "久",
    "狨": "容",
    "銑": "显",
    "鹩": "聊",
    "荩": "进",
    "涢": "云",
    "撺": "窜",
    "籀": "昼",
    "籬": "离",
    "峣": "摇",
    "嘩": "花",
    "麹": "区",
    "伅": "顿",
    "蛄": "姑",
    "哢": "弄",
    "廯": "先",
    "狲": "孙",
    "瓨": "翔",
    "竷": "砍",
    "焃": "贺",
    "猡": "罗",
    "虓": "消",
    "鑸": "垒",
    "洣": "米",
    "渼": "美",
    "汸": "方",
    "墖": "塔",
    "樶": "嘴",
    "兿": "意",
    "踟": "持",
    "搋": "揣",
    "寘": "至",
    "岵": "互",
    "庤": "至",
    "蕹": "瓮",
    "摯": "至",
    "矅": "要",
    "鎹": "宋",
    "洏": "而",
    "稂": "狼",
    "呉": "无",
    "諦": "地",
    "鉑": "博",
    "搛": "间",
    "艋": "猛",
    "鳇": "黄",
    "繘": "玉",
    "桴": "福",
    "缍": "朵",
    "蠉": "宣",
    "婅": "局",
    "诼": "着",
    "澗": "见",
    "迣": "至",
    "爇": "弱",
    "鲩": "换",
    "簮": "赞",
    "龃": "举",
    "簖": "断",
    "盱": "需",
    "砬": "啦",
    "畳": "叠",
    "潗": "极",
    "緂": "田",
    "闿": "凯",
    "黻": "福",
    "苐": "提",
    "挢": "角",
    "鹾": "搓",
    "懑": "闷",
    "獃": "呆",
    "聳": "耸",
    "塁": "垒",
    "謨": "魔",
    "淠": "屁",
    "佀": "四",
    "砩": "福",
    "窆": "扁",
    "拡": "扩",
    "鰈": "叠",
    "埜": "也",
    "箝": "钱",
    "吢": "亲",
    "脤": "肾",
    "簬": "路",
    "氶": "整",
    "蛯": "老",
    "袮": "迷",
    "諷": "奉",
    "驊": "华",
    "檜": "贵",
    "汭": "瑞",
    "儱": "垄",
    "錚": "睁",
    "雋": "倦",
    "痺": "必",
    "湇": "气",
    "炴": "养",
    "苺": "梅",
    "泚": "此",
    "獍": "静",
    "鮭": "归",
    "泔": "干",
    "秭": "子",
    "翾": "宣",
    "箦": "则",
    "蒨": "欠",
    "蜢": "猛",
    "镠": "刘",
    "粨": "摆",
    "笤": "条",
    "穸": "西",
    "茼": "同",
    "栝": "瓜",
    "陔": "该",
    "洅": "在",
    "訟": "宋",
    "飢": "机",
    "棬": "圈",
    "笊": "照",
    "僰": "博",
    "礪": "利",
    "旰": "干",
    "趵": "报",
    "佴": "二",
    "郛": "福",
    "滐": "节",
    "栨": "次",
    "畬": "舍",
    "鳟": "尊",
    "儔": "愁",
    "湎": "免",
    "嗛": "浅",
    "箣": "册",
    "羮": "耕",
    "瓞": "叠",
    "徉": "羊",
    "蒔": "石",
    "毳": "翠",
    "麿": "迷",
    "鹧": "这",
    "耔": "子",
    "虼": "个",
    "缛": "入",
    "枊": "盎",
    "莶": "先",
    "穌": "苏",
    "糈": "许",
    "犷": "广",
    "亠": "头",
    "侉": "垮",
    "舾": "西",
    "苳": "东",
    "柃": "零",
    "岖": "区",
    "彯": "飘",
    "蚱": "咋",
    "颎": "窘",
    "踬": "至",
    "伒": "进",
    "硭": "忙",
    "暀": "网",
    "澐": "云",
    "檆": "山",
    "嫠": "离",
    "熀": "谎",
    "豝": "八",
    "桕": "就",
    "圊": "青",
    "瘆": "肾",
    "牴": "底",
    "缵": "钻",
    "壸": "捆",
    "泶": "学",
    "夬": "怪",
    "蛍": "营",
    "酏": "以",
    "趿": "他",
    "餉": "想",
    "珽": "挺",
    "嘖": "则",
    "弎": "三",
    "禘": "地",
    "鲡": "离",
    "馿": "驴",
    "讦": "节",
    "忸": "纽",
    "埇": "永",
    "栘": "宜",
    "砗": "车",
    "溇": "楼",
    "疒": "呢",
    "儁": "俊",
    "忎": "人",
    "湔": "间",
    "葦": "伟",
    "脷": "利",
    "潓": "会",
    "笌": "牙",
    "箞": "前",
    "摰": "聂",
    "镅": "梅",
    "鍠": "黄",
    "祔": "父",
    "彴": "着",
    "儹": "赞",
    "忋": "改",
    "疄": "吝",
    "譻": "应",
    "龒": "龙",
    "迮": "则",
    "馡": "飞",
    "葚": "任",
    "嫀": "琴",
    "紜": "云",
    "奨": "讲",
    "嫃": "真",
    "嬮": "烟",
    "裣": "脸",
    "噐": "气",
    "滈": "号",
    "橦": "同",
    "偍": "提",
    "蘩": "烦",
    "猁": "利",
    "樫": "间",
    "亇": "吗",
    "苠": "民",
    "囥": "抗",
    "甓": "屁",
    "忪": "松",
    "嵯": "搓",
    "浿": "配",
    "誮": "花",
    "趄": "居",
    "蟛": "朋",
    "讧": "红",
    "軎": "位",
    "慝": "特",
    "郕": "成",
    "詤": "谎",
    "萑": "环",
    "潶": "黑",
    "擐": "换",
    "鱉": "憋",
    "箋": "间",
    "炻": "石",
    "褊": "扁",
    "轫": "任",
    "択": "则",
    "硇": "脑",
    "縦": "宗",
    "禊": "系",
    "梶": "伟",
    "鋭": "瑞",
    "镤": "葡",
    "眈": "单",
    "顗": "以",
    "凥": "居",
    "蠱": "古",
    "崋": "话",
    "垤": "叠",
    "慟": "痛",
    "跚": "山",
    "礤": "擦",
    "綘": "逢",
    "獞": "同",
    "瘡": "窗",
    "颱": "台",
    "藴": "运",
    "栦": "愁",
    "綽": "绰",
    "藔": "聊",
    "輶": "由",
    "簍": "楼",
    "齤": "全",
    "瓏": "龙",
    "彿": "福",
    "嬶": "鼻",
    "龖": "达",
    "嫲": "吗",
    "譲": "让",
    "阋": "系",
    "箪": "单",
    "麈": "主",
    "丆": "罕",
    "碹": "炫",
    "厤": "利",
    "裒": "剖",
    "廸": "敌",
    "瘐": "雨",
    "籓": "翻",
    "筍": "损",
    "钶": "科",
    "瑺": "长",
    "眢": "冤",
    "龤": "鞋",
    "翚": "灰",
    "仴": "卧",
    "撙": "尊",
    "俍": "良",
    "緱": "勾",
    "悓": "欠",
    "繹": "意",
    "丗": "是",
    "邠": "彬",
    "侷": "局",
    "狅": "狂",
    "傞": "缩",
    "蜩": "条",
    "褓": "宝",
    "汔": "气",
    "掟": "整",
    "毵": "三",
    "臁": "连",
    "繋": "记",
    "曡": "叠",
    "埼": "其",
    "缋": "会",
    "嶉": "催",
    "虮": "几",
    "瞾": "照",
    "鸶": "思",
    "瑆": "星",
    "歿": "墨",
    "慉": "续",
    "謁": "夜",
    "呾": "达",
    "濺": "见",
    "涳": "空",
    "龁": "和",
    "艧": "或",
    "貍": "离",
    "嶶": "微",
    "菥": "西",
    "篃": "妹",
    "肷": "浅",
    "絳": "降",
    "碶": "气",
    "鯖": "睁",
    "翛": "消",
    "阏": "恶",
    "轵": "指",
    "萣": "定",
    "鶏": "机",
    "訛": "额",
    "儯": "腾",
    "眛": "妹",
    "悱": "匪",
    "鋬": "判",
    "絜": "节",
    "珹": "成",
    "瀝": "利",
    "盦": "安",
    "銊": "续",
    "眵": "吃",
    "婹": "咬",
    "嶃": "展",
    "簏": "路",
    "襤": "蓝",
    "咾": "老",
    "疎": "书",
    "恠": "怪",
    "脧": "捐",
    "牮": "见",
    "涗": "睡",
    "腙": "宗",
    "捽": "做",
    "礅": "蹲",
    "滺": "优",
    "竅": "巧",
    "捯": "刀",
    "崡": "含",
    "颥": "如",
    "霙": "应",
    "茓": "学",
    "駄": "驮",
    "頰": "夹",
    "蔴": "麻",
    "窭": "巨",
    "燻": "熏",
    "鴞": "消",
    "锾": "环",
    "儞": "你",
    "蟊": "毛",
    "桫": "缩",
    "棿": "尼",
    "犮": "拔",
    "箢": "冤",
    "棧": "战",
    "崚": "棱",
    "韜": "掏",
    "涇": "精",
    "贄": "至",
    "叄": "参",
    "覌": "关",
    "鉨": "洗",
    "蒇": "铲",
    "琀": "含",
    "幟": "至",
    "澥": "谢",
    "鯤": "昆",
    "羥": "抢",
    "剉": "错",
    "餸": "宋",
    "螚": "耐",
    "幞": "福",
    "嗆": "枪",
    "剀": "凯",
    "簨": "损",
    "鎊": "棒",
    "嬸": "审",
    "衕": "痛",
    "偄": "软",
    "蚿": "闲",
    "蕺": "极",
    "曖": "爱",
    "紓": "书",
    "儚": "盟",
    "枵": "消",
    "譙": "巧",
    "伀": "中",
    "囄": "离",
    "纙": "落",
    "躋": "机",
    "鎾": "温",
    "渕": "冤",
    "幋": "盘",
    "揵": "钱",
    "躅": "竹",
    "莐": "陈",
    "溽": "入",
    "羝": "低",
    "昜": "羊",
    "棼": "坟",
    "邡": "方",
    "鈻": "四",
    "竤": "红",
    "缫": "骚",
    "疍": "蛋",
    "掲": "接",
    "駙": "父",
    "烠": "回",
    "埖": "花",
    "妡": "心",
    "栆": "早",
    "怫": "福",
    "偾": "愤",
    "蘚": "显",
    "趱": "赞",
    "嫜": "张",
    "觋": "习",
    "艣": "鲁",
    "牋": "间",
    "嘍": "楼",
    "刿": "贵",
    "媿": "溃",
    "脠": "山",
    "琎": "进",
    "婇": "采",
    "耩": "讲",
    "锖": "枪",
    "衳": "中",
    "仌": "冰",
    "偁": "称",
    "鹆": "玉",
    "缲": "敲",
    "饸": "和",
    "勣": "机",
    "旛": "翻",
    "褀": "其",
    "痲": "麻",
    "梏": "固",
    "禱": "导",
    "冑": "昼",
    "灉": "庸",
    "舗": "瀑",
    "嵗": "岁",
    "勹": "包",
    "犰": "求",
    "棻": "分",
    "侟": "存",
    "塒": "石",
    "蛑": "谋",
    "嫇": "明",
    "爀": "贺",
    "屻": "任",
    "脕": "万",
    "邽": "归",
    "镟": "炫",
    "炵": "通",
    "躶": "裸",
    "亖": "四",
    "錳": "猛",
    "鐾": "被",
    "餡": "现",
    "笀": "忙",
    "鐤": "顶",
    "劄": "扎",
    "冋": "窘",
    "嫋": "尿",
    "啁": "招",
    "扺": "指",
    "玙": "鱼",
    "禰": "迷",
    "榎": "假",
    "夨": "责",
    "壒": "爱",
    "隂": "因",
    "揲": "叠",
    "栭": "而",
    "苀": "行",
    "曚": "盟",
    "竝": "病",
    "蠋": "竹",
    "觎": "鱼",
    "怮": "优",
    "睱": "下",
    "慬": "琴",
    "礿": "月",
    "楢": "由",
    "搌": "展",
    "丬": "强",
    "駝": "驮",
    "徧": "变",
    "粞": "西",
    "溻": "他",
    "俆": "徐",
    "濜": "进",
    "嵫": "姿",
    "颃": "行",
    "勩": "意",
    "刭": "井",
    "锼": "搜",
    "脝": "哼",
    "鎌": "连",
    "慫": "耸",
    "叚": "假",
    "坲": "佛",
    "墍": "系",
    "氼": "逆",
    "鹮": "环",
    "偰": "谢",
    "崞": "锅",
    "檎": "琴",
    "瘜": "西",
    "廲": "离",
    "毆": "欧",
    "洫": "续",
    "萏": "蛋",
    "棩": "冤",
    "崄": "显",
    "傈": "利",
    "槦": "庸",
    "馱": "驮",
    "陥": "现",
    "庨": "消",
    "塝": "棒",
    "樿": "善",
    "琸": "着",
    "瘝": "关",
    "龆": "条",
    "艟": "冲",
    "嗱": "拿",
    "顸": "憨",
    "蚍": "皮",
    "鬈": "全",
    "檛": "抓",
    "砕": "岁",
    "舣": "以",
    "趔": "裂",
    "谵": "占",
    "蚰": "由",
    "沺": "田",
    "斉": "其",
    "烺": "浪",
    "勍": "情",
    "嶠": "教",
    "吙": "霍",
    "鰲": "敖",
    "竒": "其",
    "蠼": "取",
    "冃": "帽",
    "叾": "了",
    "獯": "熏",
    "倳": "字",
    "脙": "修",
    "賁": "必",
    "脡": "挺",
    "潯": "寻",
    "猞": "舍",
    "曁": "记",
    "黴": "梅",
    "勲": "熏",
    "咢": "恶",
    "顒": "庸",
    "朣": "同",
    "膂": "旅",
    "膿": "农",
    "甁": "平",
    "湲": "原",
    "挒": "裂",
    "甶": "福",
    "灺": "谢",
    "艼": "听",
    "侘": "差",
    "皢": "小",
    "妽": "深",
    "笢": "敏",
    "戔": "间",
    "锃": "赠",
    "俵": "标",
    "鉬": "木",
    "琲": "被",
    "蒴": "硕",
    "屲": "挖",
    "斻": "行",
    "掊": "剖",
    "悃": "捆",
    "儖": "蓝",
    "鹚": "瓷",
    "奀": "恩",
    "佲": "命",
    "尜": "嘎",
    "菪": "荡",
    "蛞": "扩",
    "脒": "米",
    "氍": "取",
    "愯": "耸",
    "鳚": "位",
    "莰": "砍",
    "鰨": "塔",
    "杄": "前",
    "螣": "特",
    "跽": "记",
    "嗭": "直",
    "仛": "拖",
    "戽": "互",
    "賄": "会",
    "釵": "拆",
    "寖": "进",
    "橀": "西",
    "珃": "染",
    "锳": "应",
    "諮": "姿",
    "卽": "极",
    "箏": "睁",
    "譏": "机",
    "淰": "年",
    "珧": "摇",
    "涶": "拖",
    "魮": "皮",
    "脟": "裂",
    "毐": "矮",
    "蓅": "刘",
    "侊": "光",
    "畊": "耕",
    "廒": "敖",
    "亣": "大",
    "跢": "堕",
    "鏘": "枪",
    "厙": "设",
    "妋": "夫",
    "酤": "姑",
    "僬": "教",
    "峫": "鞋",
    "眰": "叠",
    "祄": "谢",
    "鈡": "中",
    "郿": "梅",
    "忞": "民",
    "枘": "瑞",
    "枼": "夜",
    "偒": "躺",
    "莀": "陈",
    "偊": "雨",
    "屸": "龙",
    "癔": "意",
    "硂": "全",
    "錡": "其",
    "裰": "多",
    "迗": "额",
    "铹": "劳",
    "埯": "俺",
    "唴": "呛",
    "畤": "至",
    "眳": "明",
    "浉": "诗",
    "斁": "意",
    "鱧": "李",
    "黡": "眼",
    "癱": "贪",
    "轹": "利",
    "跸": "必",
    "偂": "钱",
    "贓": "脏",
    "仈": "八",
    "暠": "搞",
    "壷": "胡",
    "撶": "华",
    "锓": "寝",
    "馇": "插",
    "阼": "做",
    "譁": "华",
    "摅": "书",
    "莈": "墨",
    "揃": "减",
    "脪": "信",
    "苈": "利",
    "躰": "体",
    "労": "劳",
    "蟙": "直",
    "閹": "烟",
    "玊": "速",
    "筧": "减",
    "怴": "续",
    "伖": "躺",
    "旼": "民",
    "冄": "染",
    "崀": "浪",
    "檤": "到",
    "脭": "成",
    "璾": "姿",
    "墼": "机",
    "惣": "总",
    "誾": "银",
    "熼": "意",
    "馑": "紧",
    "掭": "天",
    "綮": "起",
    "誥": "告",
    "亱": "夜",
    "舲": "零",
    "窰": "摇",
    "卲": "绍",
    "拶": "匝",
    "鑚": "钻",
    "礽": "仍",
    "湓": "盆",
    "訖": "气",
    "朿": "次",
    "儼": "眼",
    "脞": "搓",
    "桄": "光",
    "帀": "匝",
    "鹎": "杯",
    "斺": "铲",
    "琞": "胜",
    "鹇": "闲",
    "瘮": "肾",
    "赱": "走",
    "趯": "替",
    "曱": "约",
    "綑": "捆",
    "燹": "显",
    "渖": "审",
    "彁": "歌",
    "穏": "稳",
    "棤": "错",
    "鲀": "吞",
    "磡": "看",
    "逺": "远",
    "垙": "光",
    "暌": "奎",
    "舯": "中",
    "莂": "别",
    "覀": "西",
    "岕": "借",
    "渋": "色",
    "堎": "愣",
    "暎": "硬",
    "燁": "夜",
    "贳": "是",
    "鳢": "李",
    "蓳": "紧",
    "蚡": "坟",
    "秂": "人",
    "馘": "国",
    "焌": "俊",
    "叿": "轰",
    "乬": "巨",
    "儕": "柴",
    "舴": "则",
    "杻": "丑",
    "鍨": "奎",
    "鑴": "西",
    "钔": "门",
    "髑": "毒",
    "伛": "雨",
    "璶": "进",
    "聩": "溃",
    "朲": "人",
    "锩": "卷",
    "祘": "算",
    "栤": "病",
    "浕": "进",
    "韡": "伟",
    "牬": "被",
    "濅": "进",
    "栴": "占",
    "埛": "窘",
    "絺": "吃",
    "玡": "牙",
    "蓆": "习",
    "懾": "设",
    "淯": "玉",
    "摽": "标",
    "拠": "巨",
    "麪": "面",
    "弍": "二",
    "剷": "铲",
    "牐": "炸",
    "榃": "谈",
    "糨": "降",
    "芐": "互",
    "鹪": "教",
    "珝": "许",
    "纓": "应",
    "腘": "国",
    "癯": "取",
    "紶": "区",
    "昺": "饼",
    "袞": "滚",
    "膞": "专",
    "蓊": "瓮",
    "洀": "盘",
    "撱": "伟",
    "垪": "病",
    "潽": "铺",
    "緢": "描",
    "嚆": "蒿",
    "黐": "吃",
    "氇": "撸",
    "嬈": "扰",
    "癀": "黄",
    "氈": "占",
    "儳": "缠",
    "菑": "灾",
    "偧": "扎",
    "炰": "袍",
    "佇": "助",
    "瞫": "审",
    "蛱": "夹",
    "赙": "父",
    "涖": "利",
    "踯": "直",
    "镚": "甭",
    "廑": "紧",
    "蝥": "毛",
    "殪": "意",
    "殢": "替",
    "榱": "催",
    "瞹": "爱",
    "窞": "蛋",
    "澋": "红",
    "巯": "求",
    "籣": "蓝",
    "熴": "昆",
    "庯": "不",
    "瀣": "谢",
    "秏": "号",
    "裑": "深",
    "镈": "博",
    "锫": "培",
    "轱": "姑",
    "踽": "举",
    "囁": "聂",
    "蜉": "福",
    "撹": "角",
    "鏗": "坑",
    "墕": "燕",
    "碥": "扁",
    "脦": "的",
    "賧": "探",
    "螓": "琴",
    "蕻": "红",
    "悘": "一",
    "囂": "消",
    "蔰": "互",
    "旇": "批",
    "羑": "有",
    "祤": "雨",
    "腧": "树",
    "跘": "盘",
    "怱": "聪",
    "粛": "速",
    "墬": "地",
    "鯶": "换",
    "繍": "秀",
    "麇": "君",
    "锿": "哀",
    "艨": "盟",
    "罝": "居",
    "罈": "谈",
    "澉": "感",
    "凕": "命",
    "惓": "全",
    "誨": "会",
    "岆": "咬",
    "踴": "永",
    "瘉": "玉",
    "瀷": "意",
    "憳": "坦",
    "啍": "吞",
    "忛": "翻",
    "揎": "宣",
    "詮": "全",
    "縯": "眼",
    "糰": "团",
    "頵": "晕",
    "寍": "凝",
    "溿": "判",
    "鎢": "乌",
    "偬": "总",
    "茝": "拆",
    "皒": "额",
    "骵": "体",
    "紥": "匝",
    "嚄": "霍",
    "阬": "坑",
    "蛲": "脑",
    "幓": "山",
    "檸": "凝",
    "蟳": "寻",
    "樋": "通",
    "畎": "犬",
    "哖": "年",
    "爣": "躺",
    "蜊": "离",
    "頹": "推",
    "陴": "皮",
    "櫓": "鲁",
    "眙": "宜",
    "矞": "玉",
    "顱": "芦",
    "遯": "顿",
    "勧": "劝",
    "謚": "是",
    "椾": "间",
    "甡": "深",
    "脜": "有",
    "嵝": "楼",
    "辋": "网",
    "彆": "蹩",
    "璣": "机",
    "荌": "按",
    "腠": "凑",
    "莔": "盟",
    "樰": "雪",
    "襌": "单",
    "罥": "倦",
    "鵟": "狂",
    "緵": "宗",
    "璉": "脸",
    "蟜": "角",
    "釈": "是",
    "緞": "断",
    "瘵": "寨",
    "猋": "标",
    "摟": "楼",
    "亁": "干",
    "坩": "干",
    "誡": "借",
    "飈": "标",
    "嗶": "必",
    "擰": "凝",
    "劧": "指",
    "鰕": "虾",
    "蒗": "浪",
    "勶": "撤",
    "闔": "和",
    "菉": "路",
    "鑣": "标",
    "眕": "枕",
    "徠": "来",
    "忾": "开",
    "噵": "到",
    "澂": "成",
    "蒄": "关",
    "幙": "木",
    "牜": "牛",
    "蛦": "宜",
    "鈷": "古",
    "猀": "沙",
    "偢": "丑",
    "簰": "排",
    "瘧": "虐",
    "繙": "翻",
    "薊": "记",
    "偡": "战",
    "熥": "腾",
    "鹨": "六",
    "檺": "搞",
    "彛": "宜",
    "窀": "准",
    "沲": "驮",
    "幀": "挣",
    "咃": "拖",
    "鸀": "楚",
    "玗": "鱼",
    "礌": "雷",
    "訶": "喝",
    "甌": "欧",
    "饋": "溃",
    "嘠": "嘎",
    "鼴": "眼",
    "淂": "德",
    "蓌": "错",
    "泦": "局",
    "縠": "胡",
    "玧": "门",
    "恝": "夹",
    "筊": "肖",
    "潟": "系",
    "嫐": "脑",
    "餼": "系",
    "醑": "许",
    "訇": "轰",
    "唅": "含",
    "鄠": "互",
    "檳": "彬",
    "渓": "西",
    "塭": "温",
    "媱": "摇",
    "閞": "变",
    "鲱": "飞",
    "冿": "间",
    "褙": "被",
    "笵": "饭",
    "鉉": "炫",
    "掕": "零",
    "弇": "眼",
    "赑": "必",
    "攰": "贵",
    "獑": "缠",
    "錕": "昆",
    "耑": "端",
    "茺": "冲",
    "楨": "真",
    "褁": "果",
    "聻": "你",
    "訁": "颜",
    "佝": "勾",
    "緈": "性",
    "紱": "福",
    "幈": "平",
    "咵": "垮",
    "覈": "和",
    "揶": "爷",
    "萢": "抛",
    "蕗": "路",
    "癃": "龙",
    "塲": "长",
    "玅": "庙",
    "瞶": "贵",
    "墚": "良",
    "荅": "答",
    "揑": "捏",
    "鈧": "抗",
    "鲦": "条",
    "硚": "桥",
    "斾": "配",
    "浛": "含",
    "榍": "谢",
    "諳": "安",
    "輋": "舍",
    "眂": "是",
    "鞬": "间",
    "漣": "连",
    "荬": "买",
    "髄": "髓",
    "卋": "是",
    "汧": "前",
    "玍": "尬",
    "酴": "图",
    "榼": "科",
    "刬": "铲",
    "瞜": "楼",
    "垾": "汉",
    "锬": "谈",
    "胼": "偏",
    "鞲": "勾",
    "嵁": "看",
    "劏": "汤",
    "璢": "刘",
    "掓": "书",
    "袼": "歌",
    "粺": "败",
    "驒": "驮",
    "燬": "毁",
    "焠": "翠",
    "蟄": "哲",
    "劅": "着",
    "疇": "愁",
    "偤": "由",
    "緥": "宝",
    "皛": "小",
    "荄": "该",
    "娸": "七",
    "砫": "助",
    "屣": "洗",
    "絫": "垒",
    "穨": "推",
    "緃": "宗",
    "銨": "俺",
    "厛": "听",
    "洑": "福",
    "箹": "约",
    "蹓": "溜",
    "倝": "干",
    "瘊": "喉",
    "汌": "串",
    "懟": "对",
    "狳": "鱼",
    "鸚": "应",
    "泇": "家",
    "辮": "变",
    "祵": "捆",
    "佋": "招",
    "狌": "生",
    "慜": "敏",
    "挱": "撒",
    "鑵": "灌",
    "瞀": "帽",
    "甴": "炸",
    "鬏": "纠",
    "枻": "意",
    "齧": "聂",
    "誸": "闲",
    "鮰": "回",
    "锱": "姿",
    "扙": "帐",
    "壟": "垄",
    "敹": "聊",
    "夛": "多",
    "豋": "灯",
    "楄": "偏",
    "帹": "煞",
    "鉞": "月",
    "莯": "木",
    "洓": "色",
    "敍": "续",
    "鬨": "红",
    "藪": "搜",
    "幆": "意",
    "埡": "呀",
    "侞": "如",
    "狴": "必",
    "蜍": "除",
    "鐥": "善",
    "讁": "哲",
    "蘀": "拓",
    "嚶": "应",
    "酾": "筛",
    "竻": "乐",
    "鐓": "对",
    "竫": "静",
    "覬": "记",
    "肀": "玉",
    "荖": "老",
    "怃": "五",
    "渧": "地",
    "糬": "鼠",
    "靐": "病",
    "吲": "引",
    "瀟": "消",
    "饗": "想",
    "纁": "熏",
    "巒": "鸾",
    "肈": "照",
    "饹": "了",
    "啀": "埃",
    "濰": "维",
    "欵": "款",
    "葜": "掐",
    "椠": "欠",
    "恹": "烟",
    "亸": "朵",
    "荝": "册",
    "鍼": "真",
    "珛": "秀",
    "倢": "节",
    "揀": "减",
    "跂": "其",
    "袑": "绍",
    "倓": "谈",
    "閙": "闹",
    "鱽": "刀",
    "絝": "裤",
    "檊": "干",
    "鼩": "取",
    "吀": "灭",
    "鱨": "长",
    "鉚": "柳",
    "禸": "柔",
    "掍": "混",
    "咹": "恶",
    "澴": "环",
    "悒": "意",
    "貎": "尼",
    "坈": "容",
    "貽": "宜",
    "垯": "哒",
    "芼": "帽",
    "巉": "缠",
    "筢": "爬",
    "鞔": "瞒",
    "邇": "耳",
    "嚙": "聂",
    "鄔": "乌",
    "玕": "干",
    "唦": "沙",
    "黹": "指",
    "儜": "凝",
    "溾": "哀",
    "笓": "必",
    "瘑": "锅",
    "簠": "辅",
    "籶": "深",
    "痄": "咋",
    "憚": "蛋",
    "囮": "额",
    "躄": "必",
    "輓": "碗",
    "姽": "鬼",
    "傗": "处",
    "簩": "劳",
    "晸": "整",
    "胬": "努",
    "姈": "零",
    "聹": "凝",
    "欷": "西",
    "帇": "聂",
    "苖": "敌",
    "瘅": "单",
    "譺": "爱",
    "媖": "应",
    "顕": "显",
    "羖": "古",
    "綅": "亲",
    "蹰": "除",
    "眊": "帽",
    "簳": "感",
    "粦": "林",
    "醵": "巨",
    "镎": "拿",
    "橈": "扰",
    "獀": "搜",
    "頷": "汉",
    "礫": "利",
    "啘": "夜",
    "跐": "刺",
    "衎": "看",
    "柸": "培",
    "湚": "印",
    "掞": "善",
    "肸": "西",
    "賑": "镇",
    "湣": "敏",
    "皊": "零",
    "壈": "懒",
    "翙": "会",
    "匋": "桃",
    "暟": "凯",
    "辁": "全",
    "捑": "责",
    "嫄": "原",
    "宔": "主",
    "岋": "恶",
    "逇": "顿",
    "兊": "对",
    "緌": "瑞",
    "耲": "怀",
    "铞": "掉",
    "聱": "敖",
    "飐": "展",
    "仹": "风",
    "讱": "任",
    "昳": "叠",
    "臓": "藏",
    "謾": "瞒",
    "喁": "庸",
    "偓": "卧",
    "毊": "消",
    "甃": "昼",
    "飖": "摇",
    "鄚": "帽",
    "澝": "宁",
    "钁": "觉",
    "飴": "宜",
    "轳": "芦",
    "儠": "裂",
    "犢": "毒",
    "麯": "区",
    "皟": "则",
    "瓩": "前",
    "舨": "板",
    "萠": "攀",
    "鎔": "容",
    "蟪": "会",
    "莋": "做",
    "姍": "山",
    "钂": "躺",
    "敔": "雨",
    "弙": "乌",
    "賶": "仓",
    "栿": "福",
    "詁": "古",
    "鲥": "石",
    "燂": "谈",
    "胩": "卡",
    "檓": "毁",
    "厾": "督",
    "萻": "安",
    "儨": "至",
    "鈅": "月",
    "稃": "夫",
    "簃": "宜",
    "楛": "互",
    "舢": "山",
    "驥": "记",
    "芻": "除",
    "鍀": "德",
    "竮": "平",
    "堔": "深",
    "鑛": "矿",
    "蝻": "男",
    "鐙": "凳",
    "薆": "爱",
    "祦": "无",
    "瞤": "润",
    "鄗": "号",
    "籔": "搜",
    "恧": "女",
    "皕": "必",
    "瀘": "芦",
    "釗": "招",
    "傒": "西",
    "刕": "离",
    "軚": "带",
    "蟓": "向",
    "濩": "或",
    "枒": "呀",
    "灜": "营",
    "蝨": "诗",
    "蹻": "绝",
    "拃": "眨",
    "濓": "连",
    "嘡": "汤",
    "蹧": "糟",
    "奼": "差",
    "歛": "憨",
    "獺": "塔",
    "洜": "落",
    "礓": "将",
    "倞": "静",
    "潏": "玉",
    "櫧": "朱",
    "梾": "来",
    "蚸": "利",
    "巘": "眼",
    "辵": "绰",
    "詇": "样",
    "姸": "颜",
    "唽": "西",
    "覩": "堵",
    "鵲": "确",
    "侁": "深",
    "槗": "桥",
    "晙": "俊",
    "綯": "桃",
    "壴": "助",
    "伾": "批",
    "儭": "衬",
    "壠": "垄",
    "塴": "甭",
    "鼡": "鼠",
    "肭": "那",
    "瀍": "缠",
    "挌": "格",
    "牱": "歌",
    "劦": "鞋",
    "銫": "色",
    "朙": "明",
    "耖": "吵",
    "妸": "阿",
    "觭": "机",
    "麤": "粗",
    "碞": "颜",
    "彔": "路",
    "璂": "其",
    "氥": "西",
    "鑶": "藏",
    "侫": "宁",
    "禩": "四",
    "绖": "叠",
    "劂": "觉",
    "袆": "灰",
    "槚": "假",
    "亙": "根",
    "菋": "位",
    "絪": "因",
    "謫": "哲",
    "櫟": "利",
    "膪": "踹",
    "嘫": "然",
    "穤": "诺",
    "谫": "减",
    "餬": "胡",
    "晅": "选",
    "訢": "心",
    "鍢": "父",
    "唊": "夹",
    "惪": "德",
    "仧": "长",
    "杧": "忙",
    "萳": "男",
    "埆": "确",
    "蛻": "退",
    "楅": "逼",
    "髈": "绑",
    "楱": "揍",
    "朧": "龙",
    "鞮": "低",
    "狛": "博",
    "鐺": "当",
    "磞": "砰",
    "珨": "侠",
    "茤": "记",
    "咰": "树",
    "欙": "雷",
    "帴": "散",
    "庳": "必",
    "嶏": "配",
    "襕": "蓝",
    "謌": "歌",
    "瀋": "审",
    "惗": "聂",
    "屚": "漏",
    "璈": "敖",
    "鉏": "除",
    "癬": "选",
    "奌": "点",
    "荮": "昼",
    "鬪": "豆",
    "琁": "旋",
    "鲻": "姿",
    "蟎": "满",
    "塙": "确",
    "欖": "懒",
    "覑": "偏",
    "疰": "助",
    "瑉": "民",
    "朅": "妾",
    "枂": "卧",
    "蔹": "脸",
    "騫": "前",
    "檙": "成",
    "蕐": "华",
    "卺": "紧",
    "珴": "额",
    "寜": "凝",
    "牤": "忙",
    "鈐": "钱",
    "搨": "踏",
    "偝": "被",
    "釒": "金",
    "劁": "敲",
    "璥": "井",
    "竾": "持",
    "娰": "四",
    "軼": "意",
    "奓": "扎",
    "纍": "雷",
    "莮": "南",
    "鲣": "间",
    "鹁": "博",
    "傺": "赤",
    "莢": "夹",
    "聟": "续",
    "仐": "三",
    "羕": "样",
    "潾": "林",
    "謡": "摇",
    "吅": "宣",
    "倷": "奶",
    "迀": "干",
    "嫺": "闲",
    "堬": "鱼",
    "掔": "前",
    "蕥": "哑",
    "蕎": "桥",
    "絙": "环",
    "滹": "呼",
    "毹": "书",
    "惛": "昏",
    "逬": "甭",
    "愨": "确",
    "鶇": "东",
    "滠": "设",
    "罺": "朝",
    "紸": "助",
    "胠": "区",
    "悇": "图",
    "葰": "虽",
    "欓": "挡",
    "驵": "脏",
    "嫪": "烙",
    "翃": "红",
    "鯽": "贼",
    "伓": "批",
    "寀": "采",
    "揠": "亚",
    "脮": "内",
    "齮": "以",
    "緾": "缠",
    "忭": "变",
    "棶": "来",
    "闁": "包",
    "聾": "龙",
    "轷": "呼",
    "礀": "见",
    "斱": "着",
    "邏": "罗",
    "賸": "胜",
    "烴": "听",
    "謕": "提",
    "棐": "匪",
    "廆": "归",
    "痳": "林",
    "憡": "册",
    "乁": "宜",
    "萇": "长",
    "嵎": "鱼",
    "綪": "欠",
    "軛": "恶",
    "粠": "红",
    "羼": "颤",
    "痦": "物",
    "蟴": "思",
    "淃": "倦",
    "檒": "风",
    "蔀": "不",
    "嚸": "点",
    "偑": "风",
    "鲙": "快",
    "傉": "怒",
    "纞": "练",
    "洚": "降",
    "堦": "接",
    "驋": "波",
    "瓌": "归",
    "髎": "聊",
    "縴": "欠",
    "紈": "完",
    "挗": "觉",
    "唍": "碗",
    "襬": "摆",
    "醸": "娘",
    "漀": "请",
    "祊": "崩",
    "礳": "墨",
    "鬢": "宾",
    "簑": "缩",
    "灋": "法",
    "扂": "电",
    "覷": "去",
    "鮃": "平",
    "儣": "旷",
    "儻": "躺",
    "滉": "荒",
    "铏": "行",
    "蒺": "极",
    "啋": "采",
    "嬡": "爱",
    "錵": "花",
    "嚨": "龙",
    "扡": "拖",
    "譟": "造",
    "悧": "利",
    "馫": "心",
    "彶": "极",
    "鲼": "愤",
    "瘼": "墨",
    "螬": "曹",
    "絾": "成",
    "餚": "摇",
    "轅": "原",
    "崯": "银",
    "崕": "牙",
    "羋": "米",
    "捥": "万",
    "唢": "锁",
    "螵": "飘",
    "蹀": "叠",
    "莬": "问",
    "婗": "尼",
    "摢": "互",
    "秖": "知",
    "胲": "海",
    "葇": "柔",
    "綷": "翠",
    "珗": "先",
    "縂": "总",
    "錒": "科",
    "蔌": "速",
    "輦": "年",
    "媃": "柔",
    "繎": "然",
    "饌": "赚",
    "糹": "思",
    "秠": "批",
    "躪": "吝",
    "觧": "解",
    "潁": "影",
    "鼽": "求",
    "柾": "就",
    "鲐": "台",
    "鄫": "增",
    "吘": "偶",
    "鎓": "瓮",
    "磜": "气",
    "罽": "记",
    "糇": "喉",
    "伹": "区",
    "慇": "因",
    "婞": "性",
    "圕": "图",
    "珋": "柳",
    "簺": "赛",
    "梼": "桃",
    "鋤": "除",
    "柅": "你",
    "覦": "鱼",
    "乧": "抖",
    "壢": "利",
    "驃": "标",
    "啯": "锅",
    "嵨": "物",
    "蹠": "直",
    "瘯": "促",
    "仸": "咬",
    "臑": "闹",
    "愝": "眼",
    "钸": "不",
    "姁": "许",
    "穠": "农",
    "袊": "领",
    "謘": "持",
    "敱": "埃",
    "蓧": "掉",
    "洖": "无",
    "嬤": "妈",
    "鈽": "不",
    "瞍": "搜",
    "徬": "旁",
    "儎": "在",
    "唣": "造",
    "曢": "了",
    "毞": "皮",
    "鏞": "庸",
    "鼔": "古",
    "蒡": "棒",
    "枟": "运",
    "賨": "从",
    "簕": "乐",
    "稈": "感",
    "湑": "需",
    "楙": "帽",
    "唞": "抖",
    "紦": "八",
    "膾": "快",
    "閟": "必",
    "邉": "编",
    "洯": "妾",
    "裛": "意",
    "鍌": "显",
    "籥": "月",
    "歓": "欢",
    "衊": "灭",
    "摱": "慢",
    "琋": "西",
    "旣": "记",
    "睒": "闪",
    "翫": "完",
    "貰": "是",
    "懮": "有",
    "岞": "做",
    "輟": "绰",
    "嗏": "插",
    "茇": "拔",
    "仚": "先",
    "姇": "夫",
    "琩": "昌",
    "卹": "续",
    "偱": "寻",
    "筳": "停",
    "硓": "老",
    "堌": "固",
    "垬": "红",
    "骒": "客",
    "妭": "拔",
    "凎": "干",
    "橎": "烦",
    "粶": "路",
    "鞚": "控",
    "潕": "五",
    "垇": "奥",
    "尰": "种",
    "蔮": "国",
    "燾": "到",
    "猄": "精",
    "幪": "盟",
    "凔": "创",
    "畯": "俊",
    "紭": "红",
    "嬾": "懒",
    "垻": "爸",
    "殹": "意",
    "襛": "农",
    "蓣": "玉",
    "牿": "固",
    "昫": "续",
    "廌": "至",
    "秈": "先",
    "唚": "亲",
    "銖": "朱",
    "傦": "古",
    "潩": "意",
    "穉": "至",
    "躐": "裂",
    "腍": "任",
    "帍": "互",
    "赇": "求",
    "舃": "系",
    "曕": "燕",
    "犏": "偏",
    "緖": "续",
    "鍎": "图",
    "纻": "助",
    "虒": "思",
    "瘌": "蜡",
    "訚": "银",
    "杬": "原",
    "蕰": "温",
    "樉": "双",
    "鏻": "林",
    "夆": "逢",
    "盨": "许",
    "搆": "够",
    "怩": "尼",
    "偟": "黄",
    "嘸": "辅",
    "暏": "鼠",
    "劻": "框",
    "媤": "思",
    "瀏": "刘",
    "幗": "国",
    "洝": "按",
    "瑒": "唱",
    "垞": "茶",
    "禋": "因",
    "絔": "摆",
    "耵": "丁",
    "縊": "意",
    "埶": "意",
    "鈸": "博",
    "閆": "颜",
    "曺": "曹",
    "孿": "鸾",
    "墈": "看",
    "筥": "举",
    "磉": "桑",
    "暚": "摇",
    "卄": "念",
    "仯": "吵",
    "羴": "山",
    "萺": "帽",
    "縈": "营",
    "狝": "显",
    "憝": "对",
    "洢": "一",
    "綻": "战",
    "篚": "匪",
    "纩": "矿",
    "酈": "利",
    "秷": "至",
    "乿": "至",
    "蠪": "龙",
    "潚": "速",
    "驩": "欢",
    "旈": "刘",
    "搷": "田",
    "冱": "互",
    "誫": "镇",
    "圞": "鸾",
    "瑈": "柔",
    "拫": "很",
    "垝": "鬼",
    "淉": "果",
    "悰": "从",
    "饞": "缠",
    "掎": "几",
    "灪": "玉",
    "鲚": "记",
    "杋": "烦",
    "僊": "先",
    "峧": "教",
    "嵙": "科",
    "厖": "旁",
    "坣": "唐",
    "悜": "成",
    "蝧": "应",
    "祃": "骂",
    "窣": "苏",
    "婥": "闹",
    "闌": "蓝",
    "俫": "来",
    "黩": "毒",
    "櫶": "显",
    "乆": "久",
    "韘": "设",
    "眍": "口",
    "珎": "真",
    "勊": "客",
    "擭": "卧",
    "荈": "喘",
    "蕑": "间",
    "倀": "昌",
    "鄀": "弱",
    "郪": "七",
    "炑": "木",
    "浽": "虽",
    "丵": "着",
    "媏": "端",
    "漖": "教",
    "兏": "长",
    "鰺": "深",
    "屝": "费",
    "敮": "侠",
    "穣": "嚷",
    "偙": "地",
    "璆": "求",
    "苝": "被",
    "縞": "搞",
    "灃": "风",
    "韮": "久",
    "讃": "赞",
    "颩": "标",
    "鲴": "固",
    "秪": "知",
    "崌": "居",
    "坬": "挂",
    "銼": "错",
    "忥": "系",
    "菛": "门",
    "缊": "晕",
    "筚": "必",
    "轆": "路",
    "秞": "由",
    "笘": "山",
    "釹": "女",
    "姴": "裂",
    "姱": "夸",
    "鎿": "拿",
    "燜": "闷",
    "茖": "格",
    "覲": "进",
    "瑅": "提",
    "鄜": "夫",
    "綃": "消",
    "嵂": "绿",
    "朓": "挑",
    "瘽": "琴",
    "枔": "信",
    "愶": "鞋",
    "籏": "其",
    "珄": "生",
    "綖": "颜",
    "韌": "任",
    "枙": "饿",
    "苭": "咬",
    "餃": "角",
    "褢": "怀",
    "漨": "逢",
    "炌": "开",
    "赿": "持",
    "圀": "国",
    "聺": "茄",
    "觖": "觉",
    "熒": "营",
    "宑": "井",
    "嘼": "处",
    "侚": "训",
    "鮠": "维",
    "棌": "菜",
    "攣": "鸾",
    "粅": "物",
    "頞": "恶",
    "錀": "伦",
    "邚": "如",
    "佂": "睁",
    "艌": "念",
    "妠": "那",
    "貙": "出",
    "驪": "离",
    "疬": "利",
    "燼": "进",
    "埫": "宠",
    "圴": "着",
    "炩": "另",
    "仒": "冰",
    "嫙": "旋",
    "觃": "燕",
    "鳮": "机",
    "燋": "教",
    "憇": "气",
    "茀": "福",
    "嘙": "婆",
    "哳": "扎",
    "喥": "夺",
    "鴇": "宝",
    "颋": "挺",
    "櫌": "优",
    "鵠": "胡",
    "姃": "睁",
    "羓": "八",
    "儐": "彬",
    "釿": "金",
    "堚": "魂",
    "惔": "谈",
    "慚": "残",
    "寚": "宝",
    "臯": "高",
    "龗": "零",
    "裀": "因",
    "橞": "会",
    "訝": "亚",
    "爍": "硕",
    "捃": "俊",
    "殽": "肖",
    "澱": "电",
    "堽": "刚",
    "哃": "同",
    "浡": "博",
    "蝭": "提",
    "濏": "色",
    "蒱": "葡",
    "炶": "闪",
    "蝤": "求",
    "艅": "鱼",
    "鮀": "驮",
    "媜": "睁",
    "苩": "博",
    "鏑": "敌",
    "眔": "大",
    "羶": "山",
    "渁": "冤",
    "韁": "将",
    "菝": "拔",
    "溡": "石",
    "晛": "现",
    "栳": "老",
    "敺": "区",
    "楋": "蜡",
    "徯": "西",
    "緟": "虫",
    "朥": "劳",
    "閡": "爱",
    "晣": "哲",
    "踺": "见",
    "桭": "真",
    "鲺": "诗",
    "溋": "营",
    "姙": "任",
    "犂": "离",
    "葎": "绿",
    "籾": "尼",
    "猸": "梅",
    "颟": "慢",
    "娖": "绰",
    "魜": "人",
    "嘮": "劳",
    "俁": "雨",
    "諗": "审",
    "殍": "漂",
    "靦": "舔",
    "堉": "玉",
    "嫈": "应",
    "檝": "极",
    "寑": "寝",
    "珌": "必",
    "琹": "琴",
    "裈": "昆",
    "溘": "客",
    "鐲": "着",
    "偋": "病",
    "尞": "料",
    "鱺": "离",
    "枹": "包",
    "殭": "将",
    "裵": "培",
    "虍": "呼",
    "弸": "朋",
    "諺": "燕",
    "讒": "缠",
    "砞": "墨",
    "魴": "房",
    "峴": "现",
    "儬": "庆",
    "玨": "觉",
    "炟": "达",
    "臔": "现",
    "嶧": "意",
    "靄": "矮",
    "鋐": "红",
    "壙": "矿",
    "瞷": "见",
    "哯": "现",
    "稆": "旅",
    "虯": "求",
    "鷇": "扣",
    "鈿": "田",
    "斈": "学",
    "槡": "丧",
    "偔": "恶",
    "瑝": "黄",
    "卾": "恶",
    "姖": "巨",
    "苪": "饼",
    "坮": "台",
    "鏜": "汤",
    "粰": "福",
    "睪": "意",
    "鈭": "姿",
    "羆": "皮",
    "嫭": "互",
    "葁": "将",
    "伩": "信",
    "苮": "先",
    "鄕": "相",
    "猇": "消",
    "芺": "袄",
    "皀": "极",
    "齦": "肯",
    "筴": "册",
    "懽": "欢",
    "梠": "旅",
    "棈": "欠",
    "懺": "颤",
    "妏": "问",
    "喦": "聂",
    "舦": "太",
    "爜": "从",
    "鈇": "夫",
    "廩": "吝",
    "蝸": "窝",
    "阩": "生",
    "滳": "伤",
    "驡": "龙",
    "筁": "区",
    "皐": "高",
    "挍": "教",
    "篺": "皮",
    "絬": "谢",
    "姛": "动",
    "葷": "昏",
    "祹": "桃",
    "攷": "考",
    "藺": "吝",
    "彨": "吃",
    "筎": "如",
    "婏": "饭",
    "澁": "色",
    "晻": "按",
    "慡": "双",
    "溞": "骚",
    "拑": "钱",
    "釁": "信",
    "暔": "南",
    "膄": "瘦",
    "曄": "夜",
    "糢": "魔",
    "飭": "赤",
    "弌": "一",
    "犋": "巨",
    "詪": "很",
    "朢": "忘",
    "敭": "羊",
    "榦": "干",
    "寕": "凝",
    "鈤": "日",
    "鱲": "裂",
    "瞵": "林",
    "憫": "敏",
    "聛": "比",
    "睘": "穷",
    "眅": "攀",
    "薗": "原",
    "芚": "吞",
    "驫": "标",
    "畐": "福",
    "朏": "匪",
    "鲹": "深",
    "栻": "是",
    "鼯": "无",
    "疭": "宗",
    "賥": "岁",
    "蟞": "憋",
    "嘰": "机",
    "犾": "银",
    "緆": "西",
    "嘔": "偶",
    "窸": "西",
    "鹓": "冤",
    "驤": "相",
    "姎": "养",
    "聍": "凝",
    "櫂": "照",
    "嫽": "聊",
    "醤": "降",
    "嶸": "容",
    "曵": "夜",
    "辚": "林",
    "潪": "这",
    "牾": "五",
    "儗": "你",
    "蕡": "坟",
    "煠": "炸",
    "嚦": "利",
    "哊": "右",
    "罙": "深",
    "勑": "赤",
    "阯": "指",
    "沷": "发",
    "剻": "捧",
    "葽": "邀",
    "唪": "奉",
    "儰": "伟",
    "倧": "宗",
    "釩": "反",
    "魕": "几",
    "玭": "贫",
    "絘": "次",
    "塥": "格",
    "棫": "玉",
    "鉾": "谋",
    "鱔": "善",
    "棸": "邹",
    "錬": "练",
    "巌": "颜",
    "蓺": "意",
    "羭": "鱼",
    "抇": "胡",
    "撖": "汉",
    "纴": "任",
    "暅": "更",
    "迚": "达",
    "铔": "呀",
    "栵": "裂",
    "盺": "心",
    "綢": "愁",
    "慥": "造",
    "孭": "灭",
    "鸛": "灌",
    "摑": "乖",
    "輜": "姿",
    "厰": "场",
    "僣": "铁",
    "焄": "熏",
    "幖": "标",
    "蚦": "然",
    "皁": "造",
    "帓": "墨",
    "驎": "林",
    "鴒": "零",
    "奡": "奥",
    "怊": "超",
    "鼷": "西",
    "魘": "眼",
    "昪": "变",
    "湸": "亮",
    "鸻": "横",
    "掻": "骚",
    "霽": "记",
    "敩": "笑",
    "瘨": "颠",
    "骃": "因",
    "倰": "愣",
    "緳": "鞋",
    "疌": "节",
    "貮": "二",
    "蝟": "位",
    "澛": "鲁",
    "妴": "院",
    "屃": "系",
    "厐": "旁",
    "柤": "扎",
    "玓": "地",
    "詬": "够",
    "邤": "心",
    "侂": "拖",
    "蘂": "瑞",
    "疂": "叠",
    "呧": "底",
    "遶": "绕",
    "倅": "翠",
    "楪": "夜",
    "臚": "芦",
    "紪": "七",
    "舭": "比",
    "囸": "日",
    "竡": "摆",
    "蓂": "明",
    "巇": "西",
    "筦": "管",
    "隄": "低",
    "厯": "利",
    "桊": "倦",
    "紞": "胆",
    "杇": "乌",
    "弜": "降",
    "殞": "允",
    "哱": "波",
    "縥": "枕",
    "喓": "邀",
    "庛": "次",
    "篸": "惨",
    "誧": "不",
    "苶": "捏",
    "裇": "需",
    "痃": "旋",
    "糥": "诺",
    "毦": "耳",
    "溚": "塔",
    "泲": "几",
    "琺": "发",
    "矟": "硕",
    "彇": "消",
    "緲": "秒",
    "澬": "姿",
    "柦": "蛋",
    "鷸": "玉",
    "軆": "体",
    "摛": "吃",
    "牎": "窗",
    "偐": "燕",
    "蒈": "凯",
    "胕": "辅",
    "旪": "鞋",
    "欬": "开",
    "畻": "成",
    "簊": "机",
    "塽": "双",
    "凨": "风",
    "牘": "毒",
    "唖": "哑",
    "禵": "提",
    "墺": "奥",
    "藌": "密",
    "髫": "条",
    "噏": "西",
    "扖": "入",
    "鹖": "和",
    "幎": "密",
    "柺": "拐",
    "唃": "古",
    "駮": "博",
    "暪": "闷",
    "奻": "暖",
    "徦": "假",
    "狘": "血",
    "閠": "润",
    "褆": "提",
    "瘖": "因",
    "妬": "度",
    "霫": "习",
    "埅": "房",
    "倐": "书",
    "阽": "电",
    "敾": "善",
    "覠": "君",
    "攲": "七",
    "噚": "寻",
    "湥": "突",
    "阧": "抖",
    "筭": "算",
    "鹋": "描",
    "耠": "霍",
    "湶": "全",
    "呫": "贴",
    "痋": "腾",
    "燴": "会",
    "觢": "是",
    "裊": "尿",
    "璱": "色",
    "砮": "努",
    "洊": "见",
    "掗": "亚",
    "槇": "颠",
    "赪": "称",
    "馂": "俊",
    "畵": "话",
    "粔": "巨",
    "渏": "一",
    "癟": "别",
    "钘": "行",
    "鷍": "消",
    "騁": "成",
    "螗": "唐",
    "惲": "运",
    "皝": "荒",
    "亴": "右",
    "銬": "烤",
    "沝": "缀",
    "彉": "锅",
    "莙": "君",
    "艴": "福",
    "籘": "腾",
    "珒": "金",
    "僆": "练",
    "紩": "至",
    "詫": "差",
    "痙": "静",
    "糀": "花",
    "昄": "板",
    "鮁": "波",
    "遈": "石",
    "沇": "眼",
    "襖": "袄",
    "鄖": "云",
    "餽": "溃",
    "崢": "睁",
    "姠": "向",
    "蒾": "迷",
    "遹": "玉",
    "衼": "知",
    "鲒": "节",
    "稙": "知",
    "窾": "款",
    "莦": "烧",
    "柉": "烦",
    "廍": "不",
    "嫤": "紧",
    "瓀": "软",
    "巟": "荒",
    "汣": "久",
    "砆": "夫",
    "鄘": "庸",
    "獙": "必",
    "蚮": "带",
    "痖": "哑",
    "頡": "鞋",
    "餴": "分",
    "狉": "批",
    "紟": "金",
    "儊": "处",
    "捚": "摘",
    "薺": "记",
    "抲": "喝",
    "脃": "翠",
    "瞙": "墨",
    "讖": "衬",
    "晹": "意",
    "姢": "捐",
    "閎": "红",
    "櫼": "间",
    "瞐": "墨",
    "弽": "设",
    "唗": "兜",
    "唓": "车",
    "髖": "宽",
    "褝": "单",
    "蔄": "慢",
    "鎘": "利",
    "抰": "养",
    "抷": "批",
    "鳆": "父",
    "餔": "不",
    "謟": "掏",
    "櫎": "谎",
    "汖": "聘",
    "縉": "进",
    "歀": "款",
    "踭": "睁",
    "睙": "裂",
    "簵": "路",
    "鯡": "费",
    "躾": "美",
    "渙": "换",
    "婻": "难",
    "弻": "必",
    "鼈": "憋",
    "綰": "碗",
    "釭": "刚",
    "刧": "节",
    "潡": "顿",
    "擓": "快",
    "瀼": "嚷",
    "烚": "侠",
    "炐": "胖",
    "垶": "星",
    "亹": "伟",
    "鴅": "欢",
    "襶": "带",
    "犪": "奎",
    "癩": "赖",
    "刄": "任",
    "佮": "格",
    "戉": "月",
    "褖": "团",
    "蹺": "敲",
    "繻": "需",
    "暋": "敏",
    "玂": "其",
    "鯧": "昌",
    "盵": "气",
    "贔": "必",
    "嚗": "博",
    "簀": "则",
    "曪": "裸",
    "狋": "宜",
    "嫹": "描",
    "偛": "插",
    "嫨": "憨",
    "衱": "节",
    "纀": "葡",
    "丏": "免",
    "銏": "善",
    "蔦": "尿",
    "酂": "搓",
    "梜": "家",
    "睎": "西",
    "礛": "间",
    "賔": "彬",
    "鯔": "姿",
    "挷": "朋",
    "辀": "周",
    "咅": "剖",
    "丠": "秋",
    "伃": "鱼",
    "翣": "煞",
    "泃": "居",
    "繀": "岁",
    "掜": "意",
    "铻": "无",
    "颺": "羊",
    "潙": "维",
    "昽": "龙",
    "蕅": "偶",
    "鑪": "芦",
    "躭": "单",
    "骹": "敲",
    "眹": "镇",
    "厼": "耳",
    "蘫": "汉",
    "顥": "号",
    "栁": "柳",
    "屟": "谢",
    "眴": "炫",
    "紂": "昼",
    "鲃": "八",
    "泿": "银",
    "縝": "陈",
    "蒎": "派",
    "勠": "路",
    "潄": "树",
    "煬": "羊",
    "奍": "圈",
    "搲": "挖",
    "臍": "其",
    "濶": "扩",
    "痷": "安",
    "辿": "搀",
    "涬": "性",
    "渷": "眼",
    "搣": "灭",
    "杮": "费",
    "踇": "母",
    "繊": "先",
    "鍕": "君",
    "淓": "方",
    "鸰": "零",
    "蒍": "伟",
    "琗": "色",
    "瀽": "减",
    "暣": "气",
    "嫆": "容",
    "鐚": "呀",
    "鴛": "冤",
    "杙": "意",
    "巺": "训",
    "鲕": "而",
    "陁": "驮",
    "烸": "海",
    "薁": "玉",
    "捊": "剖",
    "蒞": "利",
    "掋": "底",
    "瀁": "样",
    "碏": "确",
    "澇": "烙",
    "嚿": "或",
    "癈": "费",
    "衴": "胆",
    "鹟": "瓮",
    "騑": "飞",
    "蔲": "扣",
    "醨": "离",
    "潬": "善",
    "鐳": "雷",
    "麑": "尼",
    "鬽": "妹",
    "婍": "起",
    "廼": "奶",
    "鬭": "豆",
    "塹": "欠",
    "鹀": "无",
    "縵": "慢",
    "赆": "进",
    "喯": "喷",
    "咡": "二",
    "廄": "就",
    "軔": "任",
    "袃": "拆",
    "籟": "赖",
    "琿": "魂",
    "倗": "朋",
    "櫄": "春",
    "硈": "恰",
    "挃": "至",
    "弶": "降",
    "禔": "知",
    "輾": "展",
    "肶": "皮",
    "侌": "因",
    "箙": "福",
    "錛": "奔",
    "苽": "姑",
    "倁": "知",
    "琠": "舔",
    "洃": "灰",
    "硄": "框",
    "詟": "哲",
    "蝓": "鱼",
    "溍": "进",
    "堊": "恶",
    "蘘": "嚷",
    "秺": "度",
    "槅": "格",
    "叜": "搜",
    "靣": "面",
    "赻": "显",
    "蔶": "则",
    "瘺": "漏",
    "晽": "林",
    "綆": "梗",
    "謢": "撸",
    "僢": "喘",
    "昋": "贵",
    "婌": "熟",
    "謐": "密",
    "嬋": "缠",
    "唲": "而",
    "鑊": "或",
    "粖": "墨",
    "餾": "六",
    "楉": "弱",
    "櫨": "芦",
    "悵": "唱",
    "倕": "垂",
    "棽": "深",
    "蝝": "原",
    "釬": "汉",
    "盁": "营",
    "笶": "使",
    "廡": "五",
    "鰩": "摇",
    "嚞": "哲",
    "桻": "风",
    "緗": "相",
    "斲": "着",
    "謋": "或",
    "譞": "宣",
    "恇": "框",
    "畞": "母",
    "瀆": "毒",
    "巆": "容",
    "漧": "干",
    "鵑": "捐",
    "窛": "扣",
    "竪": "树",
    "硙": "维",
    "飝": "飞",
    "釧": "串",
    "壵": "壮",
    "纘": "钻",
    "簭": "是",
    "憙": "西",
    "晲": "你",
    "蝣": "由",
    "掆": "刚",
    "磘": "摇",
    "鐔": "信",
    "騏": "其",
    "巠": "精",
    "藠": "教",
    "膋": "聊",
    "抅": "居",
    "黢": "区",
    "殮": "练",
    "曀": "意",
    "墫": "尊",
    "殩": "窜",
    "宆": "穷",
    "琓": "完",
    "櫤": "降",
    "蔯": "陈",
    "薀": "运",
    "睆": "换",
    "轡": "配",
    "匼": "科",
    "樷": "从",
    "煿": "博",
    "洘": "考",
    "祏": "石",
    "皦": "角",
    "阷": "称",
    "鋳": "助",
    "詡": "许",
    "贍": "善",
    "锽": "黄",
    "龥": "玉",
    "唒": "求",
    "悾": "空",
    "嵥": "节",
    "迆": "宜",
    "秴": "和",
    "瑍": "换",
    "煐": "应",
    "惂": "砍",
    "蓀": "孙",
    "娤": "装",
    "脎": "萨",
    "皥": "号",
    "箰": "损",
    "儢": "旅",
    "爝": "觉",
    "瓟": "博",
    "俛": "辅",
    "腨": "涮",
    "硑": "砰",
    "窅": "咬",
    "篭": "龙",
    "褦": "耐",
    "楒": "思",
    "翯": "贺",
    "饃": "魔",
    "榠": "明",
    "黓": "意",
    "笖": "以",
    "蜑": "蛋",
    "熲": "窘",
    "鮱": "老",
    "抪": "不",
    "糌": "赞",
    "箠": "垂",
    "牗": "有",
    "縹": "漂",
    "嘜": "骂",
    "鶸": "弱",
    "詓": "曲",
    "棑": "排",
    "橢": "妥",
    "眗": "居",
    "炣": "可",
    "蓰": "洗",
    "繄": "一",
    "晵": "起",
    "嵆": "机",
    "菻": "吝",
    "軫": "枕",
    "餹": "唐",
    "徍": "网",
    "刼": "节",
    "豷": "意",
    "紇": "和",
    "蒻": "弱",
    "賡": "耕",
    "鳪": "哺",
    "澣": "换",
    "妼": "必",
    "楬": "节",
    "袕": "学",
    "裯": "愁",
    "敼": "以",
    "柷": "处",
    "鑀": "爱",
    "湭": "求",
    "擩": "乳",
    "鴈": "燕",
    "苰": "红",
    "喌": "周",
    "軻": "科",
    "鯓": "深",
    "撔": "红",
    "闉": "因",
    "浵": "同",
    "摂": "设",
    "緘": "间",
    "溁": "营",
    "軦": "矿",
    "湋": "维",
    "鶚": "恶",
    "蜣": "枪",
    "峘": "环",
    "嘦": "教",
    "絣": "崩",
    "銙": "垮",
    "丂": "考",
    "朷": "刀",
    "撾": "窝",
    "垏": "绿",
    "銻": "提",
    "獥": "教",
    "惉": "占",
    "廕": "印",
    "烱": "窘",
    "泴": "灌",
    "噰": "庸",
    "擷": "鞋",
    "挴": "美",
    "囻": "国",
    "厎": "底",
    "瑳": "搓",
    "盻": "系",
    "垰": "卡",
    "劚": "竹",
    "俙": "西",
    "勷": "嚷",
    "礚": "科",
    "蘗": "薄",
    "淢": "玉",
    "焮": "信",
    "娮": "颜",
    "鍺": "朵",
    "匄": "概",
    "匽": "眼",
    "鉍": "必",
    "聦": "聪",
    "埳": "砍",
    "頫": "辅",
    "呅": "梅",
    "呏": "生",
    "溸": "速",
    "噝": "思",
    "惝": "场",
    "搢": "进",
    "骕": "速",
    "窊": "挖",
    "銥": "一",
    "阢": "物",
    "撗": "逛",
    "鎱": "原",
    "槺": "康",
    "翺": "敖",
    "鲌": "爸",
    "粯": "现",
    "亷": "连",
    "骍": "星",
    "奣": "瓮",
    "騧": "瓜",
    "箘": "俊",
    "訕": "善",
    "唝": "共",
    "薳": "伟",
    "厽": "垒",
    "墽": "敲",
    "侢": "带",
    "娒": "梅",
    "癘": "利",
    "頴": "影",
    "諴": "闲",
    "瀯": "营",
    "聨": "连",
    "鉱": "矿",
    "蘺": "离",
    "鮓": "眨",
    "蒓": "纯",
    "燏": "玉",
    "瓛": "环",
    "遆": "提",
    "矷": "子",
    "殣": "进",
    "剅": "楼",
    "敳": "埃",
    "粙": "昼",
    "畱": "刘",
    "釷": "土",
    "麅": "袍",
    "觝": "底",
    "謗": "棒",
    "凲": "干",
    "嚰": "魔",
    "惈": "果",
    "撣": "胆",
    "焢": "轰",
    "藞": "啦",
    "擫": "夜",
    "賚": "赖",
    "鯙": "纯",
    "躉": "蹲",
    "姅": "办",
    "爼": "组",
    "惤": "间",
    "圵": "荡",
    "葂": "免",
    "羛": "意",
    "柈": "办",
    "敧": "机",
    "篜": "睁",
    "鯷": "提",
    "臸": "知",
    "筩": "同",
    "氂": "毛",
    "騮": "刘",
    "歞": "恶",
    "孅": "前",
    "纒": "缠",
    "劐": "霍",
    "啣": "闲",
    "偞": "谢",
    "欥": "意",
    "昻": "昂",
    "琂": "颜",
    "邘": "鱼",
    "瓅": "利",
    "諠": "宣",
    "迋": "忘",
    "欱": "喝",
    "侹": "挺",
    "棪": "眼",
    "乢": "概",
    "筬": "成",
    "喅": "玉",
    "礞": "盟",
    "盿": "民",
    "獟": "要",
    "遡": "速",
    "弪": "静",
    "槪": "概",
    "傪": "参",
    "鴝": "取",
    "刲": "亏",
    "狥": "训",
    "摡": "概",
    "挓": "扎",
    "瑮": "利",
    "聝": "国",
    "瓲": "哇",
    "詀": "占",
    "滽": "庸",
    "鋇": "被",
    "儅": "荡",
    "獏": "墨",
    "硿": "空",
    "咍": "孩",
    "謿": "朝",
    "犅": "刚",
    "蹌": "枪",
    "铇": "报",
    "戤": "概",
    "廰": "听",
    "謅": "周",
    "豄": "毒",
    "簹": "当",
    "摷": "角",
    "栃": "利",
    "蟫": "银",
    "迖": "达",
    "羃": "密",
    "籇": "豪",
    "鼇": "敖",
    "媷": "入",
    "罿": "冲",
    "糡": "降",
    "扐": "乐",
    "齶": "恶",
    "閼": "恶",
    "邲": "必",
    "膬": "翠",
    "栂": "梅",
    "讎": "愁",
    "掅": "庆",
    "杽": "丑",
    "砢": "科",
    "暒": "情",
    "慼": "七",
    "摶": "团",
    "锠": "昌",
    "僇": "路",
    "缾": "平",
    "铦": "先",
    "禫": "蛋",
    "詎": "巨",
    "笩": "罚",
    "湩": "动",
    "廘": "路",
    "泂": "窘",
    "鴷": "裂",
    "駟": "四",
    "醡": "咋",
    "薔": "强",
    "舩": "传",
    "膕": "国",
    "焔": "燕",
    "鲰": "邹",
    "繬": "色",
    "璫": "当",
    "蹍": "年",
    "櫥": "除",
    "狢": "和",
    "錞": "纯",
    "筈": "扩",
    "璹": "熟",
    "踼": "唐",
    "魊": "玉",
    "抃": "变",
    "癹": "拔",
    "穓": "意",
    "魎": "两",
    "崠": "东",
    "擿": "踢",
    "葢": "概",
    "佒": "养",
    "秨": "做",
    "腃": "溃",
    "筣": "离",
    "鈀": "靶",
    "禗": "思",
    "嫿": "话",
    "諶": "陈",
    "歠": "绰",
    "鐟": "赞",
    "駢": "偏",
    "鐕": "赞",
    "夀": "瘦",
    "蜾": "果",
    "唙": "敌",
    "挐": "拿",
    "雰": "分",
    "蹾": "蹲",
    "鏤": "漏",
    "酖": "镇",
    "剳": "达",
    "鴟": "吃",
    "鉭": "坦",
    "鳘": "敏",
    "噀": "训",
    "愺": "草",
    "諟": "是",
    "坰": "窘",
    "摣": "扎",
    "煚": "窘",
    "櫲": "玉",
    "椆": "愁",
    "筿": "小",
    "魆": "需",
    "綇": "修",
    "宼": "扣",
    "祡": "柴",
    "俻": "被",
    "螋": "搜",
    "鳣": "占",
    "繛": "绰",
    "猙": "睁",
    "眎": "是",
    "穘": "消",
    "菢": "报",
    "荙": "达",
    "辒": "温",
    "譎": "觉",
    "矦": "喉",
    "縋": "缀",
    "旓": "烧",
    "盢": "续",
    "榞": "原",
    "瀀": "优",
    "躡": "聂",
    "穋": "路",
    "屇": "田",
    "墰": "谈",
    "浭": "耕",
    "鉸": "角",
    "奤": "哈",
    "嶲": "西",
    "椑": "杯",
    "擧": "举",
    "碡": "毒",
    "耤": "极",
    "剕": "费",
    "妶": "闲",
    "觤": "鬼",
    "滧": "摇",
    "朤": "浪",
    "銣": "如",
    "鯱": "虎",
    "厡": "原",
    "嗼": "墨",
    "簣": "溃",
    "鍫": "敲",
    "俥": "车",
    "唼": "煞",
    "溂": "蜡",
    "篋": "妾",
    "蟌": "聪",
    "匸": "系",
    "瑸": "彬",
    "喼": "接",
    "勗": "续",
    "唜": "墨",
    "陑": "而",
    "赼": "姿",
    "獰": "凝",
    "椪": "碰",
    "敇": "册",
    "萡": "波",
    "蠎": "忙",
    "狖": "右",
    "緔": "上",
    "毉": "一",
    "鎣": "营",
    "谸": "前",
    "娧": "退",
    "芉": "干",
    "瑔": "全",
    "鱟": "后",
    "聑": "贴",
    "縺": "连",
    "慤": "确",
    "嗢": "袜",
    "豲": "环",
    "蔿": "伟",
    "襷": "举",
    "楤": "耸",
    "朒": "女",
    "饅": "瞒",
    "麕": "君",
    "骯": "肮",
    "仭": "任",
    "飠": "石",
    "襜": "搀",
    "瑎": "鞋",
    "弬": "宜",
    "嵒": "颜",
    "聵": "溃",
    "蘤": "花",
    "奐": "换",
    "槢": "习",
    "飬": "倦",
    "蟣": "几",
    "鰧": "腾",
    "澏": "含",
    "礬": "烦",
    "抳": "你",
    "皃": "帽",
    "剗": "铲",
    "兠": "兜",
    "俤": "地",
    "嫗": "玉",
    "冁": "铲",
    "葒": "红",
    "凩": "木",
    "廮": "影",
    "莑": "朋",
    "緤": "谢",
    "晠": "胜",
    "噣": "昼",
    "銲": "汉",
    "喛": "换",
    "漷": "火",
    "碕": "其",
    "愙": "客",
    "萉": "费",
    "啇": "地",
    "挀": "掰",
    "戇": "壮",
    "殯": "宾",
    "篥": "利",
    "壌": "嚷",
    "鞪": "木",
    "觔": "金",
    "礐": "确",
    "糵": "聂",
    "犨": "抽",
    "噛": "聂",
    "闋": "确",
    "鳉": "将",
    "癵": "鸾",
    "愼": "肾",
    "萿": "扩",
    "猃": "显",
    "傃": "速",
    "矖": "洗",
    "珖": "光",
    "劋": "角",
    "鉲": "卡",
    "苃": "有",
    "狪": "同",
    "跔": "居",
    "眮": "同",
    "禆": "必",
    "硾": "缀",
    "枩": "松",
    "牳": "母",
    "籮": "罗",
    "疈": "屁",
    "鏐": "刘",
    "晿": "昌",
    "嘇": "山",
    "赽": "觉",
    "瑊": "间",
    "侒": "安",
    "轂": "古",
    "洔": "指",
    "璊": "门",
    "鹢": "意",
    "蓶": "维",
    "揜": "眼",
    "鈮": "你",
    "靷": "引",
    "脻": "接",
    "阨": "恶",
    "冾": "恰",
    "懡": "抹",
    "淲": "标",
    "砯": "平",
    "葻": "蓝",
    "滒": "歌",
    "砐": "恶",
    "疐": "至",
    "顰": "贫",
    "昅": "节",
    "鲗": "贼",
    "兟": "深",
    "獁": "骂",
    "艎": "黄",
    "瀺": "缠",
    "冘": "银",
    "勥": "降",
    "倠": "虽",
    "躞": "谢",
    "摐": "窗",
    "熇": "贺",
    "脴": "匹",
    "鈩": "芦",
    "蹯": "烦",
    "圡": "土",
    "飔": "思",
    "桟": "战",
    "籙": "路",
    "祴": "该",
    "鬬": "豆",
    "軏": "月",
    "嚤": "魔",
    "烋": "修",
    "玼": "此",
    "仠": "感",
    "焾": "年",
    "猂": "汉",
    "獦": "格",
    "綎": "听",
    "幏": "驾",
    "欉": "从",
    "豑": "至",
    "鹙": "秋",
    "衘": "闲",
    "彣": "文",
    "犜": "蹲",
    "攼": "干",
    "荗": "树",
    "緷": "运",
    "縳": "倦",
    "檁": "吝",
    "仾": "低",
    "飱": "孙",
    "畗": "达",
    "皔": "汉",
    "咈": "福",
    "藹": "矮",
    "笭": "零",
    "訏": "需",
    "殅": "生",
    "噭": "教",
    "媂": "地",
    "禕": "一",
    "偦": "许",
    "鴎": "欧",
    "硉": "路",
    "鼕": "东",
    "踡": "全",
    "哻": "憨",
    "櫙": "欧",
    "鱮": "续",
    "鎅": "借",
    "熯": "汉",
    "眥": "字",
    "騵": "原",
    "潒": "荡",
    "栟": "奔",
    "旉": "夫",
    "髣": "访",
    "叐": "拔",
    "彃": "必",
    "蓢": "浪",
    "劒": "见",
    "譪": "矮",
    "糼": "工",
    "跼": "局",
    "揦": "啦",
    "矼": "刚",
    "偖": "扯",
    "稌": "图",
    "萰": "练",
    "鐻": "巨",
    "鮡": "照",
    "麩": "夫",
    "漥": "挖",
    "汫": "井",
    "苲": "眨",
    "諎": "则",
    "飃": "飘",
    "疁": "刘",
    "魭": "原",
    "蕶": "零",
    "枲": "洗",
    "琱": "雕",
    "敊": "处",
    "枬": "占",
    "暕": "减",
    "呌": "教",
    "玜": "红",
    "狯": "快",
    "樛": "纠",
    "邅": "占",
    "矴": "定",
    "媎": "解",
    "儺": "挪",
    "湙": "意",
    "薲": "贫",
    "芔": "会",
    "錮": "固",
    "棓": "棒",
    "籪": "断",
    "珷": "五",
    "畄": "刘",
    "磳": "增",
    "媧": "挖",
    "翴": "连",
    "觫": "速",
    "茪": "光",
    "灄": "设",
    "瑬": "刘",
    "廇": "六",
    "訌": "红",
    "槱": "有",
    "紆": "迂",
    "兪": "鱼",
    "孋": "离",
    "櫆": "奎",
    "磾": "低",
    "諨": "福",
    "謔": "血",
    "檞": "解",
    "鴀": "否",
    "夿": "八",
    "爫": "找",
    "箑": "煞",
    "唂": "姑",
    "琈": "福",
    "沕": "密",
    "帊": "怕",
    "焺": "生",
    "糳": "做",
    "芞": "气",
    "鬶": "归",
    "聢": "定",
    "傖": "仓",
    "譔": "赚",
    "犦": "博",
    "淜": "平",
    "膤": "雪",
    "冡": "盟",
    "篴": "敌",
    "倎": "舔",
    "魷": "由",
    "壎": "熏",
    "搩": "眨",
    "衖": "向",
    "挵": "弄",
    "壼": "捆",
    "箄": "比",
    "輗": "尼",
    "楳": "梅",
    "慴": "设",
    "忺": "先",
    "勨": "向",
    "璝": "归",
    "桯": "听",
    "幨": "搀",
    "熦": "觉",
    "赩": "系",
    "芓": "字",
    "遖": "南",
    "镮": "环",
    "遝": "踏",
    "貲": "姿",
    "耞": "家",
    "媴": "原",
    "祋": "对",
    "嘪": "买",
    "鉈": "诗",
    "捄": "就",
    "拤": "恰",
    "慯": "伤",
    "氆": "普",
    "蠏": "谢",
    "鰐": "恶",
    "鄮": "帽",
    "汍": "完",
    "黪": "惨",
    "塂": "向",
    "棁": "捉",
    "贗": "燕",
    "毪": "木",
    "玱": "枪",
    "帨": "睡",
    "茻": "忙",
    "緜": "眠",
    "漃": "记",
    "蟗": "秋",
    "柹": "是",
    "啈": "哼",
    "鳓": "乐",
    "緍": "民",
    "狊": "局",
    "媯": "归",
    "瀅": "营",
    "硁": "坑",
    "徏": "至",
    "巶": "招",
    "犤": "排",
    "濙": "营",
    "謜": "原",
    "拸": "宜",
    "橲": "洗",
    "菍": "聂",
    "楿": "相",
    "潥": "速",
    "埈": "俊",
    "縟": "入",
    "嚬": "贫",
    "羢": "容",
    "槾": "慢",
    "胘": "闲",
    "詧": "茶",
    "袏": "做",
    "粂": "摘",
    "榑": "福",
    "岤": "学",
    "姷": "右",
    "筼": "云",
    "蟰": "消",
    "磥": "垒",
    "娭": "哀",
    "莾": "忙",
    "冐": "帽",
    "霅": "咋",
    "雊": "够",
    "犌": "家",
    "叞": "位",
    "臛": "或",
    "葄": "做",
    "芧": "续",
    "珇": "组",
    "氀": "驴",
    "嚑": "熏",
    "惎": "记",
    "梹": "彬",
    "杅": "鱼",
    "錧": "管",
    "镴": "蜡",
    "娞": "内",
    "餑": "波",
    "鋯": "告",
    "柇": "和",
    "髽": "抓",
    "癦": "么",
    "靭": "任",
    "斅": "笑",
    "瘎": "陈",
    "攺": "以",
    "箟": "俊",
    "嵿": "顶",
    "臫": "角",
    "昡": "炫",
    "坿": "父",
    "舙": "话",
    "勀": "客",
    "牚": "称",
    "潻": "鼠",
    "諍": "挣",
    "僥": "角",
    "臈": "蜡",
    "柲": "必",
    "罣": "挂",
    "瞛": "聪",
    "狓": "皮",
    "巗": "颜",
    "鹐": "前",
    "杣": "眠",
    "崲": "黄",
    "碙": "脑",
    "歔": "需",
    "蓏": "裸",
    "鋋": "缠",
    "桼": "七",
    "煭": "裂",
    "媻": "盘",
    "蕟": "发",
    "叅": "参",
    "瘃": "竹",
    "瑫": "掏",
    "絛": "掏",
    "伨": "训",
    "鰾": "标",
    "滮": "标",
    "廙": "意",
    "稾": "搞",
    "沴": "利",
    "哵": "八",
    "渄": "飞",
    "璄": "井",
    "鶉": "纯",
    "爩": "玉",
    "鱒": "尊",
    "漶": "换",
    "頬": "夹",
    "夣": "梦",
    "渰": "眼",
    "釔": "以",
    "跧": "全",
    "鱵": "真",
    "嵃": "眼",
    "泆": "意",
    "籦": "中",
    "頽": "推",
    "棊": "其",
    "昤": "零",
    "搯": "掏",
    "趑": "姿",
    "觽": "西",
    "皚": "埃",
    "顓": "专",
    "踦": "以",
    "歟": "鱼",
    "彮": "永",
    "挄": "扩",
    "鮻": "缩",
    "叀": "专",
    "叓": "是",
    "抯": "扎",
    "齪": "绰",
    "辧": "变",
    "偭": "免",
    "朳": "八",
    "砳": "乐",
    "鯢": "尼",
    "倂": "病",
    "煴": "晕",
    "絰": "叠",
    "纕": "嚷",
    "磻": "盘",
    "鵙": "局",
    "劯": "朱",
    "敻": "胸",
    "韞": "运",
    "欌": "藏",
    "猨": "原",
    "罉": "称",
    "徥": "是",
    "恊": "鞋",
    "裻": "毒",
    "讂": "炫",
    "彟": "约",
    "栺": "意",
    "棡": "刚",
    "暤": "号",
    "俓": "静",
    "搤": "恶",
    "焅": "裤",
    "狶": "西",
    "虡": "巨",
    "箖": "林",
    "焪": "穷",
    "茘": "利",
    "璸": "彬",
    "儩": "四",
    "撝": "灰",
    "輌": "亮",
    "畺": "将",
    "礮": "炮",
    "痜": "突",
    "犫": "抽",
    "鳀": "提",
    "皠": "脆",
    "妜": "月",
    "笯": "努",
    "玃": "觉",
    "莃": "西",
    "熤": "意",
    "腄": "垂",
    "婨": "伦",
    "桮": "杯",
    "铴": "汤",
    "泙": "平",
    "瑥": "温",
    "箂": "来",
    "鰹": "间",
    "矰": "增",
    "竚": "助",
    "楴": "替",
    "祍": "任",
    "磗": "专",
    "塀": "平",
    "駉": "窘",
    "帺": "其",
    "鞕": "硬",
    "扟": "深",
    "哬": "和",
    "苿": "位",
    "鵡": "五",
    "簙": "博",
    "錆": "枪",
    "珆": "宜",
    "縌": "逆",
    "饦": "拖",
    "矝": "金",
    "眖": "矿",
    "臒": "卧",
    "烇": "犬",
    "磧": "气",
    "鉽": "是",
    "莗": "车",
    "聜": "底",
    "蹆": "腿",
    "嵈": "换",
    "丩": "纠",
    "癶": "波",
    "鱘": "寻",
    "甀": "缀",
    "掿": "诺",
    "滶": "敖",
    "禠": "思",
    "鳧": "福",
    "鯥": "路",
    "迊": "匝",
    "嘂": "教",
    "璪": "早",
    "昩": "墨",
    "徤": "见",
    "瀲": "练",
    "咉": "养",
    "昷": "温",
    "唫": "进",
    "鴖": "民",
    "粻": "张",
    "驀": "墨",
    "栠": "忍",
    "靿": "要",
    "癆": "劳",
    "庘": "呀",
    "簞": "单",
    "舺": "侠",
    "宨": "挑",
    "礒": "以",
    "瑑": "赚",
    "怳": "谎",
    "謏": "小",
    "郈": "后",
    "湢": "必",
    "鱥": "贵",
    "琖": "展",
    "蒟": "举",
    "皸": "君",
    "蕯": "龙",
    "峈": "落",
    "眒": "深",
    "顳": "聂",
    "蒳": "那",
    "耂": "老",
    "瘭": "标",
    "盬": "古",
    "旙": "翻",
    "蕚": "恶",
    "惷": "春",
    "啨": "应",
    "輅": "和",
    "腽": "袜",
    "嫮": "互",
    "鮈": "居",
    "諲": "因",
    "瑂": "梅",
    "僎": "赚",
    "搊": "抽",
    "蝢": "鞋",
    "醱": "发",
    "蓸": "曹",
    "埥": "青",
    "聧": "亏",
    "絟": "全",
    "苅": "意",
    "濳": "钱",
    "凅": "固",
    "眆": "访",
    "喠": "种",
    "桋": "宜",
    "頩": "平",
    "盩": "周",
    "槨": "果",
    "薾": "耳",
    "嶒": "层",
    "憀": "聊",
    "鮸": "免",
    "灤": "鸾",
    "険": "显",
    "塈": "记",
    "聸": "单",
    "豭": "家",
    "笲": "烦",
    "鞦": "秋",
    "抦": "饼",
    "枏": "南",
    "縒": "刺",
    "峮": "群",
    "淟": "舔",
    "嵜": "其",
    "魋": "推",
    "懗": "下",
    "蠵": "西",
    "糶": "跳",
    "吂": "忙",
    "蔠": "中",
    "酺": "葡",
    "襚": "岁",
    "腂": "垒",
    "碿": "速",
    "鍬": "敲",
    "讌": "燕",
    "霤": "六",
    "籵": "烦",
    "溵": "因",
    "鉓": "赤",
    "韾": "因",
    "煵": "男",
    "塟": "藏",
    "楩": "偏",
    "髏": "楼",
    "誑": "狂",
    "粃": "比",
    "嵚": "亲",
    "聅": "撤",
    "梛": "挪",
    "犿": "欢",
    "羘": "脏",
    "坒": "必",
    "鹯": "占",
    "旴": "需",
    "陧": "聂",
    "彺": "王",
    "聫": "连",
    "偨": "刺",
    "娢": "含",
    "簻": "抓",
    "泒": "姑",
    "蕫": "懂",
    "昸": "东",
    "楡": "鱼",
    "詨": "笑",
    "鳡": "感",
    "饉": "紧",
    "籨": "连",
    "靸": "洒",
    "渱": "红",
    "鼌": "朝",
    "癴": "鸾",
    "摥": "烫",
    "鼆": "盟",
    "淥": "路",
    "癭": "影",
    "袝": "父",
    "椇": "举",
    "頦": "孩",
    "佱": "法",
    "鶄": "精",
    "岠": "巨",
    "袿": "归",
    "痁": "山",
    "羠": "宜",
    "馹": "日",
    "摼": "坑",
    "泹": "蛋",
    "鍶": "松",
    "苙": "利",
    "懓": "爱",
    "摝": "路",
    "痶": "舔",
    "醗": "破",
    "乥": "互",
    "鉷": "红",
    "慒": "从",
    "趌": "极",
    "喨": "亮",
    "鐠": "普",
    "懌": "意",
    "錱": "真",
    "佪": "回",
    "磦": "标",
    "溙": "太",
    "苨": "你",
    "蚖": "原",
    "銦": "因",
    "驁": "奥",
    "詒": "宜",
    "鳤": "管",
    "爊": "凹",
    "妱": "招",
    "佫": "贺",
    "鱤": "感",
    "琡": "处",
    "牓": "绑",
    "礱": "龙",
    "淈": "古",
    "榚": "咬",
    "仱": "钱",
    "蕝": "觉",
    "熈": "西",
    "憟": "速",
    "漰": "砰",
    "狟": "环",
    "沘": "比",
    "捫": "门",
    "珦": "向",
    "暊": "许",
    "玶": "平",
    "壡": "瑞",
    "渢": "烦",
    "毱": "局",
    "睲": "醒",
    "翵": "喉",
    "汋": "着",
    "誃": "宜",
    "緇": "姿",
    "靁": "雷",
    "狺": "银",
    "篶": "烟",
    "岒": "钱",
    "橷": "兜",
    "巂": "归",
    "啩": "挂",
    "椗": "定",
    "甽": "镇",
    "啅": "着",
    "鯪": "零",
    "瞼": "减",
    "泝": "速",
    "躱": "朵",
    "鄃": "书",
    "鴦": "养",
    "釨": "子",
    "豽": "那",
    "秝": "利",
    "湼": "聂",
    "砃": "单",
    "鬾": "记",
    "醖": "运",
    "醂": "懒",
    "鬂": "宾",
    "汯": "红",
    "筽": "欧",
    "璦": "爱",
    "儫": "豪",
    "灊": "钱",
    "紉": "任",
    "薌": "相",
    "碂": "宗",
    "誔": "挺",
    "瞏": "穷",
    "堨": "夜",
    "翬": "灰",
    "侭": "紧",
    "膁": "浅",
    "螞": "马",
    "娕": "绰",
    "崈": "虫",
    "荢": "字",
    "頠": "伟",
    "悮": "物",
    "禖": "梅",
    "坔": "地",
    "箛": "姑",
    "鷂": "要",
    "蓜": "配",
    "熋": "奶",
    "鏷": "葡",
    "趪": "黄",
    "晈": "角",
    "詆": "底",
    "筶": "告",
    "蚳": "持",
    "絯": "该",
    "粐": "互",
    "莄": "梗",
    "圂": "混",
    "瓖": "相",
    "蓱": "平",
    "昦": "号",
    "皷": "古",
    "橚": "速",
    "澦": "玉",
    "峃": "学",
    "侎": "米",
    "摖": "气",
    "痡": "夫",
    "敁": "颠",
    "勼": "纠",
    "靺": "墨",
    "洉": "后",
    "窎": "掉",
    "屰": "逆",
    "鑭": "烂",
    "磵": "见",
    "舠": "刀",
    "晼": "碗",
    "秬": "巨",
    "雚": "灌",
    "忬": "玉",
    "鋹": "场",
    "瑏": "穿",
    "牷": "全",
    "瓻": "吃",
    "笻": "穷",
    "饍": "善",
    "绤": "系",
    "燶": "农",
    "咇": "别",
    "牥": "方",
    "雬": "否",
    "閶": "昌",
    "蚃": "想",
    "緫": "聪",
    "聤": "停",
    "魢": "几",
    "堼": "哼",
    "婔": "飞",
    "昬": "昏",
    "窋": "竹",
    "璚": "穷",
    "爞": "虫",
    "輮": "柔",
    "竵": "歪",
    "畇": "云",
    "鑨": "龙",
    "瓕": "迷",
    "敋": "格",
    "鮴": "修",
    "帉": "分",
    "刓": "完",
    "祻": "固",
    "倱": "混",
    "攋": "蜡",
    "鄲": "单",
    "閂": "拴",
    "鋌": "定",
    "垍": "记",
    "婖": "天",
    "髃": "鱼",
    "洈": "维",
    "裧": "搀",
    "羇": "机",
    "槩": "概",
    "銠": "老",
    "蓹": "玉",
    "蹱": "中",
    "嘓": "锅",
    "蔕": "地",
    "膉": "意",
    "耎": "软",
    "勔": "免",
    "彍": "锅",
    "逰": "由",
    "膟": "绿",
    "帢": "恰",
    "厺": "去",
    "賾": "则",
    "緭": "位",
    "鮪": "伟",
    "犧": "西",
    "寽": "绿",
    "鋃": "狼",
    "俰": "或",
    "尃": "夫",
    "繽": "彬",
    "囀": "赚",
    "蘡": "应",
    "瀦": "朱",
    "芖": "至",
    "卨": "谢",
    "諄": "准",
    "嫢": "归",
    "罃": "应",
    "眘": "肾",
    "琝": "民",
    "貭": "至",
    "緼": "运",
    "跕": "点",
    "厔": "至",
    "閦": "处",
    "磪": "催",
    "懞": "盟",
    "媢": "帽",
    "陏": "堕",
    "墐": "进",
    "鵼": "空",
    "乊": "一",
    "醲": "农",
    "侐": "续",
    "椻": "燕",
    "籫": "钻",
    "柛": "深",
    "潎": "屁",
    "闚": "亏",
    "箎": "持",
    "鎛": "博",
    "爧": "零",
    "歭": "持",
    "梿": "连",
    "祲": "进",
    "蕜": "匪",
    "嶌": "导",
    "尫": "汪",
    "貚": "谈",
    "敯": "敏",
    "彞": "宜",
    "檷": "你",
    "愴": "创",
    "盫": "安",
    "搒": "棒",
    "稰": "许",
    "絤": "现",
    "灡": "蓝",
    "厵": "原",
    "璲": "岁",
    "琜": "来",
    "蒅": "染",
    "玞": "夫",
    "伮": "努",
    "巃": "龙",
    "绹": "桃",
    "嵶": "弱",
    "焽": "胸",
    "眽": "墨",
    "徫": "伟",
    "羬": "钱",
    "眡": "是",
    "莿": "次",
    "蠄": "琴",
    "徝": "至",
    "靨": "夜",
    "竂": "聊",
    "摎": "纠",
    "騲": "草",
    "苂": "银",
    "宻": "密",
    "瓁": "卧",
    "尟": "显",
    "麨": "吵",
    "炏": "开",
    "墭": "胜",
    "骻": "跨",
    "褩": "班",
    "蓴": "纯",
    "軾": "是",
    "敶": "镇",
    "觿": "西",
    "騾": "罗",
    "紾": "枕",
    "鑠": "硕",
    "淐": "昌",
    "稊": "提",
    "隤": "推",
    "茞": "陈",
    "搫": "盘",
    "妑": "趴",
    "皘": "欠",
    "咊": "和",
    "椚": "们",
    "楆": "邀",
    "棯": "忍",
    "阾": "领",
    "叝": "极",
    "槫": "团",
    "鮄": "福",
    "怑": "办",
    "廵": "寻",
    "垈": "带",
    "嫍": "掏",
    "晄": "谎",
    "碦": "客",
    "巼": "八",
    "梲": "着",
    "犖": "落",
    "僤": "蛋",
    "颰": "拔",
    "懃": "琴",
    "獊": "仓",
    "椥": "知",
    "蛧": "网",
    "臞": "取",
    "醠": "盎",
    "忳": "吞",
    "灥": "寻",
    "臝": "裸",
    "礂": "西",
    "塰": "海",
    "瓥": "利",
    "硋": "爱",
    "沋": "由",
    "繒": "增",
    "鴴": "横",
    "餭": "黄",
    "齬": "雨",
    "抆": "稳",
    "酙": "真",
    "鼒": "姿",
    "啴": "铲",
    "瑡": "诗",
    "捀": "逢",
    "獚": "黄",
    "聣": "尼",
    "碪": "真",
    "鷃": "燕",
    "媐": "宜",
    "棝": "固",
    "鋦": "居",
    "喩": "玉",
    "鋶": "柳",
    "汘": "前",
    "冣": "巨",
    "皌": "墨",
    "閸": "捆",
    "佡": "先",
    "踎": "谋",
    "挰": "成",
    "吤": "借",
    "勦": "超",
    "庿": "庙",
    "掫": "周",
    "侕": "而",
    "椄": "接",
    "昞": "饼",
    "掄": "伦",
    "誩": "静",
    "鰆": "春",
    "剘": "其",
    "脵": "古",
    "畷": "缀",
    "訐": "节",
    "賒": "舍",
    "鑖": "灭",
    "嚵": "缠",
    "嫼": "墨",
    "硤": "侠",
    "鉮": "环",
    "惻": "册",
    "鰥": "关",
    "媔": "眠",
    "磑": "维",
    "虀": "机",
    "湝": "接",
    "豿": "狗",
    "垺": "夫",
    "疪": "必",
    "麁": "粗",
    "詘": "区",
    "硔": "红",
    "捗": "不",
    "絋": "矿",
    "埢": "全",
    "鰰": "神",
    "韤": "袜",
    "襾": "亚",
    "嚛": "互",
    "櫘": "会",
    "薍": "万",
    "碽": "工",
    "杕": "地",
    "鶡": "和",
    "獶": "脑",
    "歜": "处",
    "尗": "书",
    "餞": "见",
    "矙": "看",
    "椓": "着",
    "飮": "引",
    "渿": "耐",
    "憯": "惨",
    "橃": "罚",
    "訽": "够",
    "涭": "瘦",
    "慆": "掏",
    "吪": "额",
    "飡": "参",
    "詺": "命",
    "闓": "凯",
    "騃": "埃",
    "鯀": "滚",
    "禴": "月",
    "祾": "零",
    "滎": "行",
    "衜": "到",
    "謄": "腾",
    "衭": "夫",
    "牁": "科",
    "鰋": "眼",
    "轤": "芦",
    "抐": "呢",
    "筻": "杠",
    "芛": "伟",
    "惒": "和",
    "礲": "龙",
    "篈": "风",
    "蠧": "度",
    "撦": "扯",
    "慭": "印",
    "曓": "报",
    "丱": "灌",
    "疢": "衬",
    "萚": "拓",
    "棭": "意",
    "奿": "饭",
    "膇": "缀",
    "閧": "红",
    "袠": "至",
    "糤": "三",
    "鰣": "石",
    "蓇": "古",
    "玤": "棒",
    "恴": "德",
    "駸": "亲",
    "傫": "垒",
    "姄": "民",
    "匱": "贵",
    "辷": "一",
    "滸": "虎",
    "瑵": "找",
    "蒝": "原",
    "錸": "来",
    "僸": "进",
    "涷": "东",
    "鋽": "掉",
    "掯": "肯",
    "霝": "零",
    "熜": "聪",
    "眜": "墨",
    "弅": "愤",
    "蜼": "位",
    "焑": "烟",
    "濪": "庆",
    "鐦": "开",
    "鳛": "习",
    "崰": "姿",
    "硺": "着",
    "怣": "由",
    "藟": "垒",
    "緿": "带",
    "髕": "宾",
    "畓": "多",
    "蹏": "提",
    "壻": "续",
    "叺": "尺",
    "朸": "利",
    "毑": "解",
    "糉": "宗",
    "襴": "蓝",
    "鉎": "生",
    "筸": "干",
    "捔": "觉",
    "玴": "意",
    "繾": "浅",
    "藦": "墨",
    "麃": "袍",
    "尌": "树",
    "姺": "深",
    "匨": "脏",
    "殰": "毒",
    "踈": "书",
    "廞": "心",
    "鐎": "教",
    "縲": "雷",
    "紨": "夫",
    "訧": "由",
    "烕": "灭",
    "朚": "荒",
    "虖": "呼",
    "崼": "是",
    "淴": "呼",
    "琷": "确",
    "嚱": "系",
    "齾": "亚",
    "栔": "气",
    "罇": "尊",
    "籿": "寸",
    "淍": "周",
    "亯": "想",
    "靉": "爱",
    "鄩": "寻",
    "謆": "善",
    "旐": "照",
    "纆": "墨",
    "牞": "纠",
    "扵": "鱼",
    "颕": "影",
    "僩": "现",
    "彽": "低",
    "銝": "修",
    "枿": "聂",
    "傎": "颠",
    "蹽": "了",
    "怺": "永",
    "湞": "真",
    "啺": "唐",
    "迏": "达",
    "絁": "诗",
    "痗": "妹",
    "槤": "连",
    "瑃": "春",
    "熝": "路",
    "崿": "恶",
    "穡": "色",
    "韂": "颤",
    "宭": "群",
    "嘥": "塞",
    "煣": "柔",
    "忈": "人",
    "蝂": "板",
    "鳋": "骚",
    "玸": "福",
    "狔": "你",
    "灴": "轰",
    "祒": "条",
    "崒": "族",
    "胐": "匪",
    "蜎": "冤",
    "儙": "欠",
    "爔": "西",
    "鉥": "树",
    "澊": "村",
    "甿": "盟",
    "銶": "求",
    "砽": "用",
    "鋂": "梅",
    "騖": "物",
    "柀": "比",
    "櫸": "举",
    "騶": "邹",
    "耭": "机",
    "韺": "应",
    "糱": "聂",
    "鴵": "消",
    "渘": "柔",
    "蔾": "离",
    "嬁": "灯",
    "酳": "印",
    "摜": "灌",
    "齛": "谢",
    "聭": "溃",
    "猧": "窝",
    "髠": "昆",
    "齙": "包",
    "盝": "路",
    "笗": "东",
    "鵾": "昆",
    "堁": "客",
    "啿": "蛋",
    "猺": "摇",
    "穕": "妾",
    "娝": "剖",
    "詊": "判",
    "旲": "台",
    "榶": "唐",
    "洤": "全",
    "袔": "贺",
    "丒": "丑",
    "摃": "康",
    "簱": "其",
    "昢": "破",
    "柎": "夫",
    "磆": "华",
    "塡": "田",
    "峎": "恩",
    "毚": "缠",
    "粎": "米",
    "囼": "胎",
    "洦": "破",
    "篯": "间",
    "桝": "节",
    "螀": "将",
    "镸": "长",
    "袗": "枕",
    "幰": "显",
    "爓": "燕",
    "餗": "速",
    "繶": "意",
    "彚": "会",
    "聠": "平",
    "鷟": "着",
    "齎": "机",
    "鱯": "互",
    "魙": "占",
    "螝": "归",
    "橕": "称",
    "鏠": "风",
    "伡": "车",
    "漚": "欧",
    "徰": "睁",
    "灷": "赚",
    "媮": "偷",
    "浰": "练",
    "幃": "维",
    "蝜": "父",
    "菼": "坦",
    "蜺": "尼",
    "掦": "替",
    "糭": "宗",
    "伷": "昼",
    "鱇": "康",
    "膥": "村",
    "亐": "鱼",
    "弖": "互",
    "胊": "取",
    "歾": "墨",
    "篔": "云",
    "鴆": "镇",
    "羫": "枪",
    "吷": "血",
    "玬": "胆",
    "埑": "哲",
    "衒": "炫",
    "橴": "子",
    "獓": "敖",
    "妚": "否",
    "篢": "垄",
    "迵": "动",
    "穐": "秋",
    "裠": "群",
    "摵": "设",
    "鄦": "许",
    "寯": "俊",
    "檵": "记",
    "騄": "路",
    "澫": "万",
    "哫": "族",
    "鹡": "极",
    "墤": "快",
    "黖": "系",
    "楇": "或",
    "諛": "鱼",
    "薉": "会",
    "黫": "烟",
    "迍": "准",
    "曏": "想",
    "耏": "耐",
    "玔": "串",
    "僂": "楼",
    "鸧": "仓",
    "剸": "团",
    "跅": "拓",
    "頎": "其",
    "琣": "崩",
    "礵": "双",
    "珚": "烟",
    "頊": "需",
    "汈": "雕",
    "笴": "感",
    "嫬": "遮",
    "僿": "赛",
    "柆": "拉",
    "蔳": "欠",
    "刅": "窗",
    "骎": "亲",
    "鸜": "取",
    "嬧": "进",
    "颿": "翻",
    "訞": "邀",
    "纚": "离",
    "綳": "崩",
    "鬒": "枕",
    "繷": "农",
    "抂": "狂",
    "凢": "烦",
    "覔": "密",
    "砏": "彬",
    "頖": "判",
    "穈": "梅",
    "詷": "同",
    "頲": "挺",
    "磱": "劳",
    "顙": "桑",
    "辡": "变",
    "蕇": "点",
    "戱": "系",
    "黽": "免",
    "蠣": "利",
    "暙": "春",
    "刦": "节",
    "犛": "毛",
    "鶩": "物",
    "朌": "坟",
    "椮": "森",
    "鰽": "求",
    "忲": "太",
    "誋": "记",
    "嫊": "速",
    "稭": "接",
    "漻": "聊",
    "餂": "舔",
    "僡": "会",
    "甧": "深",
    "猠": "点",
    "鬛": "裂",
    "緡": "民",
    "觩": "求",
    "晆": "奎",
    "盽": "风",
    "髆": "博",
    "桒": "丧",
    "藼": "宣",
    "闞": "看",
    "瑴": "觉",
    "豖": "处",
    "絅": "窘",
    "緦": "思",
    "鵽": "堕",
    "譴": "浅",
    "齲": "曲",
    "湌": "参",
    "缞": "催",
    "晬": "最",
    "筨": "含",
    "痟": "消",
    "蓨": "条",
    "珶": "地",
    "玐": "八",
    "囶": "国",
    "秗": "玉",
    "櫹": "消",
    "硊": "伟",
    "箒": "肘",
    "撯": "着",
    "瑇": "带",
    "媟": "谢",
    "忼": "康",
    "汼": "牛",
    "奺": "久",
    "罌": "应",
    "謳": "欧",
    "橿": "将",
    "伇": "意",
    "頣": "审",
    "萮": "鱼",
    "蘄": "其",
    "竕": "分",
    "跱": "至",
    "夑": "谢",
    "杦": "久",
    "駑": "努",
    "薡": "顶",
    "洴": "平",
    "僷": "夜",
    "煍": "角",
    "抝": "袄",
    "媣": "染",
    "媼": "袄",
    "麐": "林",
    "羗": "枪",
    "橆": "五",
    "柍": "养",
    "煈": "奉",
    "厊": "哑",
    "昚": "肾",
    "虂": "路",
    "礠": "瓷",
    "粷": "局",
    "鬰": "玉",
    "痏": "伟",
    "鈰": "是",
    "穽": "井",
    "蝖": "宣",
    "詌": "干",
    "鐍": "觉",
    "韙": "伟",
    "薱": "对",
    "侻": "退",
    "狤": "极",
    "帤": "如",
    "殫": "单",
    "璏": "位",
    "惄": "逆",
    "鼫": "石",
    "惁": "西",
    "衯": "分",
    "瞴": "谋",
    "藯": "位",
    "荁": "环",
    "嗇": "色",
    "砠": "居",
    "捒": "树",
    "魖": "需",
    "篐": "姑",
    "銛": "先",
    "瞉": "扣",
    "髳": "毛",
    "珼": "被",
    "呠": "喷",
    "楧": "养",
    "碻": "确",
    "碠": "定",
    "雝": "庸",
    "眿": "墨",
    "厹": "柔",
    "覡": "习",
    "皜": "号",
    "篗": "月",
    "汮": "君",
    "猔": "宗",
    "膅": "唐",
    "啙": "子",
    "儥": "玉",
    "饈": "修",
    "侱": "成",
    "窵": "掉",
    "哷": "裂",
    "宧": "宜",
    "鯒": "永",
    "莇": "助",
    "胾": "字",
    "錩": "昌",
    "詝": "主",
    "髢": "敌",
    "罫": "挂",
    "騔": "格",
    "磝": "敖",
    "侼": "博",
    "猘": "至",
    "迯": "桃",
    "漙": "团",
    "灩": "燕",
    "囈": "意",
    "峳": "由",
    "汵": "干",
    "綈": "提",
    "鉂": "使",
    "膆": "速",
    "肨": "胖",
    "衧": "鱼",
    "綟": "利",
    "伣": "欠",
    "臜": "匝",
    "厑": "牙",
    "窡": "着",
    "紁": "差",
    "玝": "五",
    "灦": "显",
    "啚": "比",
    "獂": "原",
    "磀": "额",
    "檨": "舍",
    "濘": "宁",
    "歨": "不",
    "埻": "准",
    "夻": "话",
    "碭": "荡",
    "簤": "带",
    "烼": "续",
    "棏": "德",
    "柂": "宜",
    "睠": "倦",
    "齷": "卧",
    "刵": "二",
    "屜": "替",
    "霗": "零",
    "鮟": "按",
    "畩": "一",
    "檪": "利",
    "鋏": "夹",
    "妀": "几",
    "僜": "称",
    "橪": "染",
    "蛶": "借",
    "虰": "丁",
    "漴": "壮",
    "嬑": "意",
    "嫕": "意",
    "蔎": "设",
    "矻": "哭",
    "觮": "路",
    "哴": "亮",
    "灒": "赞",
    "挕": "叠",
    "傁": "搜",
    "棃": "离",
    "砡": "玉",
    "栒": "寻",
    "枺": "墨",
    "恛": "回",
    "鴕": "驮",
    "琄": "炫",
    "晊": "至",
    "琟": "维",
    "灮": "光",
    "訸": "和",
    "捴": "总",
    "簥": "教",
    "嵕": "宗",
    "寗": "凝",
    "戨": "歌",
    "衠": "准",
    "暆": "宜",
    "諤": "恶",
    "愐": "免",
    "筃": "因",
    "塋": "营",
    "潧": "真",
    "朞": "机",
    "騳": "毒",
    "桸": "西",
    "醙": "搜",
    "眤": "逆",
    "睟": "岁",
    "篘": "抽",
    "闐": "田",
    "漼": "脆",
    "侰": "窘",
    "仦": "吵",
    "魡": "掉",
    "荍": "桥",
    "呇": "起",
    "肧": "培",
    "捝": "拖",
    "鰤": "诗",
    "譌": "额",
    "偩": "父",
    "檰": "眠",
    "鴂": "觉",
    "棴": "福",
    "鍱": "夜",
    "岨": "区",
    "焫": "弱",
    "垉": "袍",
    "蠆": "拆",
    "輈": "周",
    "梂": "求",
    "俽": "心",
    "郳": "尼",
    "鈑": "板",
    "虁": "奎",
    "儈": "快",
    "諂": "铲",
    "詛": "组",
    "鑁": "宗",
    "衵": "意",
    "淛": "这",
    "阸": "恶",
    "昮": "宗",
    "掁": "成",
    "鉿": "家",
    "瓫": "盆",
    "徎": "成",
    "郉": "行",
    "飂": "六",
    "卆": "族",
    "萹": "扁",
    "凐": "因",
    "峸": "成",
    "虵": "蛇",
    "綣": "犬",
    "扢": "古",
    "詖": "必",
    "豗": "灰",
    "韝": "勾",
    "藋": "掉",
    "樆": "离",
    "闗": "关",
    "瓃": "雷",
    "脁": "挑",
    "瘞": "意",
    "蟟": "聊",
    "嚚": "银",
    "膌": "极",
    "糴": "敌",
    "燨": "西",
    "鵷": "冤",
    "遧": "张",
    "衐": "取",
    "杗": "忙",
    "崳": "鱼",
    "愒": "开",
    "篛": "弱",
    "杍": "子",
    "欅": "举",
    "鷁": "意",
    "圑": "普",
    "闥": "踏",
    "猻": "孙",
    "繦": "抢",
    "鵐": "无",
    "頳": "称",
    "悈": "借",
    "謑": "洗",
    "愢": "塞",
    "旵": "铲",
    "瘍": "羊",
    "梺": "下",
    "顠": "漂",
    "眃": "云",
    "榣": "摇",
    "炛": "光",
    "厸": "林",
    "坋": "笨",
    "挏": "动",
    "斶": "处",
    "榐": "展",
    "墣": "葡",
    "椈": "局",
    "坴": "路",
    "郚": "无",
    "黿": "原",
    "圥": "路",
    "纗": "嘴",
    "秮": "活",
    "畍": "借",
    "噧": "谢",
    "攃": "擦",
    "雘": "卧",
    "揳": "些",
    "竉": "垄",
    "胻": "横",
    "悑": "不",
    "甹": "平",
    "跓": "助",
    "餒": "内",
    "繐": "岁",
    "珸": "无",
    "楟": "停",
    "栯": "有",
    "槖": "驮",
    "麷": "风",
    "灕": "离",
    "酓": "眼",
    "鰌": "秋",
    "胵": "吃",
    "莝": "错",
    "蝿": "营",
    "熰": "欧",
    "藳": "搞",
    "縗": "催",
    "鞄": "袍",
    "喞": "机",
    "攨": "挖",
    "昹": "矮",
    "殏": "求",
    "瓂": "概",
    "睖": "愣",
    "醆": "展",
    "傆": "院",
    "臏": "宾",
    "簈": "平",
    "凘": "思",
    "膙": "讲",
    "犆": "直",
    "澼": "屁",
    "舋": "信",
    "紤": "久",
    "舝": "侠",
    "鎲": "躺",
    "慅": "骚",
    "綶": "果",
    "鉦": "睁",
    "彄": "口",
    "羉": "鸾",
    "葀": "扩",
    "殗": "夜",
    "聬": "瓮",
    "儃": "缠",
    "埞": "低",
    "豘": "吞",
    "镵": "缠",
    "煆": "虾",
    "箮": "宣",
    "趆": "低",
    "暰": "聪",
    "浻": "窘",
    "繯": "环",
    "甂": "编",
    "攧": "颠",
    "髇": "消",
    "筰": "做",
    "廹": "拍",
    "箥": "跛",
    "鵩": "福",
    "揈": "轰",
    "懠": "其",
    "凣": "烦",
    "睸": "妹",
    "袥": "拖",
    "輙": "哲",
    "蒛": "缺",
    "梘": "减",
    "桵": "瑞",
    "玣": "变",
    "乲": "姿",
    "鵁": "教",
    "蚫": "报",
    "觶": "至",
    "璮": "坦",
    "竼": "朋",
    "哹": "福",
    "禣": "父",
    "梄": "有",
    "鮒": "父",
    "孻": "奶",
    "賂": "路",
    "篰": "不",
    "嶰": "谢",
    "緉": "两",
    "糒": "被",
    "褻": "谢",
    "阓": "会",
    "飜": "翻",
    "痌": "通",
    "朘": "嘴",
    "慲": "瞒",
    "溰": "埃",
    "琑": "锁",
    "眣": "叠",
    "隩": "奥",
    "滭": "必",
    "皧": "爱",
    "淿": "博",
    "阰": "皮",
    "逈": "窘",
    "乷": "沙",
    "噈": "促",
    "毶": "三",
    "岦": "利",
    "哸": "虽",
    "砱": "零",
    "塜": "种",
    "喐": "玉",
    "揔": "总",
    "汃": "彬",
    "夗": "院",
    "膴": "呼",
    "傋": "讲",
    "鍅": "法",
    "侴": "丑",
    "庈": "琴",
    "秱": "同",
    "鬋": "减",
    "捁": "角",
    "槮": "森",
    "蝋": "蜡",
    "鞶": "盘",
    "慿": "平",
    "竛": "零",
    "芢": "人",
    "屧": "谢",
    "袚": "波",
    "嬀": "归",
    "璓": "秀",
    "塼": "专",
    "聥": "举",
    "韆": "前",
    "崬": "东",
    "旑": "以",
    "敨": "偷",
    "狦": "山",
    "癎": "闲",
    "蒵": "习",
    "罓": "刚",
    "琫": "崩",
    "軿": "平",
    "鱠": "快",
    "傌": "骂",
    "繝": "见",
    "蛁": "雕",
    "嬞": "懂",
    "姶": "恶",
    "諉": "伟",
    "蝀": "东",
    "膍": "皮",
    "葅": "租",
    "圫": "玉",
    "斠": "教",
    "礋": "则",
    "煑": "主",
    "厫": "敖",
    "耇": "狗",
    "攱": "鬼",
    "螄": "思",
    "箷": "宜",
    "靹": "那",
    "樌": "灌",
    "蒫": "搓",
    "縀": "侠",
    "顚": "颠",
    "颸": "思",
    "囌": "苏",
    "磈": "伟",
    "墲": "木",
    "妟": "燕",
    "蘹": "怀",
    "熿": "黄",
    "垽": "印",
    "孌": "鸾",
    "椯": "朵",
    "詂": "父",
    "猌": "印",
    "捖": "完",
    "尭": "摇",
    "亗": "岁",
    "虳": "觉",
    "玪": "间",
    "簓": "雕",
    "珜": "羊",
    "偮": "极",
    "嬝": "尿",
    "鐹": "果",
    "湦": "生",
    "釤": "善",
    "蚑": "其",
    "鈼": "做",
    "浂": "意",
    "冓": "够",
    "暃": "飞",
    "旟": "鱼",
    "桽": "稳",
    "鶲": "瓮",
    "欋": "取",
    "秡": "博",
    "懍": "吝",
    "卭": "穷",
    "餠": "饼",
    "弨": "超",
    "佖": "必",
    "柭": "八",
    "堓": "按",
    "拻": "灰",
    "鏹": "抢",
    "漄": "牙",
    "恌": "挑",
    "詏": "要",
    "躹": "局",
    "麀": "优",
    "禒": "显",
    "磓": "堆",
    "鬿": "其",
    "瀸": "间",
    "鹲": "盟",
    "崶": "风",
    "鐽": "达",
    "酫": "绰",
    "蹔": "赞",
    "碸": "风",
    "玌": "求",
    "鞡": "拉",
    "喿": "造",
    "揰": "冲",
    "詶": "昼",
    "凴": "平",
    "脺": "翠",
    "縭": "离",
    "絚": "耕",
    "猯": "团",
    "蹣": "盘",
    "趍": "持",
    "暲": "张",
    "瘓": "换",
    "靘": "庆",
    "昍": "宣",
    "淶": "来",
    "奵": "顶",
    "誏": "浪",
    "牂": "脏",
    "檮": "桃",
    "柶": "四",
    "欦": "前",
    "耹": "琴",
    "嵓": "颜",
    "擸": "裂",
    "塳": "朋",
    "晍": "同",
    "鋗": "宣",
    "茢": "裂",
    "蔂": "雷",
    "矪": "周",
    "瞱": "夜",
    "攙": "搀",
    "迠": "撤",
    "嫏": "狼",
    "摋": "萨",
    "葴": "真",
    "誄": "垒",
    "鳽": "间",
    "梒": "含",
    "穄": "记",
    "嵖": "茶",
    "闬": "汉",
    "梔": "知",
    "逌": "优",
    "醩": "糟",
    "騭": "至",
    "徖": "从",
    "蘻": "记",
    "硸": "虐",
    "灆": "蓝",
    "筪": "侠",
    "窇": "薄",
    "欗": "蓝",
    "桹": "狼",
    "饐": "意",
    "皾": "毒",
    "塯": "六",
    "緛": "软",
    "媭": "需",
    "琧": "恶",
    "鯵": "深",
    "墏": "抢",
    "髤": "修",
    "龎": "旁",
    "禟": "唐",
    "溈": "维",
    "栐": "永",
    "挋": "镇",
    "巵": "知",
    "膶": "润",
    "譮": "话",
    "簔": "缩",
    "倲": "东",
    "焞": "吞",
    "婑": "瑞",
    "嗹": "连",
    "樒": "密",
    "橑": "老",
    "攠": "迷",
    "鴠": "蛋",
    "荶": "银",
    "丯": "借",
    "孨": "转",
    "蘶": "位",
    "鴣": "姑",
    "玿": "勺",
    "宷": "审",
    "鼢": "坟",
    "剠": "情",
    "婤": "抽",
    "藎": "进",
    "隃": "树",
    "貏": "比",
    "麞": "张",
    "襝": "脸",
    "輖": "周",
    "旍": "精",
    "鍮": "偷",
    "訉": "饭",
    "鈜": "红",
    "糷": "烂",
    "惙": "绰",
    "彾": "零",
    "覘": "搀",
    "伆": "物",
    "薸": "漂",
    "辬": "班",
    "誶": "岁",
    "拵": "存",
    "觵": "工",
    "銩": "丢",
    "鶥": "梅",
    "譩": "一",
    "縐": "昼",
    "竢": "四",
    "鐶": "环",
    "韨": "福",
    "捈": "图",
    "鱚": "洗",
    "辠": "最",
    "奩": "连",
    "菗": "愁",
    "鏣": "树",
    "讉": "宜",
    "怗": "贴",
    "烆": "横",
    "噇": "床",
    "擣": "导",
    "徛": "记",
    "黦": "月",
    "噲": "快",
    "妛": "吃",
    "銕": "铁",
    "敿": "角",
    "瘏": "图",
    "馜": "你",
    "駂": "宝",
    "裞": "睡",
    "糎": "离",
    "蘥": "月",
    "劙": "离",
    "孞": "信",
    "龏": "工",
    "蟇": "麻",
    "閗": "豆",
    "淎": "捧",
    "鬮": "纠",
    "漺": "双",
    "鉁": "真",
    "啹": "局",
    "嫟": "逆",
    "颭": "展",
    "羂": "倦",
    "逨": "来",
    "鬐": "其",
    "鍇": "凯",
    "甛": "田",
    "僝": "缠",
    "飊": "标",
    "娊": "现",
    "蟢": "洗",
    "甖": "应",
    "饟": "想",
    "萓": "宜",
    "熖": "燕",
    "搙": "怒",
    "翆": "翠",
    "鋩": "忙",
    "憓": "会",
    "搟": "显",
    "斵": "着",
    "蕬": "思",
    "膖": "旁",
    "礭": "确",
    "迉": "七",
    "砈": "饿",
    "咼": "锅",
    "戩": "减",
    "琒": "风",
    "慍": "运",
    "穜": "种",
    "馌": "夜",
    "橒": "云",
    "挜": "亚",
    "蠙": "贫",
    "馺": "萨",
    "纇": "泪",
    "夘": "帽",
    "佁": "以",
    "棷": "邹",
    "噳": "雨",
    "愊": "必",
    "灂": "着",
    "楲": "微",
    "癰": "庸",
    "竎": "父",
    "悏": "妾",
    "斘": "生",
    "躂": "达",
    "渞": "求",
    "昑": "寝",
    "鄾": "优",
    "驌": "速",
    "躧": "洗",
    "饤": "定",
    "齄": "扎",
    "嶮": "显",
    "恅": "老",
    "潣": "敏",
    "彑": "记",
    "宊": "突",
    "俴": "见",
    "饾": "豆",
    "鯮": "宗",
    "辢": "蜡",
    "媌": "描",
    "帄": "丁",
    "鞁": "被",
    "萭": "雨",
    "襃": "包",
    "絎": "行",
    "峝": "同",
    "諝": "需",
    "噃": "翻",
    "梀": "速",
    "磌": "田",
    "鯈": "条",
    "畮": "母",
    "恉": "指",
    "杫": "四",
    "倛": "七",
    "絠": "改",
    "鐱": "见",
    "刣": "中",
    "囇": "利",
    "僠": "波",
    "覜": "跳",
    "咮": "昼",
    "牰": "右",
    "慙": "残",
    "槀": "搞",
    "迒": "行",
    "鼘": "冤",
    "顣": "促",
    "瘔": "裤",
    "剮": "寡",
    "衶": "重",
    "赗": "奉",
    "挭": "梗",
    "禝": "记",
    "黷": "毒",
    "幑": "灰",
    "斸": "主",
    "貆": "环",
    "珓": "教",
    "啛": "翠",
    "訆": "教",
    "鱊": "玉",
    "碈": "民",
    "咷": "桃",
    "紕": "批",
    "笇": "算",
    "藂": "从",
    "圔": "亚",
    "踨": "宗",
    "葹": "诗",
    "鱬": "如",
    "戅": "杠",
    "艻": "乐",
    "憞": "对",
    "莧": "现",
    "泍": "奔",
    "燀": "铲",
    "楻": "黄",
    "煾": "恩",
    "僔": "尊",
    "襭": "鞋",
    "尷": "干",
    "淽": "指",
    "訃": "父",
    "碨": "位",
    "椷": "间",
    "嵏": "宗",
    "浀": "区",
    "幚": "帮",
    "鲄": "和",
    "辌": "良",
    "筜": "当",
    "苸": "呼",
    "滫": "修",
    "彸": "中",
    "妷": "直",
    "痓": "赤",
    "硰": "沙",
    "餿": "搜",
    "娬": "五",
    "鋮": "成",
    "晱": "闪",
    "秌": "秋",
    "熛": "标",
    "箤": "族",
    "胹": "而",
    "壖": "软",
    "霥": "梦",
    "殸": "庆",
    "硥": "忙",
    "惃": "滚",
    "彅": "减",
    "穊": "记",
    "幘": "则",
    "膧": "同",
    "愾": "开",
    "唕": "造",
    "魽": "含",
    "莕": "性",
    "鞆": "饼",
    "媬": "宝",
    "苚": "用",
    "椌": "枪",
    "軨": "零",
    "樕": "速",
    "屴": "利",
    "灠": "懒",
    "捇": "或",
    "婘": "全",
    "壂": "电",
    "禡": "骂",
    "勄": "敏",
    "澨": "是",
    "漍": "国",
    "尠": "显",
    "岼": "平",
    "鈫": "琴",
    "豵": "宗",
    "纋": "优",
    "怞": "愁",
    "泜": "知",
    "逥": "回",
    "湵": "有",
    "雮": "木",
    "飇": "标",
    "靬": "钱",
    "籧": "取",
    "猳": "家",
    "鹥": "一",
    "溹": "所",
    "歁": "砍",
    "賖": "舍",
    "窂": "劳",
    "譕": "无",
    "妦": "风",
    "浹": "家",
    "繮": "将",
    "鷘": "赤",
    "刜": "福",
    "嚠": "刘",
    "涥": "哼",
    "縡": "在",
    "鲉": "由",
    "笷": "帽",
    "銪": "有",
    "鷚": "六",
    "螘": "以",
    "卙": "极",
    "佌": "此",
    "眲": "呢",
    "埿": "尼",
    "俹": "亚",
    "玾": "假",
    "嶴": "奥",
    "虋": "门",
    "琾": "借",
    "醁": "路",
    "璒": "灯",
    "蕼": "四",
    "沍": "互",
    "唡": "两",
    "餳": "唐",
    "漘": "纯",
    "鶻": "古",
    "殧": "就",
    "粓": "干",
    "儤": "报",
    "柧": "姑",
    "帪": "真",
    "噟": "硬",
    "伭": "闲",
    "鹔": "速",
    "圤": "葡",
    "赒": "周",
    "鷔": "敖",
    "癇": "闲",
    "鲿": "长",
    "璵": "鱼",
    "悙": "哼",
    "泈": "中",
    "軑": "带",
    "弚": "推",
    "揅": "颜",
    "睄": "绍",
    "烮": "裂",
    "罶": "柳",
    "諢": "混",
    "麛": "迷",
    "辪": "靴",
    "迌": "兔",
    "袙": "怕",
    "躓": "至",
    "諈": "缀",
    "蝯": "原",
    "綼": "必",
    "洂": "夜",
    "褗": "眼",
    "繈": "抢",
    "眧": "吵",
    "渂": "问",
    "翧": "宣",
    "鉰": "思",
    "穬": "矿",
    "鸝": "离",
    "浱": "纯",
    "垔": "因",
    "愖": "陈",
    "騨": "驮",
    "蜨": "叠",
    "姰": "君",
    "囜": "您",
    "抶": "赤",
    "褳": "连",
    "骭": "干",
    "錇": "剖",
    "涆": "汉",
    "呟": "卷",
    "齏": "机",
    "峕": "石",
    "萵": "窝",
    "堧": "软",
    "蒪": "破",
    "灨": "干",
    "譶": "踏",
    "鱓": "善",
    "藧": "换",
    "傴": "雨",
    "袌": "报",
    "躥": "窜",
    "唋": "突",
    "唭": "气",
    "醞": "运",
    "朾": "成",
    "軃": "朵",
    "龂": "银",
    "薶": "买",
    "鴽": "如",
    "鵯": "杯",
    "獌": "慢",
    "屩": "绝",
    "娯": "鱼",
    "嶢": "摇",
    "郔": "颜",
    "榯": "石",
    "膵": "翠",
    "藅": "罚",
    "詵": "深",
    "緎": "玉",
    "乻": "鱼",
    "鷖": "一",
    "趫": "桥",
    "俀": "腿",
    "貺": "矿",
    "裌": "夹",
    "爁": "烂",
    "粩": "捞",
    "韈": "袜",
    "劘": "魔",
    "輹": "父",
    "喣": "许",
    "茷": "罚",
    "虌": "憋",
    "紌": "求",
    "塤": "熏",
    "鰼": "习",
    "耼": "单",
    "殙": "昏",
    "秔": "精",
    "恓": "西",
    "腷": "必",
    "駃": "觉",
    "圁": "银",
    "壄": "也",
    "榙": "他",
    "阛": "环",
    "醶": "燕",
    "鮶": "君",
    "寎": "病",
    "埰": "菜",
    "噦": "月",
    "笎": "原",
    "嚻": "消",
    "甮": "奉",
    "唹": "迂",
    "鐿": "意",
    "壋": "荡",
    "筫": "至",
    "釺": "前",
    "殜": "叠",
    "銧": "光",
    "桱": "静",
    "哶": "灭",
    "峏": "而",
    "珻": "梅",
    "匴": "算",
    "玈": "芦",
    "匒": "达",
    "鄅": "雨",
    "椏": "呀",
    "莵": "兔",
    "唶": "则",
    "偳": "端",
    "櫜": "高",
    "硞": "确",
    "蕣": "顺",
    "楥": "炫",
    "趉": "觉",
    "惌": "冤",
    "冸": "判",
    "抴": "夜",
    "謃": "星",
    "瘒": "文",
    "孧": "右",
    "兦": "王",
    "醳": "意",
    "絸": "减",
    "阤": "至",
    "跍": "哭",
    "簗": "助",
    "攽": "班",
    "籈": "真",
    "蛺": "夹",
    "釂": "教",
    "葲": "全",
    "燑": "同",
    "慛": "催",
    "釕": "了",
    "冞": "迷",
    "纈": "鞋",
    "沰": "拖",
    "奆": "倦",
    "鴫": "田",
    "羱": "原",
    "岇": "昂",
    "愓": "荡",
    "棎": "缠",
    "韃": "达",
    "踄": "不",
    "瘈": "赤",
    "隺": "胡",
    "郺": "庸",
    "鱀": "记",
    "鷦": "教",
    "倴": "笨",
    "疉": "叠",
    "埲": "崩",
    "絓": "挂",
    "嶁": "楼",
    "峢": "李",
    "澑": "六",
    "揂": "纠",
    "欀": "相",
    "敀": "破",
    "圗": "图",
    "僈": "瞒",
    "攆": "年",
    "沑": "女",
    "罧": "肾",
    "檣": "强",
    "硍": "现",
    "瓔": "应",
    "儮": "利",
    "蠚": "喝",
    "璖": "取",
    "汬": "井",
    "箉": "拐",
    "縩": "菜",
    "瑐": "减",
    "媥": "偏",
    "摠": "总",
    "鑌": "彬",
    "扤": "物",
    "鰂": "贼",
    "蒶": "坟",
    "鏨": "赞",
    "鸑": "月",
    "磹": "谈",
    "矱": "约",
    "閺": "文",
    "嘷": "豪",
    "泘": "呼",
    "坢": "办",
    "璡": "进",
    "蝱": "盟",
    "晜": "昆",
    "睗": "是",
    "缻": "否",
    "滍": "至",
    "閴": "去",
    "鯿": "编",
    "瓈": "离",
    "壃": "将",
    "剏": "创",
    "晀": "挑",
    "喤": "黄",
    "銚": "摇",
    "橓": "顺",
    "炋": "批",
    "枮": "先",
    "灈": "取",
    "蘪": "梅",
    "梡": "魂",
    "矉": "贫",
    "褾": "表",
    "淔": "直",
    "鉝": "利",
    "酅": "西",
    "禬": "贵",
    "颣": "泪",
    "轘": "环",
    "鴏": "带",
    "瀙": "亲",
    "諏": "邹",
    "鴳": "燕",
    "饘": "占",
    "鸌": "互",
    "鶖": "秋",
    "蚔": "其",
    "礉": "和",
    "潖": "爬",
    "藄": "其",
    "娐": "夫",
    "繑": "敲",
    "韽": "安",
    "茽": "重",
    "駔": "脏",
    "悢": "亮",
    "趽": "放",
    "牕": "窗",
    "滵": "密",
    "篽": "玉",
    "皡": "号",
    "萂": "和",
    "繂": "绿",
    "笰": "福",
    "咓": "瓦",
    "贋": "燕",
    "皻": "扎",
    "螾": "引",
    "惞": "心",
    "猰": "亚",
    "懜": "猛",
    "侅": "该",
    "煻": "唐",
    "莥": "纽",
    "鐁": "思",
    "奾": "先",
    "禜": "永",
    "鼑": "顶",
    "鎝": "答",
    "鎕": "唐",
    "曐": "星",
    "虣": "报",
    "秹": "忍",
    "梽": "至",
    "鋨": "铁",
    "葍": "福",
    "眫": "米",
    "欞": "零",
    "抌": "胆",
    "揝": "赞",
    "蔢": "婆",
    "婈": "零",
    "愜": "妾",
    "堾": "春",
    "佄": "憨",
    "剺": "离",
    "貹": "胜",
    "鮗": "东",
    "闑": "聂",
    "蹕": "必",
    "岊": "节",
    "鑢": "绿",
    "煃": "魁",
    "壚": "芦",
    "賎": "见",
    "摏": "冲",
    "魣": "续",
    "鞓": "听",
    "埊": "地",
    "鋕": "至",
    "鱣": "占",
    "嵧": "刘",
    "鎩": "沙",
    "筓": "机",
    "卼": "物",
    "媑": "重",
    "榅": "温",
    "粆": "沙",
    "錤": "机",
    "蠘": "节",
    "榾": "古",
    "甞": "长",
    "騩": "归",
    "幉": "叠",
    "巄": "龙",
    "鰱": "连",
    "腯": "图",
    "翋": "拉",
    "覊": "机",
    "桾": "君",
    "柌": "瓷",
    "礟": "炮",
    "碔": "五",
    "倵": "五",
    "櫚": "驴",
    "妌": "静",
    "俉": "五",
    "澭": "庸",
    "肂": "四",
    "骙": "奎",
    "爕": "谢",
    "誹": "匪",
    "胷": "胸",
    "筀": "贵",
    "夽": "允",
    "桺": "柳",
    "妔": "坑",
    "慓": "飘",
    "窻": "窗",
    "刴": "堕",
    "剼": "山",
    "貁": "右",
    "榳": "停",
    "繟": "铲",
    "鳦": "以",
    "緄": "滚",
    "虙": "福",
    "墡": "善",
    "螻": "楼",
    "僺": "巧",
    "闠": "会",
    "旽": "吞",
    "簉": "造",
    "癝": "吝",
    "挆": "朵",
    "揌": "塞",
    "竃": "造",
    "囋": "杂",
    "蟝": "取",
    "傂": "至",
    "穟": "岁",
    "荵": "忍",
    "忴": "钱",
    "楕": "妥",
    "瀓": "成",
    "淭": "取",
    "譭": "毁",
    "摮": "敖",
    "熆": "和",
    "僯": "吝",
    "蓎": "唐",
    "汒": "忙",
    "椫": "善",
    "睷": "间",
    "峖": "安",
    "獪": "快",
    "艛": "楼",
    "餧": "位",
    "萪": "科",
    "焿": "耕",
    "崍": "来",
    "蟈": "锅",
    "坆": "梅",
    "逴": "戳",
    "镃": "姿",
    "噆": "赞",
    "輧": "平",
    "絇": "取",
    "潨": "从",
    "瀡": "髓",
    "珔": "见",
    "蚚": "其",
    "饙": "分",
    "灙": "挡",
    "蘯": "荡",
    "泟": "称",
    "賙": "周",
    "僴": "现",
    "渻": "省",
    "藨": "标",
    "悤": "聪",
    "鈢": "洗",
    "籂": "诗",
    "蚞": "木",
    "魒": "飘",
    "薵": "愁",
    "闏": "风",
    "樅": "聪",
    "榿": "七",
    "瑲": "枪",
    "匊": "居",
    "蝛": "微",
    "杁": "入",
    "嚂": "烂",
    "氻": "乐",
    "蝡": "如",
    "唈": "意",
    "浧": "影",
    "髲": "必",
    "垀": "呼",
    "祑": "至",
    "芿": "仍",
    "偼": "节",
    "饎": "赤",
    "褸": "旅",
    "阣": "概",
    "輷": "轰",
    "乕": "虎",
    "櫫": "朱",
    "糝": "三",
    "嚫": "衬",
    "帟": "意",
    "楖": "至",
    "鈶": "四",
    "牪": "燕",
    "矠": "则",
    "鬺": "伤",
    "鷯": "聊",
    "煁": "陈",
    "鄑": "姿",
    "斄": "离",
    "襍": "杂",
    "窼": "招",
    "圐": "哭",
    "浢": "豆",
    "袇": "然",
    "硲": "玉",
    "犘": "麻",
    "裪": "桃",
    "聮": "连",
    "嶓": "波",
    "剾": "口",
    "卪": "节",
    "徆": "西",
    "敜": "聂",
    "瀿": "烦",
    "霣": "允",
    "鷉": "踢",
    "荋": "而",
    "嗺": "嘴",
    "綀": "书",
    "囃": "擦",
    "騂": "星",
    "誽": "逆",
    "隞": "敖",
    "忦": "夹",
    "濼": "落",
    "痽": "堆",
    "溠": "咋",
    "劔": "见",
    "廔": "楼",
    "儦": "标",
    "跲": "夹",
    "虷": "含",
    "蚻": "炸",
    "骴": "刺",
    "墑": "地",
    "韠": "必",
    "輴": "春",
    "僐": "善",
    "鲪": "君",
    "剫": "夺",
    "蕋": "瑞",
    "罳": "思",
    "錋": "朋",
    "鱝": "愤",
    "抈": "月",
    "飍": "修",
    "榬": "原",
    "懣": "闷",
    "澮": "会",
    "憈": "区",
    "鋚": "条",
    "嚈": "夜",
    "朜": "吞",
    "犉": "纯",
    "馉": "古",
    "駘": "台",
    "壪": "弯",
    "竏": "前",
    "蓙": "做",
    "伻": "崩",
    "垿": "续",
    "舕": "探",
    "檟": "假",
    "稧": "系",
    "檇": "最",
    "蕠": "如",
    "茠": "蒿",
    "孼": "聂",
    "矺": "哲",
    "瀠": "营",
    "氊": "占",
    "娻": "东",
    "暯": "墨",
    "隡": "萨",
    "垳": "行",
    "憜": "堕",
    "駹": "忙",
    "崹": "提",
    "蹐": "极",
    "喴": "微",
    "鳼": "文",
    "棆": "伦",
    "喕": "免",
    "烾": "赤",
    "禑": "无",
    "挦": "闲",
    "澸": "胆",
    "伔": "胆",
    "鯻": "蜡",
    "鈒": "萨",
    "楶": "节",
    "鼪": "生",
    "薽": "真",
    "屨": "巨",
    "疻": "指",
    "觍": "舔",
    "妎": "害",
    "奅": "炮",
    "湬": "角",
    "丣": "有",
    "軰": "被",
    "呁": "俊",
    "忟": "稳",
    "勚": "意",
    "齨": "就",
    "窴": "田",
    "漮": "康",
    "樀": "敌",
    "飣": "定",
    "弉": "藏",
    "翏": "六",
    "尣": "汪",
    "羄": "照",
    "粸": "其",
    "袺": "节",
    "鐉": "圈",
    "厈": "罕",
    "腶": "断",
    "駞": "驮",
    "諌": "懂",
    "搱": "至",
    "袐": "必",
    "魠": "拖",
    "迻": "宜",
    "咺": "选",
    "莟": "汉",
    "暜": "普",
    "詃": "减",
    "鱄": "专",
    "鵳": "间",
    "萛": "纠",
    "頋": "饿",
    "擕": "鞋",
    "搰": "胡",
    "獆": "豪",
    "嘺": "桥",
    "爖": "龙",
    "碫": "断",
    "樃": "浪",
    "羏": "羊",
    "褭": "尿",
    "橅": "魔",
    "肎": "肯",
    "禥": "其",
    "寙": "雨",
    "旹": "石",
    "鈁": "方",
    "蘳": "灰",
    "乭": "石",
    "凙": "夺",
    "覰": "区",
    "粁": "前",
    "堐": "牙",
    "倸": "采",
    "挮": "体",
    "籱": "着",
    "軘": "吞",
    "罎": "谈",
    "蔍": "路",
    "烖": "灾",
    "臷": "叠",
    "沜": "判",
    "湏": "会",
    "儽": "雷",
    "蒀": "晕",
    "黌": "红",
    "綞": "朵",
    "轝": "玉",
    "鄐": "处",
    "峂": "同",
    "骦": "双",
    "窶": "巨",
    "餱": "喉",
    "輞": "网",
    "猤": "贵",
    "菶": "崩",
    "璴": "楚",
    "竍": "石",
    "膹": "愤",
    "箈": "台",
    "黈": "偷",
    "藢": "指",
    "臠": "鸾",
    "捿": "七",
    "裬": "零",
    "蜅": "辅",
    "曶": "呼",
    "穛": "捉",
    "獈": "意",
    "崪": "族",
    "誜": "刷",
    "嫸": "展",
    "衂": "女",
    "嵄": "美",
    "萯": "父",
    "胏": "子",
    "馝": "必",
    "薠": "烦",
    "郣": "博",
    "釴": "意",
    "琕": "贫",
    "謩": "魔",
    "帵": "弯",
    "侇": "宜",
    "潫": "弯",
    "盠": "离",
    "剟": "多",
    "芵": "觉",
    "潠": "训",
    "皅": "趴",
    "嫧": "则",
    "畣": "达",
    "靇": "龙",
    "菎": "昆",
    "剚": "字",
    "籩": "编",
    "犃": "剖",
    "賫": "机",
    "蓚": "条",
    "嘨": "笑",
    "蹅": "差",
    "皰": "炮",
    "諕": "豪",
    "藷": "鼠",
    "鋘": "华",
    "籯": "营",
    "櫪": "利",
    "鴊": "挣",
    "徻": "会",
    "昣": "枕",
    "賅": "该",
    "耡": "除",
    "瀜": "容",
    "娀": "松",
    "婫": "昆",
    "緪": "耕",
    "搕": "科",
    "忢": "物",
    "蚘": "回",
    "怤": "夫",
    "貐": "雨",
    "勱": "卖",
    "虤": "颜",
    "麄": "粗",
    "獹": "芦",
    "侸": "树",
    "糲": "利",
    "鏛": "长",
    "匤": "区",
    "蠭": "风",
    "巋": "亏",
    "譓": "会",
    "瀇": "网",
    "鴍": "文",
    "撢": "胆",
    "繸": "岁",
    "埨": "伦",
    "坱": "养",
    "潱": "椰",
    "忣": "极",
    "獮": "显",
    "礶": "灌",
    "擯": "宾",
    "埀": "垂",
    "酇": "赞",
    "岥": "坡",
    "榥": "荒",
    "顁": "定",
    "椙": "昌",
    "吺": "兜",
    "鏵": "华",
    "漟": "唐",
    "蒢": "除",
    "俇": "逛",
    "犠": "西",
    "珿": "处",
    "甤": "瑞",
    "奱": "鸾",
    "鉋": "报",
    "犙": "三",
    "幤": "必",
    "屪": "聊",
    "綊": "鞋",
    "塇": "宣",
    "淗": "局",
    "沗": "旁",
    "髧": "蛋",
    "詑": "宜",
    "凷": "快",
    "漦": "持",
    "凮": "风",
    "僟": "机",
    "秄": "子",
    "殀": "邀",
    "窐": "归",
    "邆": "腾",
    "憒": "溃",
    "汻": "虎",
    "芇": "眠",
    "叇": "带",
    "拕": "拖",
    "浟": "由",
    "繵": "蛋",
    "鱅": "庸",
    "鎡": "姿",
    "蓭": "安",
    "脄": "梅",
    "鹺": "搓",
    "捬": "辅",
    "幜": "井",
    "棔": "昏",
    "韑": "伟",
    "沶": "宜",
    "浲": "逢",
    "盇": "和",
    "蒃": "赚",
    "卛": "帅",
    "眻": "羊",
    "箯": "编",
    "蓽": "必",
    "刐": "胆",
    "趚": "速",
    "踧": "促",
    "娷": "缀",
    "煟": "位",
    "瘲": "宗",
    "秼": "朱",
    "紷": "零",
    "揫": "纠",
    "俌": "辅",
    "滊": "系",
    "匛": "就",
    "蘢": "龙",
    "姯": "光",
    "虅": "腾",
    "竸": "静",
    "臶": "见",
    "倯": "松",
    "礊": "客",
    "佊": "比",
    "靂": "利",
    "驄": "聪",
    "爚": "月",
    "迼": "节",
    "梪": "豆",
    "禢": "踏",
    "颻": "摇",
    "飩": "吞",
    "煯": "接",
    "輤": "欠",
    "氎": "叠",
    "聐": "亚",
    "熕": "工",
    "婯": "利",
    "肙": "院",
    "縼": "炫",
    "濎": "顶",
    "鞵": "鞋",
    "恟": "胸",
    "焛": "吝",
    "獷": "广",
    "鯁": "梗",
    "魸": "片",
    "翜": "煞",
    "縧": "掏",
    "芅": "意",
    "砛": "金",
    "曗": "夜",
    "僽": "昼",
    "蝍": "节",
    "頍": "魁",
    "焟": "西",
    "欶": "硕",
    "巪": "巨",
    "罞": "毛",
    "鶕": "安",
    "搉": "确",
    "檲": "团",
    "巎": "脑",
    "吜": "丑",
    "靌": "宝",
    "壝": "伟",
    "洍": "四",
    "觲": "星",
    "宂": "容",
    "罏": "芦",
    "謖": "速",
    "櫱": "聂",
    "廱": "庸",
    "遫": "赤",
    "椊": "做",
    "珟": "速",
    "忹": "狂",
    "謉": "溃",
    "鵞": "额",
    "璔": "增",
    "爮": "袍",
    "爯": "称",
    "浖": "裂",
    "灀": "双",
    "墪": "蹲",
    "蛓": "次",
    "貟": "原",
    "葼": "宗",
    "觬": "尼",
    "訡": "银",
    "漹": "烟",
    "蓷": "推",
    "峗": "维",
    "扲": "钱",
    "狽": "被",
    "乹": "干",
    "鷊": "意",
    "媊": "钱",
    "騋": "来",
    "迡": "逆",
    "鐄": "黄",
    "碝": "软",
    "赸": "善",
    "媠": "妥",
    "緺": "瓜",
    "鐬": "会",
    "兺": "分",
    "瞯": "闲",
    "麳": "来",
    "熁": "鞋",
    "澕": "和",
    "膓": "长",
    "梉": "装",
    "鐀": "溃",
    "鷆": "田",
    "凧": "睁",
    "緁": "妾",
    "咶": "坏",
    "矂": "懆",
    "洬": "速",
    "楺": "柔",
    "鳑": "旁",
    "緸": "因",
    "譖": "怎",
    "颷": "标",
    "炓": "料",
    "籰": "月",
    "巁": "利",
    "厀": "西",
    "嘒": "会",
    "饀": "桃",
    "蝐": "帽",
    "闤": "环",
    "鉺": "二",
    "羀": "柳",
    "唀": "右",
    "莁": "无",
    "縆": "耕",
    "儧": "赞",
    "飤": "四",
    "欝": "玉",
    "齟": "举",
    "圷": "下",
    "喗": "允",
    "萅": "春",
    "愄": "微",
    "滪": "玉",
    "揙": "编",
    "慠": "奥",
    "螎": "容",
    "筺": "框",
    "坃": "熏",
    "噅": "灰",
    "枴": "拐",
    "祬": "知",
    "牣": "任",
    "矑": "芦",
    "汳": "变",
    "謈": "婆",
    "鏾": "三",
    "剨": "霍",
    "蒁": "树",
    "惍": "金",
    "嵵": "石",
    "鷝": "必",
    "蝬": "宗",
    "胓": "平",
    "峊": "父",
    "碋": "贺",
    "遰": "地",
    "魓": "必",
    "舤": "烦",
    "洭": "框",
    "阹": "区",
    "夅": "降",
    "揕": "镇",
    "繲": "谢",
    "娫": "颜",
    "嬟": "意",
    "錽": "万",
    "梴": "搀",
    "橝": "电",
    "窽": "款",
    "瑽": "聪",
    "爌": "矿",
    "宒": "准",
    "謓": "陈",
    "獢": "消",
    "郘": "旅",
    "燖": "寻",
    "蝞": "妹",
    "錑": "泪",
    "猽": "明",
    "轃": "真",
    "躃": "必",
    "冝": "宜",
    "殕": "否",
    "趖": "缩",
    "飫": "玉",
    "涰": "绰",
    "翂": "分",
    "婣": "因",
    "橖": "唐",
    "汦": "指",
    "扜": "迂",
    "咟": "或",
    "懕": "烟",
    "纉": "钻",
    "鬷": "宗",
    "悺": "灌",
    "郲": "来",
    "鱫": "爱",
    "椱": "父",
    "颼": "搜",
    "繤": "钻",
    "褱": "怀",
    "曨": "龙",
    "爃": "容",
    "黵": "展",
    "伿": "意",
    "釰": "日",
    "艤": "以",
    "芀": "条",
    "畕": "将",
    "靫": "茶",
    "齝": "吃",
    "縿": "山",
    "荺": "允",
    "歮": "色",
    "麌": "雨",
    "煝": "妹",
    "阭": "允",
    "陾": "仍",
    "踆": "村",
    "峆": "和",
    "劤": "进",
    "霨": "位",
    "玵": "岸",
    "鍉": "低",
    "啒": "古",
    "紲": "谢",
    "萴": "册",
    "籋": "聂",
    "獧": "倦",
    "鉫": "家",
    "墌": "直",
    "鉐": "石",
    "斨": "枪",
    "蟡": "鬼",
    "磎": "西",
    "杝": "离",
    "杸": "书",
    "疕": "比",
    "鉔": "匝",
    "蝚": "柔",
    "躣": "取",
    "冎": "寡",
    "珤": "宝",
    "蚆": "八",
    "篵": "聪",
    "湕": "减",
    "朻": "纠",
    "荰": "度",
    "穻": "迂",
    "僃": "被",
    "嚖": "会",
    "鞿": "机",
    "摬": "影",
    "檦": "表",
    "奰": "必",
    "嘵": "消",
    "爅": "墨",
    "燡": "意",
    "劥": "坑",
    "杶": "春",
    "葿": "梅",
    "蕳": "间",
    "逎": "求",
    "鰫": "庸",
    "蒆": "靴",
    "騣": "宗",
    "匬": "雨",
    "驂": "参",
    "啑": "煞",
    "綹": "柳",
    "廐": "就",
    "鯾": "编",
    "詻": "恶",
    "櫬": "衬",
    "鄋": "搜",
    "鞀": "桃",
    "鋡": "含",
    "媁": "维",
    "鞟": "扩",
    "餜": "果",
    "錼": "耐",
    "盳": "忘",
    "虘": "搓",
    "葃": "做",
    "簁": "筛",
    "輳": "凑",
    "盋": "波",
    "靔": "天",
    "貒": "团",
    "戧": "枪",
    "畟": "册",
    "禼": "谢",
    "鹴": "双",
    "廦": "必",
    "釖": "刀",
    "垹": "帮",
    "穵": "挖",
    "趠": "绰",
    "撧": "绝",
    "脼": "两",
    "偀": "应",
    "婾": "偷",
    "稉": "精",
    "嬍": "美",
    "詍": "意",
    "蛣": "七",
    "嶔": "亲",
    "酘": "豆",
    "擵": "魔",
    "憭": "了",
    "瑿": "一",
    "貀": "那",
    "閅": "门",
    "煢": "穷",
    "醎": "闲",
    "菳": "琴",
    "薋": "瓷",
    "劖": "缠",
    "鷐": "陈",
    "筄": "要",
    "毿": "三",
    "覂": "奉",
    "檍": "意",
    "寷": "风",
    "釪": "华",
    "湹": "缠",
    "憃": "冲",
    "槕": "捉",
    "轪": "带",
    "煱": "瓜",
    "鴜": "瓷",
    "歊": "消",
    "鰯": "弱",
    "陃": "饼",
    "舑": "贪",
    "夒": "脑",
    "戺": "是",
    "潳": "图",
    "蒧": "点",
    "鲾": "逼",
    "媋": "春",
    "鬙": "僧",
    "齕": "和",
    "蟩": "觉",
    "袵": "任",
    "腤": "安",
    "鮹": "烧",
    "奜": "匪",
    "靯": "度",
    "戄": "觉",
    "塨": "工",
    "泀": "思",
    "鯝": "固",
    "寊": "真",
    "耴": "意",
    "魌": "七",
    "鱦": "硬",
    "踠": "碗",
    "笍": "缀",
    "痝": "忙",
    "鯹": "星",
    "贁": "败",
    "銗": "向",
    "斆": "笑",
    "寋": "见",
    "峟": "右",
    "灧": "燕",
    "鋄": "万",
    "綌": "系",
    "藇": "续",
    "鷙": "至",
    "踘": "居",
    "頄": "奎",
    "嚲": "朵",
    "恀": "是",
    "嬓": "教",
    "嬜": "心",
    "鼀": "促",
    "俋": "意",
    "枍": "意",
    "嫝": "康",
    "紃": "寻",
    "醓": "坦",
    "榤": "节",
    "旿": "五",
    "堻": "金",
    "懰": "刘",
    "揗": "寻",
    "娪": "无",
    "簂": "贵",
    "蚼": "狗",
    "斢": "挑",
    "乤": "下",
    "鄨": "必",
    "菧": "底",
    "螆": "次",
    "忊": "定",
    "樠": "瞒",
    "碃": "庆",
    "烰": "福",
    "鸇": "占",
    "鵻": "追",
    "縕": "运",
    "鉼": "饼",
    "裃": "卡",
    "駈": "区",
    "鞻": "楼",
    "劜": "亚",
    "禐": "院",
    "弿": "减",
    "酛": "原",
    "衏": "院",
    "鯎": "成",
    "蛖": "忙",
    "潹": "缠",
    "堘": "成",
    "裩": "昆",
    "嫾": "连",
    "炡": "睁",
    "葌": "间",
    "秳": "活",
    "袨": "炫",
    "趷": "科",
    "饠": "罗",
    "縚": "掏",
    "聕": "号",
    "輊": "至",
    "凞": "西",
    "猒": "燕",
    "罖": "罗",
    "涽": "昏",
    "褧": "窘",
    "曮": "眼",
    "軞": "毛",
    "趜": "局",
    "燳": "照",
    "埓": "裂",
    "騛": "飞",
    "痵": "记",
    "煹": "够",
    "櫞": "原",
    "璍": "夜",
    "穚": "教",
    "椶": "宗",
    "獜": "林",
    "鏦": "聪",
    "趮": "造",
    "觕": "粗",
    "耰": "优",
    "衟": "到",
    "礹": "颜",
    "巓": "颠",
    "緅": "邹",
    "豻": "按",
    "鄷": "风",
    "鼃": "挖",
    "籝": "营",
    "丮": "几",
    "堹": "重",
    "璅": "锁",
    "祳": "肾",
    "繏": "炫",
    "鲏": "皮",
    "姼": "石",
    "揻": "微",
    "繅": "骚",
    "鶒": "赤",
    "幠": "呼",
    "嬣": "凝",
    "躝": "蓝",
    "陼": "主",
    "鴓": "灭",
    "鼳": "局",
    "臩": "广",
    "犕": "被",
    "礨": "垒",
    "弆": "举",
    "葧": "博",
    "靤": "报",
    "輑": "引",
    "驘": "罗",
    "絻": "免",
    "鞧": "秋",
    "鞨": "和",
    "馠": "憨",
    "牨": "刚",
    "譤": "机",
    "獡": "硕",
    "倽": "煞",
    "砨": "恶",
    "欿": "砍",
    "籛": "减",
    "巰": "求",
    "瞆": "溃",
    "鼂": "朝",
    "粇": "康",
    "襈": "赚",
    "碢": "驮",
    "眝": "助",
    "猵": "编",
    "敒": "深",
    "簄": "互",
    "觹": "西",
    "匁": "文",
    "娾": "矮",
    "禂": "导",
    "肁": "照",
    "鰶": "记",
    "爢": "迷",
    "瘻": "漏",
    "枛": "照",
    "醽": "零",
    "圿": "夹",
    "詙": "拔",
    "瑦": "五",
    "椸": "宜",
    "鰏": "逼",
    "尶": "干",
    "斕": "蓝",
    "溓": "连",
    "觱": "必",
    "蚄": "方",
    "圎": "原",
    "櫴": "赖",
    "媈": "灰",
    "仜": "红",
    "刱": "创",
    "櫑": "雷",
    "轢": "利",
    "雥": "杂",
    "坧": "知",
    "棖": "成",
    "螠": "意",
    "窢": "需",
    "鶽": "损",
    "砅": "利",
    "疷": "知",
    "挸": "减",
    "堷": "印",
    "妉": "单",
    "甠": "情",
    "蘷": "奎",
    "朁": "惨",
    "鞾": "靴",
    "烒": "是",
    "澒": "红",
    "歰": "色",
    "枅": "机",
    "癁": "福",
    "宱": "咋",
    "矓": "龙",
    "洷": "至",
    "簶": "路",
    "橉": "吝",
    "罛": "姑",
    "塿": "楼",
    "陘": "行",
    "礜": "玉",
    "敂": "扣",
    "僼": "风",
    "蜯": "棒",
    "醰": "谈",
    "謷": "敖",
    "岏": "完",
    "餷": "插",
    "塮": "谢",
    "齜": "柴",
    "膃": "袜",
    "扸": "西",
    "卂": "训",
    "臦": "逛",
    "藾": "赖",
    "鱶": "想",
    "缹": "否",
    "厧": "颠",
    "匃": "概",
    "呩": "是",
    "輭": "软",
    "滻": "铲",
    "辤": "瓷",
    "剦": "烟",
    "搘": "知",
    "帗": "波",
    "窌": "教",
    "贑": "干",
    "甝": "含",
    "甈": "气",
    "礸": "擦",
    "辳": "农",
    "騜": "黄",
    "麖": "精",
    "乶": "辅",
    "阘": "达",
    "逓": "地",
    "穅": "康",
    "槰": "朋",
    "剢": "督",
    "揥": "替",
    "釡": "辅",
    "雼": "荡",
    "菭": "台",
    "鴗": "利",
    "媙": "微",
    "駓": "批",
    "鴄": "匹",
    "覿": "敌",
    "綡": "良",
    "懯": "夫",
    "煏": "必",
    "艑": "变",
    "袧": "勾",
    "阠": "信",
    "穧": "记",
    "蚇": "尺",
    "毣": "木",
    "蜧": "利",
    "韍": "福",
    "蠦": "芦",
    "齺": "邹",
    "閁": "骂",
    "榟": "子",
    "鍤": "插",
    "曂": "荒",
    "鹒": "耕",
    "磂": "刘",
    "蒭": "除",
    "峱": "脑",
    "磏": "连",
    "荂": "夫",
    "拺": "册",
    "梖": "被",
    "耬": "楼",
    "葔": "喉",
    "柕": "帽",
    "礇": "玉",
    "逽": "诺",
    "乨": "使",
    "鮞": "而",
    "暵": "汉",
    "邍": "原",
    "枀": "松",
    "鰃": "微",
    "屓": "谢",
    "袡": "然",
    "圇": "伦",
    "虗": "需",
    "鞎": "很",
    "崊": "林",
    "矁": "丑",
    "俈": "裤",
    "馎": "博",
    "抭": "咬",
    "篨": "除",
    "蕌": "垒",
    "箶": "胡",
    "餈": "瓷",
    "虪": "树",
    "囕": "懒",
    "踳": "喘",
    "蝲": "蜡",
    "媹": "刘",
    "嶤": "摇",
    "眑": "咬",
    "濨": "瓷",
    "檿": "眼",
    "檏": "普",
    "劌": "贵",
    "慁": "混",
    "嶗": "劳",
    "圢": "挺",
    "霳": "龙",
    "艈": "玉",
    "醹": "如",
    "庼": "请",
    "欂": "博",
    "酧": "愁",
    "醄": "桃",
    "哣": "剖",
    "醕": "纯",
    "窫": "亚",
    "甒": "五",
    "峬": "不",
    "篊": "黄",
    "兤": "谎",
    "橊": "刘",
    "繢": "会",
    "獽": "嚷",
    "茩": "够",
    "邿": "诗",
    "醷": "意",
    "孴": "你",
    "鐃": "脑",
    "礧": "雷",
    "厞": "费",
    "嚁": "敌",
    "椖": "朋",
    "薃": "号",
    "刌": "存",
    "翽": "会",
    "噥": "农",
    "煪": "求",
    "硠": "狼",
    "秙": "裤",
    "薖": "科",
    "襆": "福",
    "椃": "豪",
    "瓉": "赞",
    "堭": "黄",
    "踶": "地",
    "懙": "雨",
    "墸": "助",
    "剄": "井",
    "釙": "破",
    "畖": "挖",
    "焸": "胸",
    "抏": "完",
    "磿": "利",
    "牶": "劝",
    "襩": "鼠",
    "椘": "楚",
    "虨": "彬",
    "寉": "贺",
    "哠": "号",
    "緙": "客",
    "靧": "会",
    "袽": "如",
    "扚": "掉",
    "涺": "居",
    "諘": "表",
    "峍": "路",
    "鏳": "称",
    "皩": "荒",
    "踤": "族",
    "鄆": "运",
    "慹": "直",
    "怌": "培",
    "摴": "出",
    "汓": "求",
    "呥": "然",
    "抧": "指",
    "碬": "侠",
    "鴸": "朱",
    "濵": "彬",
    "褈": "虫",
    "鶪": "局",
    "嫎": "旁",
    "鸊": "屁",
    "韊": "蓝",
    "鷡": "无",
    "旕": "鱼",
    "蜙": "松",
    "捸": "突",
    "蹢": "敌",
    "皉": "此",
    "臽": "现",
    "霐": "红",
    "燣": "蓝",
    "煗": "暖",
    "帿": "喉",
    "鄳": "盟",
    "漒": "强",
    "粫": "而",
    "岹": "条",
    "銍": "至",
    "圅": "含",
    "俒": "混",
    "蛃": "饼",
    "奫": "晕",
    "夵": "眼",
    "瞂": "罚",
    "劸": "挖",
    "侳": "做",
    "鲖": "同",
    "桙": "鱼",
    "齌": "记",
    "鑞": "蜡",
    "巹": "紧",
    "裭": "尺",
    "豦": "巨",
    "啌": "相",
    "莚": "颜",
    "郱": "平",
    "溎": "燕",
    "璬": "角",
    "錂": "零",
    "薢": "谢",
    "稬": "诺",
    "狇": "木",
    "鸓": "垒",
    "樏": "垒",
    "躩": "觉",
    "蛒": "格",
    "塓": "密",
    "剱": "见",
    "蒩": "租",
    "圚": "会",
    "鍳": "见",
    "峚": "密",
    "蚲": "平",
    "慖": "国",
    "瑓": "练",
    "塏": "凯",
    "襡": "鼠",
    "荹": "不",
    "氜": "羊",
    "爟": "灌",
    "箆": "必",
    "赬": "称",
    "齆": "瓮",
    "餋": "倦",
    "噮": "院",
    "糂": "三",
    "鶠": "眼",
    "氒": "觉",
    "葮": "断",
    "蠐": "其",
    "錏": "呀",
    "趒": "条",
    "摚": "称",
    "狏": "驮",
    "鑓": "浅",
    "湤": "诗",
    "檾": "请",
    "綒": "夫",
    "罯": "俺",
    "稑": "路",
    "曅": "夜",
    "澟": "吝",
    "獉": "真",
    "鑥": "鲁",
    "暶": "旋",
    "堩": "更",
    "鸂": "西",
    "斳": "琴",
    "蜋": "狼",
    "嘑": "呼",
    "瓬": "访",
    "誖": "被",
    "燵": "达",
    "乵": "眼",
    "臙": "烟",
    "雟": "西",
    "袀": "君",
    "厱": "蓝",
    "蹹": "他",
    "摙": "脸",
    "堒": "昆",
    "豀": "西",
    "挳": "坑",
    "瞡": "归",
    "諪": "停",
    "犎": "风",
    "鏝": "慢",
    "纎": "先",
    "爎": "聊",
    "襂": "森",
    "搸": "真",
    "楘": "木",
    "漎": "从",
    "坹": "血",
    "鄤": "慢",
    "鞌": "安",
    "渜": "暖",
    "顴": "全",
    "厃": "伟",
    "蓪": "通",
    "欘": "竹",
    "穇": "惨",
    "顑": "砍",
    "霛": "零",
    "紏": "偷",
    "縑": "间",
    "賻": "父",
    "戭": "眼",
    "亝": "其",
    "扴": "夹",
    "膐": "旅",
    "鈏": "引",
    "鴃": "觉",
    "礑": "荡",
    "櫉": "除",
    "嬽": "冤",
    "皪": "利",
    "駶": "局",
    "蕸": "侠",
    "纊": "矿",
    "牉": "判",
    "甆": "瓷",
    "戁": "男",
    "惸": "穷",
    "邧": "原",
    "犗": "借",
    "閈": "汉",
    "儌": "角",
    "灚": "角",
    "醻": "愁",
    "畒": "母",
    "挩": "拖",
    "莏": "缩",
    "欭": "意",
    "齱": "邹",
    "覤": "系",
    "誚": "巧",
    "牻": "忙",
    "殾": "训",
    "鶤": "昆",
    "鉶": "行",
    "鄡": "敲",
    "舮": "芦",
    "憮": "五",
    "墴": "黄",
    "譐": "尊",
    "聏": "而",
    "栰": "罚",
    "帾": "堵",
    "厪": "紧",
    "昛": "巨",
    "踛": "路",
    "閵": "吝",
    "礘": "恶",
    "悥": "意",
    "礄": "桥",
    "顬": "如",
    "頙": "撤",
    "燗": "烂",
    "郰": "邹",
    "嵡": "瓮",
    "焴": "玉",
    "臐": "熏",
    "邐": "李",
    "襢": "坦",
    "蒥": "刘",
    "霔": "助",
    "繜": "尊",
    "岅": "板",
    "砎": "借",
    "磟": "六",
    "傔": "欠",
    "喒": "杂",
    "濹": "么",
    "鷜": "驴",
    "芁": "教",
    "撠": "几",
    "骾": "梗",
    "曤": "或",
    "諰": "洗",
    "灲": "消",
    "徶": "别",
    "鵹": "离",
    "欴": "狼",
    "誷": "网",
    "馚": "坟",
    "鰔": "感",
    "鞜": "踏",
    "鼜": "气",
    "摫": "归",
    "漑": "概",
    "嶵": "嘴",
    "檋": "局",
    "鏸": "会",
    "謍": "营",
    "兛": "前",
    "僄": "票",
    "謸": "敖",
    "鱞": "关",
    "綧": "准",
    "辸": "仍",
    "跰": "偏",
    "陿": "侠",
    "穾": "要",
    "籒": "昼",
    "橸": "精",
    "簆": "扣",
    "偹": "被",
    "稫": "屁",
    "廧": "强",
    "鹠": "刘",
    "峞": "维",
    "敚": "夺",
    "衦": "感",
    "箾": "硕",
    "菺": "间",
    "鵿": "生",
    "喭": "燕",
    "鸴": "学",
    "蛫": "鬼",
    "傤": "在",
    "琘": "民",
    "艭": "双",
    "鵦": "路",
    "趦": "姿",
    "槜": "最",
    "穖": "几",
    "胮": "旁",
    "怰": "炫",
    "僗": "劳",
    "珘": "周",
    "阺": "底",
    "埮": "探",
    "湺": "闲",
    "嵅": "含",
    "汱": "犬",
    "尩": "汪",
    "趛": "引",
    "昖": "颜",
    "昘": "访",
    "劽": "裂",
    "錙": "姿",
    "畡": "该",
    "楜": "胡",
    "屵": "恶",
    "蓡": "深",
    "谼": "红",
    "繉": "魂",
    "膡": "硬",
    "郟": "夹",
    "鷛": "庸",
    "孆": "应",
    "冺": "敏",
    "淊": "烟",
    "傿": "燕",
    "嬃": "需",
    "鬊": "顺",
    "讋": "哲",
    "鰎": "减",
    "圼": "聂",
    "鷓": "这",
    "鐇": "烦",
    "秎": "愤",
    "颲": "裂",
    "胈": "拔",
    "鼣": "费",
    "珫": "冲",
    "卥": "西",
    "坽": "零",
    "笡": "妾",
    "鑗": "离",
    "隉": "聂",
    "熣": "虽",
    "痚": "消",
    "汥": "知",
    "嚾": "欢",
    "踖": "极",
    "敃": "敏",
    "茐": "聪",
    "麰": "谋",
    "苢": "以",
    "鴌": "奉",
    "巙": "奎",
    "堗": "突",
    "邫": "帮",
    "轓": "翻",
    "悋": "吝",
    "韣": "毒",
    "疞": "需",
    "桪": "寻",
    "婡": "来",
    "犝": "同",
    "杛": "工",
    "湨": "局",
    "訒": "任",
    "悷": "利",
    "蹖": "冲",
    "奒": "开",
    "輂": "局",
    "怚": "巨",
    "湆": "气",
    "葊": "安",
    "凁": "搜",
    "澽": "巨",
    "檡": "宅",
    "嵉": "停",
    "畉": "福",
    "疘": "刚",
    "蘠": "强",
    "櫝": "毒",
    "輍": "玉",
    "楰": "鱼",
    "椵": "假",
    "皭": "教",
    "礷": "蓝",
    "熅": "运",
    "雔": "愁",
    "剒": "错",
    "蒰": "盘",
    "祮": "告",
    "璕": "寻",
    "侜": "周",
    "岧": "条",
    "襵": "者",
    "箼": "乌",
    "絏": "谢",
    "凾": "含",
    "垖": "堆",
    "颶": "巨",
    "頚": "井",
    "鯸": "喉",
    "巚": "眼",
    "齠": "条",
    "塻": "墨",
    "竓": "豪",
    "嵣": "荡",
    "胣": "尺",
    "媦": "位",
    "傱": "耸",
    "毸": "塞",
    "欪": "处",
    "纐": "角",
    "螉": "瓮",
    "摪": "将",
    "殠": "臭",
    "磒": "允",
    "誎": "促",
    "鶵": "除",
    "蒖": "真",
    "璼": "蓝",
    "睋": "额",
    "秐": "云",
    "筞": "册",
    "鵪": "安",
    "迬": "助",
    "勌": "倦",
    "哤": "忙",
    "苉": "匹",
    "愋": "宣",
    "獘": "必",
    "颵": "烧",
    "瀴": "营",
    "歏": "进",
    "孶": "姿",
    "擥": "懒",
    "牼": "坑",
    "躌": "五",
    "祱": "睡",
    "糿": "右",
    "洕": "印",
    "豰": "博",
    "餤": "谈",
    "梩": "离",
    "蒠": "西",
    "脀": "成",
    "誆": "框",
    "禙": "被",
    "鸕": "芦",
    "馽": "直",
    "笜": "竹",
    "阞": "乐",
    "褵": "离",
    "倈": "来",
    "墱": "凳",
    "侾": "消",
    "躦": "搓",
    "詼": "灰",
    "妢": "坟",
    "薂": "习",
    "酦": "破",
    "葖": "突",
    "藸": "除",
    "腏": "绰",
    "謞": "贺",
    "茋": "指",
    "鋀": "偷",
    "渳": "米",
    "絭": "倦",
    "棦": "称",
    "蚗": "觉",
    "寴": "亲",
    "茡": "字",
    "觻": "利",
    "轖": "色",
    "椺": "习",
    "鰉": "黄",
    "捼": "弱",
    "鷰": "燕",
    "鈙": "琴",
    "偺": "杂",
    "枆": "毛",
    "堳": "梅",
    "癤": "接",
    "坺": "拔",
    "珢": "银",
    "涾": "踏",
    "縸": "木",
    "籸": "深",
    "瓓": "烂",
    "籭": "思",
    "婮": "居",
    "嚳": "裤",
    "爂": "标",
    "茣": "无",
    "鍡": "伟",
    "屳": "先",
    "譱": "善",
    "瀻": "带",
    "匇": "意",
    "峜": "记",
    "鮢": "朱",
    "睰": "骂",
    "憖": "印",
    "蟭": "教",
    "斞": "雨",
    "緓": "应",
    "菬": "桥",
    "嶣": "教",
    "櫰": "怀",
    "鵶": "呀",
    "柣": "至",
    "笿": "落",
    "韉": "间",
    "銾": "红",
    "眐": "睁",
    "撜": "整",
    "鮦": "同",
    "黳": "一",
    "櫕": "攒",
    "趂": "衬",
    "鎦": "刘",
    "蚹": "父",
    "痑": "贪",
    "枑": "互",
    "屷": "会",
    "芆": "拆",
    "樍": "则",
    "酕": "毛",
    "臮": "记",
    "魗": "丑",
    "騠": "提",
    "柗": "松",
    "塠": "堆",
    "摗": "搜",
    "劀": "瓜",
    "祩": "助",
    "鞼": "贵",
    "菄": "东",
    "撁": "前",
    "礝": "软",
    "啽": "岸",
    "鳬": "辅",
    "蘓": "苏",
    "窷": "料",
    "薻": "早",
    "閄": "或",
    "恘": "秋",
    "舚": "天",
    "墋": "尘",
    "湗": "奉",
    "圶": "恰",
    "幐": "腾",
    "虭": "雕",
    "邞": "夫",
    "霚": "物",
    "睩": "路",
    "鴔": "福",
    "橧": "增",
    "趈": "占",
    "餲": "爱",
    "鍆": "门",
    "錿": "虎",
    "惿": "提",
    "菆": "邹",
    "辥": "靴",
    "僶": "敏",
    "蔞": "楼",
    "嬙": "强",
    "譊": "脑",
    "畽": "吞",
    "絖": "矿",
    "蛈": "铁",
    "嘾": "蛋",
    "陓": "迂",
    "衁": "荒",
    "玽": "狗",
    "鰗": "胡",
    "禨": "机",
    "杘": "赤",
    "洠": "谋",
    "熗": "呛",
    "慔": "木",
    "檶": "前",
    "凟": "毒",
    "墷": "夜",
    "瞦": "西",
    "豞": "后",
    "稡": "最",
    "馻": "允",
    "郥": "被",
    "迶": "右",
    "怶": "必",
    "荓": "平",
    "饂": "温",
    "兾": "记",
    "墯": "堕",
    "徾": "梅",
    "靏": "贺",
    "緮": "父",
    "蟦": "肥",
    "龝": "秋",
    "槧": "欠",
    "瓍": "随",
    "鋻": "见",
    "夝": "情",
    "鯩": "伦",
    "剙": "创",
    "匳": "连",
    "傊": "运",
    "櫡": "着",
    "簝": "聊",
    "蟶": "称",
    "湷": "装",
    "薿": "你",
    "膲": "教",
    "矒": "盟",
    "鏕": "路",
    "鼟": "腾",
    "倿": "宁",
    "鈖": "分",
    "嚹": "啦",
    "姕": "姿",
    "炗": "光",
    "鞳": "踏",
    "杴": "先",
    "煓": "团",
    "傮": "糟",
    "璗": "荡",
    "艩": "其",
    "靱": "任",
    "拹": "鞋",
    "饜": "燕",
    "赯": "唐",
    "訨": "指",
    "霺": "维",
    "菕": "伦",
    "葠": "深",
    "祰": "告",
    "徲": "提",
    "怢": "突",
    "忯": "其",
    "蚈": "前",
    "飀": "刘",
    "剴": "凯",
    "檖": "岁",
    "呄": "格",
    "襘": "贵",
    "裋": "树",
    "顡": "外",
    "靋": "利",
    "蛕": "回",
    "刡": "敏",
    "黮": "胆",
    "齞": "眼",
    "偫": "至",
    "烳": "普",
    "畃": "寻",
    "怉": "宝",
    "挬": "博",
    "皽": "招",
    "逷": "替",
    "劗": "减",
    "萐": "煞",
    "鶆": "来",
    "穭": "旅",
    "乯": "呼",
    "嫓": "屁",
    "竁": "翠",
    "朄": "引",
    "睯": "昏",
    "蕁": "钱",
    "齭": "楚",
    "荎": "持",
    "憸": "先",
    "盰": "干",
    "棜": "玉",
    "壨": "雷",
    "縶": "直",
    "轌": "雪",
    "轔": "林",
    "騱": "习",
    "瀫": "胡",
    "嵞": "图",
    "踒": "窝",
    "榓": "密",
    "焻": "唱",
    "蝳": "毒",
    "穱": "捉",
    "鴋": "方",
    "袩": "哲",
    "猼": "博",
    "秥": "年",
    "簼": "勾",
    "絿": "求",
    "餀": "害",
    "樲": "二",
    "澓": "福",
    "猲": "些",
    "奙": "本",
    "旾": "春",
    "鬹": "归",
    "胟": "母",
    "貤": "宜",
    "菾": "田",
    "蓲": "秋",
    "耮": "烙",
    "蜪": "桃",
    "嶦": "占",
    "漞": "密",
    "顢": "瞒",
    "洡": "泪",
    "攄": "书",
    "岻": "持",
    "疶": "靴",
    "鍰": "环",
    "陊": "堕",
    "篅": "传",
    "嬥": "挑",
    "詅": "零",
    "寈": "青",
    "韟": "高",
    "渮": "和",
    "岰": "奥",
    "栮": "耳",
    "獋": "豪",
    "焂": "书",
    "屘": "满",
    "窔": "要",
    "鉧": "母",
    "楍": "本",
    "藙": "意",
    "鉩": "洗",
    "髾": "烧",
    "慽": "七",
    "硦": "落",
    "媕": "安",
    "韏": "劝",
    "蹛": "带",
    "秅": "茶",
    "鉳": "北",
    "竬": "曲",
    "濦": "引",
    "齔": "衬",
    "呍": "轰",
    "燸": "如",
    "氠": "深",
    "唩": "窝",
    "湠": "探",
    "胒": "逆",
    "爉": "蜡",
    "譣": "显",
    "寪": "伟",
    "嶕": "教",
    "淾": "引",
    "荱": "伟",
    "礩": "至",
    "坅": "寝",
    "篍": "秋",
    "厗": "提",
    "穼": "深",
    "齯": "尼",
    "傯": "总",
    "賏": "应",
    "攅": "赞",
    "曧": "容",
    "郩": "肖",
    "矊": "眠",
    "頥": "宜",
    "搳": "华",
    "簜": "荡",
    "騤": "奎",
    "諵": "南",
    "鞈": "格",
    "邔": "起",
    "忂": "取",
    "荾": "虽",
    "藽": "亲",
    "粀": "帐",
    "婟": "互",
    "濲": "古",
    "茮": "教",
    "鶬": "仓",
    "齰": "则",
    "嶪": "夜",
    "懹": "让",
    "迾": "裂",
    "劰": "墨",
    "歂": "喘",
    "滖": "虽",
    "鼲": "魂",
    "騉": "昆",
    "皶": "扎",
    "姂": "罚",
    "鋲": "冰",
    "淧": "密",
    "鰳": "乐",
    "焬": "西",
    "鐌": "向",
    "癐": "贵",
    "麏": "君",
    "濧": "对",
    "癙": "鼠",
    "斏": "狼",
    "篻": "漂",
    "躆": "巨",
    "汑": "拖",
    "婰": "点",
    "嘄": "教",
    "捛": "旅",
    "挧": "雨",
    "抩": "南",
    "髥": "然",
    "揇": "男",
    "桇": "如",
    "蠿": "捉",
    "蹜": "速",
    "櫐": "垒",
    "闒": "踏",
    "堈": "刚",
    "霿": "盟",
    "憕": "成",
    "枖": "邀",
    "輠": "果",
    "蓒": "宣",
    "鄪": "必",
    "蕀": "极",
    "岶": "破",
    "蹵": "促",
    "痆": "聂",
    "嵺": "聊",
    "礔": "批",
    "雡": "六",
    "膸": "髓",
    "枎": "福",
    "滱": "扣",
    "凓": "利",
    "婩": "按",
    "耈": "狗",
    "緀": "七",
    "蝺": "曲",
    "鍭": "喉",
    "傡": "病",
    "蝏": "停",
    "鯃": "无",
    "襮": "博",
    "譅": "色",
    "麫": "面",
    "狚": "蛋",
    "綕": "知",
    "鉃": "是",
    "櫽": "引",
    "嫛": "一",
    "孾": "应",
    "厴": "眼",
    "嗿": "坦",
    "蔁": "张",
    "鵮": "前",
    "偯": "以",
    "豯": "西",
    "敄": "物",
    "綩": "碗",
    "扏": "求",
    "攦": "利",
    "獝": "续",
    "刾": "次",
    "鸼": "周",
    "朰": "木",
    "潐": "教",
    "頇": "憨",
    "娙": "行",
    "犚": "位",
    "孍": "颜",
    "椢": "贵",
    "襀": "机",
    "姲": "燕",
    "扻": "至",
    "媉": "卧",
    "裿": "以",
    "悁": "冤",
    "嶡": "贵",
    "衚": "胡",
    "翄": "赤",
    "麮": "去",
    "漋": "龙",
    "羾": "共",
    "罸": "罚",
    "醦": "尘",
    "蝁": "恶",
    "鬦": "豆",
    "擪": "夜",
    "鎍": "锁",
    "喍": "柴",
    "蚅": "恶",
    "鞢": "谢",
    "鰛": "温",
    "扨": "任",
    "昈": "互",
    "憊": "被",
    "梻": "佛",
    "靝": "天",
    "褅": "替",
    "簴": "巨",
    "齴": "眼",
    "軄": "直",
    "郂": "该",
    "庴": "极",
    "嶞": "堕",
    "柡": "永",
    "恈": "谋",
    "栙": "翔",
    "濽": "赞",
    "梫": "寝",
    "烓": "微",
    "鷫": "速",
    "稺": "至",
    "媆": "软",
    "艒": "木",
    "甎": "专",
    "鮊": "爸",
    "鈃": "行",
    "骽": "腿",
    "淕": "路",
    "犓": "除",
    "菙": "垂",
    "葟": "黄",
    "鶛": "接",
    "啎": "五",
    "奛": "谎",
    "轜": "而",
    "帎": "蛋",
    "莭": "节",
    "蘜": "局",
    "逿": "荡",
    "怭": "必",
    "栶": "因",
    "僫": "恶",
    "蓃": "搜",
    "幦": "密",
    "盭": "利",
    "榡": "速",
    "韛": "败",
    "鴐": "歌",
    "釾": "爷",
    "幍": "掏",
    "憱": "促",
    "吰": "红",
    "橔": "蹲",
    "輘": "棱",
    "珡": "琴",
    "篏": "欠",
    "蝩": "虫",
    "騞": "霍",
    "飺": "瓷",
    "砪": "母",
    "嗊": "红",
    "縨": "谎",
    "暓": "帽",
    "僓": "腿",
    "瘹": "掉",
    "懀": "位",
    "夃": "古",
    "鰄": "微",
    "勆": "狼",
    "惏": "蓝",
    "笧": "册",
    "枦": "芦",
    "匷": "觉",
    "梐": "必",
    "誀": "二",
    "垗": "照",
    "壔": "导",
    "鍄": "亮",
    "帞": "墨",
    "肐": "歌",
    "曔": "静",
    "棳": "捉",
    "恮": "圈",
    "楌": "颜",
    "釅": "燕",
    "櫋": "眠",
    "臇": "卷",
    "屭": "系",
    "嫯": "奥",
    "蓤": "零",
    "陻": "因",
    "拁": "家",
    "羜": "助",
    "膫": "聊",
    "膯": "腾",
    "兣": "李",
    "侙": "吃",
    "曒": "角",
    "粊": "必",
    "襧": "指",
    "籷": "哲",
    "疺": "罚",
    "錝": "宗",
    "猚": "牙",
    "磛": "缠",
    "鉒": "助",
    "棙": "利",
    "螶": "取",
    "峔": "母",
    "熢": "朋",
    "鶼": "间",
    "齗": "银",
    "樧": "沙",
    "駊": "坡",
    "瀌": "标",
    "魰": "文",
    "腟": "赤",
    "蒬": "冤",
    "烿": "容",
    "鱭": "记",
    "湻": "纯",
    "椡": "到",
    "蟕": "嘴",
    "銱": "掉",
    "熩": "互",
    "癳": "裸",
    "娗": "挺",
    "跦": "朱",
    "斦": "银",
    "鬴": "辅",
    "銤": "米",
    "炾": "谎",
    "腢": "偶",
    "琔": "电",
    "螹": "见",
    "貛": "欢",
    "捘": "尊",
    "壜": "谈",
    "篂": "星",
    "柋": "带",
    "鹸": "减",
    "甔": "单",
    "贜": "脏",
    "睂": "梅",
    "雃": "前",
    "宎": "咬",
    "挅": "朵",
    "霦": "彬",
    "蓫": "处",
    "剹": "路",
    "鍂": "偏",
    "瑹": "书",
    "薝": "占",
    "鬄": "敌",
    "鎞": "逼",
    "觛": "蛋",
    "鼱": "精",
    "縓": "全",
    "栍": "生",
    "麊": "迷",
    "髷": "区",
    "訑": "宜",
    "袯": "博",
    "牅": "庸",
    "笚": "答",
    "氝": "内",
    "魀": "尬",
    "輐": "万",
    "趤": "荡",
    "聎": "挑",
    "旝": "快",
    "颾": "搜",
    "豜": "间",
    "孊": "米",
    "鑔": "差",
    "跴": "采",
    "暿": "洗",
    "羍": "达",
    "鼏": "密",
    "噽": "匹",
    "瀭": "书",
    "沯": "杂",
    "懨": "烟",
    "纃": "其",
    "蜵": "冤",
    "袣": "意",
    "箊": "迂",
    "忇": "乐",
    "兞": "毛",
    "蕢": "溃",
    "鰇": "柔",
    "魼": "区",
    "赺": "引",
    "肕": "任",
    "稯": "宗",
    "覯": "够",
    "鄶": "快",
    "綗": "窘",
    "禈": "灰",
    "圠": "亚",
    "轠": "雷",
    "慦": "就",
    "矄": "熏",
    "螇": "西",
    "禓": "羊",
    "瞃": "卧",
    "怋": "民",
    "砊": "康",
    "傐": "号",
    "嚊": "屁",
    "俔": "欠",
    "熂": "系",
    "璯": "会",
    "匞": "降",
    "騅": "追",
    "鯗": "想",
    "堸": "逢",
    "譝": "生",
    "鐼": "坟",
    "湐": "墨",
    "壀": "皮",
    "顖": "信",
    "硣": "消",
    "妕": "重",
    "嗠": "烙",
    "璑": "无",
    "蠸": "全",
    "螙": "度",
    "藊": "扁",
    "珁": "瓷",
    "焇": "消",
    "驣": "腾",
    "豮": "坟",
    "絴": "翔",
    "厬": "鬼",
    "堶": "驮",
    "絥": "福",
    "鄍": "明",
    "煼": "吵",
    "鉵": "同",
    "蔆": "零",
    "捠": "帮",
    "甐": "吝",
    "臖": "性",
    "嬄": "一",
    "傸": "闯",
    "虩": "系",
    "鐯": "着",
    "痻": "民",
    "棅": "饼",
    "攖": "应",
    "槵": "换",
    "蘰": "慢",
    "巑": "攒",
    "繓": "左",
    "饄": "唐",
    "黚": "钱",
    "燓": "坟",
    "恦": "上",
    "僛": "七",
    "絽": "旅",
    "蘱": "泪",
    "榗": "见",
    "愃": "宣",
    "穪": "称",
    "闝": "漂",
    "樝": "扎",
    "衺": "鞋",
    "鑕": "至",
    "蕘": "扰",
    "鱆": "张",
    "酟": "天",
    "鏮": "康",
    "拲": "拱",
    "殎": "恰",
    "櫩": "颜",
    "鬅": "朋",
    "垷": "现",
    "巊": "影",
    "懭": "旷",
    "籄": "溃",
    "疧": "其",
    "郼": "一",
    "祶": "地",
    "諞": "偏",
    "皨": "星",
    "竘": "曲",
    "埱": "处",
    "蜲": "微",
    "轗": "砍",
    "罁": "刚",
    "鰢": "马",
    "糏": "谢",
    "裓": "格",
    "娋": "绍",
    "焀": "胡",
    "睕": "碗",
    "桚": "赞",
    "謪": "伤",
    "鱾": "几",
    "烣": "灰",
    "泋": "会",
    "鋟": "寝",
    "爄": "利",
    "詗": "胸",
    "嬇": "溃",
    "滼": "饭",
    "枈": "必",
    "澙": "系",
    "襫": "是",
    "蟁": "文",
    "蛂": "别",
    "娔": "客",
    "梑": "敌",
    "抋": "亲",
    "赲": "利",
    "秶": "姿",
    "霡": "卖",
    "潌": "至",
    "幁": "需",
    "貣": "特",
    "蟱": "无",
    "鰷": "条",
    "綂": "统",
    "蜛": "居",
    "蒒": "诗",
    "遟": "持",
    "瘄": "促",
    "畁": "必",
    "馦": "先",
    "髴": "福",
    "塉": "极",
    "銋": "人",
    "旔": "见",
    "糓": "古",
    "蔩": "银",
    "罋": "瓮",
    "梮": "居",
    "纑": "芦",
    "恡": "吝",
    "鑩": "恶",
    "薎": "灭",
    "麬": "夫",
    "奯": "或",
    "蝑": "需",
    "崸": "羊",
    "愻": "训",
    "鱩": "雷",
    "螿": "将",
    "蠒": "减",
    "娨": "现",
    "籉": "台",
    "灳": "灰",
    "唨": "组",
    "媶": "容",
    "摨": "奶",
    "稏": "亚",
    "稦": "一",
    "醘": "科",
    "嵤": "容",
    "丳": "铲",
    "駜": "必",
    "犐": "科",
    "硜": "坑",
    "詚": "达",
    "搹": "恶",
    "鍈": "应",
    "蔃": "强",
    "悡": "离",
    "赹": "穷",
    "蒮": "玉",
    "兓": "金",
    "齅": "秀",
    "懅": "巨",
    "崵": "羊",
    "歖": "洗",
    "齼": "楚",
    "慞": "张",
    "忶": "魂",
    "鼁": "去",
    "礆": "减",
    "鵄": "吃",
    "鸘": "双",
    "瓡": "直",
    "簐": "年",
    "雦": "极",
    "嘋": "笑",
    "睻": "宣",
    "緐": "烦",
    "菤": "卷",
    "鸐": "敌",
    "鮏": "星",
    "岝": "做",
    "酻": "最",
    "汄": "责",
    "觟": "话",
    "謧": "离",
    "瀤": "怀",
    "屶": "会",
    "覴": "灯",
    "朆": "分",
    "詯": "会",
    "矔": "灌",
    "觡": "格",
    "莍": "求",
    "橗": "盟",
    "甋": "地",
    "隥": "凳",
    "篲": "会",
    "漌": "紧",
    "蘬": "亏",
    "獫": "显",
    "囆": "拆",
    "姡": "华",
    "橰": "高",
    "崜": "多",
    "鸏": "盟",
    "婝": "电",
    "砄": "觉",
    "菐": "葡",
    "麚": "家",
    "緰": "头",
    "黺": "粉",
    "鞂": "接",
    "刉": "机",
    "餻": "高",
    "婋": "消",
    "蠌": "则",
    "遬": "速",
    "鮿": "哲",
    "搻": "诺",
    "烻": "燕",
    "瑖": "断",
    "紿": "带",
    "澺": "意",
    "殟": "温",
    "舧": "烦",
    "夳": "太",
    "嬠": "参",
    "腜": "梅",
    "鯬": "离",
    "鏚": "七",
    "譃": "需",
    "鷩": "必",
    "嵷": "耸",
    "漜": "也",
    "篹": "赚",
    "盓": "迂",
    "摓": "逢",
    "仢": "博",
    "藮": "桥",
    "紼": "福",
    "錴": "路",
    "腀": "伦",
    "賩": "从",
    "縤": "速",
    "癓": "维",
    "篣": "朋",
    "坁": "指",
    "匢": "呼",
    "薘": "达",
    "輨": "管",
    "佅": "卖",
    "饁": "夜",
    "隑": "概",
    "壍": "欠",
    "鷴": "闲",
    "斣": "豆",
    "襥": "福",
    "鬌": "妥",
    "熚": "必",
    "孏": "懒",
    "咠": "气",
    "鶨": "串",
    "捵": "陈",
    "胉": "博",
    "娳": "利",
    "濴": "营",
    "秇": "意",
    "鵉": "鸾",
    "柪": "凹",
    "熞": "间",
    "磄": "唐",
    "剬": "端",
    "恾": "忙",
    "伌": "爱",
    "橮": "柳",
    "髺": "扩",
    "藗": "速",
    "儝": "穷",
    "軷": "拔",
    "鷿": "屁",
    "鯭": "猛",
    "灟": "竹",
    "懁": "宣",
    "譗": "炸",
    "嗃": "贺",
    "顈": "选",
    "棾": "情",
    "笐": "行",
    "陎": "书",
    "譆": "西",
    "爤": "烂",
    "遤": "马",
    "跥": "堕",
    "豩": "彬",
    "絧": "动",
    "榰": "知",
    "磃": "思",
    "黰": "枕",
    "鎜": "盘",
    "啠": "哲",
    "櫳": "龙",
    "拪": "前",
    "嫞": "庸",
    "鷬": "黄",
    "陚": "父",
    "毼": "和",
    "瑌": "软",
    "鞸": "必",
    "憅": "痛",
    "榩": "钱",
    "鰁": "全",
    "酼": "海",
    "袘": "宜",
    "輢": "以",
    "颽": "凯",
    "峅": "变",
    "佨": "包",
    "鲯": "其",
    "荕": "金",
    "覸": "间",
    "韔": "唱",
    "圱": "前",
    "縏": "盘",
    "黣": "美",
    "牭": "四",
    "霢": "卖",
    "澃": "窘",
    "鴙": "至",
    "紖": "镇",
    "菨": "接",
    "駻": "汉",
    "鯆": "铺",
    "痀": "居",
    "壿": "尊",
    "羳": "烦",
    "訬": "超",
    "朼": "比",
    "猍": "来",
    "硧": "永",
    "蒦": "或",
    "怘": "互",
    "灱": "消",
    "蠺": "残",
    "醊": "缀",
    "鰒": "父",
    "玀": "罗",
    "歈": "鱼",
    "綛": "忍",
    "媝": "秋",
    "胑": "知",
    "躿": "康",
    "埪": "空",
    "寠": "巨",
    "罻": "位",
    "樔": "朝",
    "釢": "奶",
    "逩": "笨",
    "悞": "物",
    "琙": "玉",
    "騐": "燕",
    "悐": "替",
    "厒": "妾",
    "矘": "躺",
    "嚘": "优",
    "醧": "玉",
    "宐": "宜",
    "碒": "银",
    "塺": "梅",
    "寁": "赞",
    "屗": "伟",
    "猣": "宗",
    "嵑": "可",
    "饝": "魔",
    "鴢": "咬",
    "睼": "天",
    "髞": "懆",
    "鮐": "台",
    "礣": "骂",
    "裺": "眼",
    "鲘": "后",
    "糦": "西",
    "趓": "朵",
    "萷": "消",
    "廗": "带",
    "鑅": "横",
    "矀": "梅",
    "鲬": "永",
    "鸁": "罗",
    "笝": "那",
    "劊": "贵",
    "龞": "憋",
    "渽": "灾",
    "乑": "银",
    "翢": "到",
    "蕿": "宣",
    "栣": "忍",
    "狾": "至",
    "鞐": "恰",
    "馼": "文",
    "壐": "洗",
    "攛": "窜",
    "簚": "密",
    "蟯": "脑",
    "佦": "诗",
    "淣": "尼",
    "桬": "沙",
    "毃": "敲",
    "狑": "零",
    "櫭": "节",
    "觠": "全",
    "嵲": "聂",
    "搼": "全",
    "蚐": "君",
    "薴": "凝",
    "旊": "访",
    "鸎": "应",
    "聁": "判",
    "胢": "科",
    "瘇": "种",
    "陹": "生",
    "檼": "印",
    "鏺": "坡",
    "躟": "嚷",
    "齚": "则",
    "軹": "指",
    "澠": "免",
    "豥": "该",
    "嫥": "专",
    "匰": "单",
    "烶": "挺",
    "泧": "萨",
    "疨": "虾",
    "匭": "鬼",
    "忩": "聪",
    "柮": "堕",
    "髩": "宾",
    "弣": "辅",
    "澯": "灿",
    "頟": "额",
    "貜": "觉",
    "躚": "先",
    "漊": "楼",
    "渒": "派",
    "澾": "踏",
    "盙": "辅",
    "蒤": "图",
    "鴥": "玉",
    "胿": "归",
    "褽": "位",
    "敥": "燕",
    "郖": "豆",
    "鷽": "学",
    "騍": "客",
    "鍴": "端",
    "樜": "这",
    "鼄": "朱",
    "霱": "玉",
    "乫": "家",
    "騕": "咬",
    "躽": "眼",
    "蹡": "枪",
    "尦": "料",
    "癕": "庸",
    "砤": "驮",
    "勽": "报",
    "碮": "提",
    "瓽": "荡",
    "凂": "美",
    "轑": "老",
    "臢": "匝",
    "煫": "岁",
    "蔇": "记",
    "諼": "宣",
    "菦": "琴",
    "僒": "窘",
    "倄": "摇",
    "羐": "有",
    "癋": "贺",
    "蚥": "父",
    "譾": "减",
    "糫": "环",
    "冔": "许",
    "飪": "任",
    "蚢": "行",
    "凬": "风",
    "蜫": "昆",
    "湽": "姿",
    "靰": "物",
    "翶": "敖",
    "騴": "燕",
    "葓": "红",
    "扄": "赏",
    "纼": "镇",
    "隮": "机",
    "榽": "西",
    "刟": "雕",
    "嶍": "习",
    "櫔": "利",
    "鼚": "昌",
    "鎟": "桑",
    "匫": "呼",
    "韱": "先",
    "翤": "赤",
    "髨": "昆",
    "稨": "扁",
    "浶": "劳",
    "癊": "印",
    "幮": "除",
    "繨": "哒",
    "靊": "风",
    "肦": "坟",
    "蟃": "万",
    "跇": "意",
    "悿": "舔",
    "墥": "懂",
    "疿": "费",
    "欛": "爸",
    "馾": "蛋",
    "轚": "极",
    "鄽": "缠",
    "藈": "奎",
    "睉": "搓",
    "鷀": "瓷",
    "庎": "借",
    "糪": "薄",
    "鯫": "邹",
    "裦": "否",
    "蕦": "需",
    "蝃": "地",
    "屫": "觉",
    "窹": "物",
    "恱": "月",
    "碆": "波",
    "宖": "红",
    "貾": "持",
    "匟": "抗",
    "譹": "豪",
    "鈨": "原",
    "鋞": "行",
    "魐": "干",
    "鷋": "图",
    "趹": "觉",
    "膔": "路",
    "匵": "毒",
    "痐": "回",
    "硨": "车",
    "娂": "红",
    "塪": "砍",
    "縰": "洗",
    "粴": "李",
    "冟": "是",
    "鏏": "位",
    "誳": "区",
    "鶊": "耕",
    "鵭": "琴",
    "浝": "忙",
    "愡": "总",
    "錣": "缀",
    "閐": "散",
    "孲": "呀",
    "簘": "消",
    "倃": "就",
    "磣": "尘",
    "弮": "圈",
    "摾": "降",
    "炃": "坟",
    "曣": "燕",
    "彠": "约",
    "擖": "咖",
    "藚": "续",
    "怓": "脑",
    "豏": "现",
    "赨": "同",
    "尮": "堕",
    "熑": "连",
    "覞": "要",
    "顇": "翠",
    "釶": "诗",
    "劮": "意",
    "鶁": "精",
    "鞗": "条",
    "籞": "玉",
    "暡": "瓮",
    "烄": "角",
    "跿": "图",
    "籎": "宜",
    "釓": "求",
    "堄": "逆",
    "靎": "贺",
    "餖": "豆",
    "圲": "前",
    "髐": "消",
    "虈": "消",
    "薭": "败",
    "璙": "聊",
    "辴": "铲",
    "毾": "踏",
    "漵": "续",
    "矆": "或",
    "轊": "位",
    "敟": "点",
    "裖": "枕",
    "熉": "云",
    "呞": "诗",
    "鏰": "甭",
    "婸": "荡",
    "忁": "报",
    "荴": "夫",
    "鰸": "区",
    "瞝": "吃",
    "蚷": "巨",
    "鸤": "诗",
    "糘": "家",
    "萀": "虎",
    "薼": "陈",
    "揯": "根",
    "椉": "成",
    "艢": "强",
    "凚": "进",
    "搃": "总",
    "炇": "铺",
    "磼": "杂",
    "癗": "垒",
    "岟": "养",
    "矐": "或",
    "譂": "铲",
    "軧": "底",
    "倹": "减",
    "涱": "帐",
    "醝": "搓",
    "姭": "现",
    "焋": "壮",
    "褷": "诗",
    "怲": "饼",
    "顟": "劳",
    "酨": "在",
    "鈟": "掉",
    "抾": "区",
    "捦": "琴",
    "餺": "博",
    "腁": "偏",
    "篳": "必",
    "乴": "学",
    "尲": "干",
    "弴": "雕",
    "柨": "不",
    "眓": "或",
    "繗": "林",
    "鬩": "系",
    "欇": "设",
    "蜰": "肥",
    "豣": "间",
    "騬": "成",
    "砶": "破",
    "醼": "燕",
    "毄": "机",
    "裲": "两",
    "蠠": "敏",
    "鄎": "西",
    "鵸": "其",
    "寣": "呼",
    "鑤": "报",
    "戼": "帽",
    "蛅": "占",
    "攩": "挡",
    "礥": "闲",
    "黂": "坟",
    "篕": "和",
    "杤": "万",
    "璌": "银",
    "媍": "父",
    "僋": "探",
    "岴": "区",
    "薥": "鼠",
    "麙": "闲",
    "鷮": "教",
    "埦": "碗",
    "湱": "或",
    "啳": "全",
    "騀": "饿",
    "禶": "赞",
    "鐈": "桥",
    "艫": "芦",
    "扝": "哭",
    "椨": "辅",
    "摤": "闯",
    "抸": "家",
    "溕": "盟",
    "遻": "恶",
    "蔪": "见",
    "皼": "古",
    "俖": "培",
    "禞": "告",
    "恄": "系",
    "蔱": "沙",
    "鞝": "上",
    "爈": "绿",
    "遱": "楼",
    "鞛": "崩",
    "疓": "奶",
    "篬": "枪",
    "櫁": "密",
    "鼛": "高",
    "腅": "蛋",
    "鶢": "原",
    "憻": "坦",
    "熎": "要",
    "萾": "营",
    "昗": "责",
    "饡": "赞",
    "蔤": "密",
    "諣": "话",
    "邷": "瓦",
    "鎇": "梅",
    "癚": "蛋",
    "衃": "培",
    "俲": "笑",
    "菣": "亲",
    "忨": "万",
    "駰": "因",
    "岉": "物",
    "窚": "成",
    "槥": "会",
    "僨": "愤",
    "猦": "风",
    "栜": "色",
    "萲": "宣",
    "孂": "角",
    "趰": "耳",
    "曋": "审",
    "酁": "缠",
    "霒": "因",
    "埣": "岁",
    "跁": "爸",
    "歕": "喷",
    "伂": "配",
    "遦": "灌",
    "馧": "晕",
    "刢": "零",
    "扗": "在",
    "鄟": "专",
    "鲝": "眨",
    "疜": "下",
    "鸙": "月",
    "勓": "开",
    "朖": "浪",
    "譛": "怎",
    "鶱": "先",
    "騯": "朋",
    "枽": "夜",
    "鐂": "刘",
    "鰜": "欠",
    "孁": "零",
    "鄝": "了",
    "鼅": "知",
    "耫": "炸",
    "閷": "筛",
    "嵠": "西",
    "弰": "烧",
    "鷕": "咬",
    "囒": "蓝",
    "罜": "主",
    "磩": "气",
    "瑘": "牙",
    "鳁": "温",
    "鱴": "灭",
    "鰀": "换",
    "摌": "铲",
    "瓪": "板",
    "睔": "滚",
    "訜": "分",
    "恲": "砰",
    "閜": "下",
    "瞲": "续",
    "牔": "博",
    "徣": "借",
    "岎": "坟",
    "騟": "鱼",
    "紽": "驮",
    "臡": "尼",
    "菮": "耕",
    "岪": "福",
    "繺": "筛",
    "趧": "提",
    "揢": "咳",
    "鯘": "内",
    "黇": "天",
    "乽": "者",
    "糽": "整",
    "屖": "西",
    "輏": "由",
    "輇": "全",
    "憽": "松",
    "寱": "意",
    "稸": "续",
    "檥": "以",
    "呹": "意",
    "亃": "吝",
    "雸": "岸",
    "鮆": "此",
    "渵": "毛",
    "媇": "亲",
    "駦": "腾",
    "睴": "滚",
    "趎": "除",
    "坙": "精",
    "郠": "梗",
    "魦": "沙",
    "簎": "册",
    "讈": "利",
    "郒": "狼",
    "犞": "桥",
    "鋎": "汉",
    "躠": "洒",
    "鼸": "现",
    "蘁": "物",
    "迃": "迂",
    "盷": "田",
    "霃": "陈",
    "齫": "允",
    "榢": "驾",
    "磍": "侠",
    "鼊": "必",
    "翈": "侠",
    "轙": "以",
    "蜭": "汉",
    "怇": "巨",
    "鉌": "和",
    "幭": "灭",
    "鯇": "换",
    "藘": "驴",
    "焆": "捐",
    "悂": "批",
    "熓": "五",
    "鷳": "闲",
    "薐": "棱",
    "萶": "春",
    "霵": "极",
    "懻": "记",
    "翷": "林",
    "濣": "卧",
    "溗": "成",
    "韼": "朋",
    "蕄": "盟",
    "乮": "帽",
    "鱖": "贵",
    "撀": "够",
    "鰅": "鱼",
    "峲": "李",
    "峑": "圈",
    "貃": "墨",
    "靻": "组",
    "峺": "梗",
    "螥": "仓",
    "鰊": "练",
    "妵": "偷",
    "侲": "镇",
    "穮": "标",
    "鰟": "房",
    "涹": "窝",
    "禭": "岁",
    "傰": "崩",
    "緧": "秋",
    "倇": "碗",
    "嵀": "助",
    "奦": "物",
    "槏": "浅",
    "圦": "快",
    "瀔": "古",
    "肻": "肯",
    "肬": "由",
    "嵍": "物",
    "獼": "迷",
    "牑": "编",
    "戫": "玉",
    "葐": "盆",
    "鶺": "极",
    "鏬": "下",
    "岯": "皮",
    "揓": "是",
    "揘": "庸",
    "坸": "够",
    "櫖": "绿",
    "驦": "双",
    "闟": "系",
    "懚": "印",
    "薧": "蒿",
    "崷": "求",
    "懪": "博",
    "瘣": "会",
    "嵻": "康",
    "茙": "容",
    "霠": "因",
    "齹": "刺",
    "僀": "地",
    "鷨": "华",
    "鸗": "龙",
    "軓": "饭",
    "欚": "李",
    "嶟": "尊",
    "燷": "蓝",
    "鮣": "印",
    "閯": "煞",
    "罊": "气",
    "涀": "现",
    "畂": "六",
    "鋫": "离",
    "讕": "蓝",
    "蓕": "贵",
    "蟖": "思",
    "鱰": "鼠",
    "傏": "唐",
    "怐": "巨",
    "釄": "迷",
    "褠": "勾",
    "狜": "苦",
    "璻": "嘴",
    "訅": "求",
    "垐": "瓷",
    "徸": "冲",
    "鏒": "三",
    "譡": "挡",
    "齩": "咬",
    "劶": "口",
    "堮": "恶",
    "肗": "乳",
    "餣": "夜",
    "膒": "欧",
    "睅": "汉",
    "蚽": "皮",
    "歍": "乌",
    "匎": "恶",
    "螜": "胡",
    "癪": "机",
    "坖": "记",
    "勈": "永",
    "稶": "玉",
    "臤": "前",
    "鋊": "玉",
    "劺": "谋",
    "濢": "翠",
    "贌": "葡",
    "靽": "办",
    "矹": "物",
    "篎": "秒",
    "雤": "学",
    "斀": "着",
    "犣": "裂",
    "蔏": "伤",
    "閇": "必",
    "駴": "害",
    "媰": "除",
    "揬": "图",
    "唘": "起",
    "韎": "妹",
    "孉": "全",
    "礕": "批",
    "鶅": "姿",
    "熡": "楼",
    "騢": "侠",
    "礃": "长",
    "艞": "要",
    "蒚": "利",
    "椧": "命",
    "鶝": "福",
    "矤": "审",
    "豠": "除",
    "虆": "雷",
    "蓩": "帽",
    "帩": "巧",
    "嚀": "凝",
    "迿": "训",
    "歫": "巨",
    "鵕": "俊",
    "擉": "绰",
    "傼": "汉",
    "嵸": "宗",
    "梚": "碗",
    "腖": "动",
    "畆": "母",
    "蚠": "坟",
    "溮": "诗",
    "嫅": "接",
    "锧": "至",
    "饏": "蛋",
    "鬕": "骂",
    "熐": "密",
    "骿": "偏",
    "殝": "真",
    "帠": "意",
    "奲": "朵",
    "誂": "挑",
    "葘": "姿",
    "阫": "培",
    "劎": "见",
    "蟔": "墨",
    "梍": "造",
    "攎": "芦",
    "軴": "助",
    "篟": "欠",
    "稵": "姿",
    "鈝": "银",
    "轛": "缀",
    "埉": "家",
    "樴": "直",
    "檧": "松",
    "蛬": "穷",
    "齳": "允",
    "銢": "匹",
    "趲": "赞",
    "鑯": "间",
    "嵢": "仓",
    "撍": "赞",
    "鶟": "图",
    "刞": "去",
    "椳": "微",
    "惵": "叠",
    "竨": "掉",
    "韹": "黄",
    "螤": "中",
    "鸔": "捕",
    "唺": "舔",
    "螌": "班",
    "繥": "西",
    "蝘": "眼",
    "烍": "显",
    "軱": "姑",
    "馣": "安",
    "鳈": "全",
    "髗": "芦",
    "耉": "狗",
    "緶": "变",
    "孇": "双",
    "囏": "间",
    "犑": "局",
    "幯": "节",
    "墹": "见",
    "鄇": "喉",
    "痎": "接",
    "覶": "罗",
    "憹": "脑",
    "嶫": "夜",
    "巏": "全",
    "嘃": "冲",
    "軺": "摇",
    "櫿": "营",
    "嚃": "他",
    "烑": "摇",
    "鮵": "夺",
    "濿": "利",
    "嶑": "向",
    "錺": "方",
    "翍": "批",
    "蘛": "鱼",
    "櫊": "格",
    "橤": "瑞",
    "篒": "诗",
    "鐴": "必",
    "刔": "觉",
    "鶞": "春",
    "炧": "谢",
    "臱": "眠",
    "嶻": "节",
    "肣": "含",
    "蒊": "花",
    "蘾": "坏",
    "蟸": "李",
    "飁": "习",
    "韸": "朋",
    "馛": "博",
    "睧": "昏",
    "擶": "见",
    "憛": "谈",
    "蓻": "姿",
    "鶗": "提",
    "菒": "搞",
    "摦": "话",
    "嶘": "战",
    "桍": "哭",
    "捤": "伟",
    "臲": "聂",
    "觼": "觉",
    "鶔": "柔",
    "蓞": "蛋",
    "耚": "批",
    "慪": "欧",
    "犔": "系",
    "譀": "汉",
    "蠑": "容",
    "觗": "至",
    "沠": "刘",
    "瞕": "帐",
    "蘮": "记",
    "鬸": "六",
    "鈄": "抖",
    "紣": "翠",
    "酑": "鱼",
    "稢": "玉",
    "鼺": "雷",
    "肔": "尺",
    "鎑": "夜",
    "爘": "参",
    "鱏": "寻",
    "蠨": "消",
    "趬": "敲",
    "憵": "批",
    "岾": "汉",
    "躕": "除",
    "帒": "带",
    "灎": "燕",
    "輀": "而",
    "憆": "称",
    "爒": "了",
    "塖": "成",
    "鳠": "互",
    "蛪": "妾",
    "鵔": "俊",
    "嵼": "铲",
    "踀": "处",
    "麜": "利",
    "驆": "必",
    "蜄": "肾",
    "帬": "群",
    "殐": "速",
    "袦": "那",
    "餯": "会",
    "傹": "静",
    "桰": "扩",
    "蛵": "星",
    "椕": "彬",
    "絍": "任",
    "捹": "笨",
    "遌": "恶",
    "噄": "吃",
    "禉": "有",
    "巤": "裂",
    "傽": "张",
    "鋾": "桃",
    "蔈": "标",
    "鐛": "影",
    "瓐": "芦",
    "罦": "福",
    "藶": "利",
    "逜": "物",
    "頺": "推",
    "孄": "懒",
    "箁": "剖",
    "蹎": "颠",
    "黕": "胆",
    "霮": "蛋",
    "錭": "桃",
    "邩": "火",
    "舏": "久",
    "黲": "惨",
    "懴": "颤",
    "欼": "尺",
    "霴": "带",
    "孮": "从",
    "賘": "脏",
    "鳰": "入",
    "灻": "赤",
    "陗": "巧",
    "帡": "平",
    "竲": "层",
    "駖": "零",
    "鵨": "书",
    "愑": "永",
    "玁": "显",
    "嬎": "饭",
    "馞": "博",
    "蓯": "聪",
    "梬": "影",
    "皹": "君",
    "鈚": "批",
    "餦": "张",
    "鯋": "沙",
    "礖": "玉",
    "匓": "就",
    "襸": "赞",
    "絊": "最",
    "澞": "鱼",
    "靗": "称",
    "纅": "要",
    "蔊": "罕",
    "黬": "颜",
    "甼": "挺",
    "蕂": "胜",
    "虸": "子",
    "鶜": "毛",
    "杊": "寻",
    "奝": "雕",
    "恑": "鬼",
    "腡": "罗",
    "罼": "必",
    "塃": "荒",
    "潷": "必",
    "灹": "咋",
    "躊": "愁",
    "癷": "波",
    "蹳": "波",
    "嶊": "嘴",
    "狕": "咬",
    "癅": "刘",
    "墄": "册",
    "縬": "促",
    "轕": "格",
    "誱": "节",
    "鶶": "唐",
    "軗": "书",
    "殨": "会",
    "鹻": "减",
    "辝": "瓷",
    "剭": "乌",
    "鞤": "帮",
    "攭": "利",
    "杔": "拖",
    "櫢": "搜",
    "瀥": "血",
    "罬": "着",
    "譍": "应",
    "涃": "困",
    "暩": "记",
    "俧": "至",
    "嵹": "降",
    "愇": "伟",
    "毨": "显",
    "黸": "芦",
    "郻": "敲",
    "塕": "瓮",
    "輬": "良",
    "鈆": "前",
    "晑": "想",
    "皗": "愁",
    "昁": "被",
    "艗": "意",
    "殌": "觉",
    "憰": "觉",
    "跈": "年",
    "硆": "恶",
    "柖": "勺",
    "鍸": "胡",
    "栕": "真",
    "覥": "舔",
    "炿": "周",
    "皏": "捧",
    "爡": "撤",
    "釃": "筛",
    "萟": "意",
    "梌": "图",
    "槯": "催",
    "鎙": "硕",
    "蟨": "觉",
    "蠷": "取",
    "焧": "聪",
    "轏": "战",
    "塶": "路",
    "譥": "教",
    "粭": "和",
    "賿": "聊",
    "瓆": "至",
    "鬵": "琴",
    "稕": "准",
    "罭": "玉",
    "陭": "意",
    "馯": "汉",
    "婽": "假",
    "嘐": "消",
    "餟": "缀",
    "恖": "思",
    "菚": "战",
    "稄": "训",
    "泏": "竹",
    "汷": "中",
    "襒": "别",
    "鰡": "刘",
    "鋔": "碗",
    "撌": "贵",
    "朡": "宗",
    "颪": "瓜",
    "雐": "呼",
    "傶": "族",
    "梕": "任",
    "毰": "培",
    "襣": "必",
    "閍": "崩",
    "騈": "偏",
    "釱": "地",
    "斍": "觉",
    "孎": "竹",
    "碄": "林",
    "檌": "最",
    "嬒": "会",
    "圛": "意",
    "歗": "笑",
    "燫": "连",
    "搎": "孙",
    "扅": "宜",
    "阥": "因",
    "鳂": "微",
    "褺": "跌",
    "檉": "称",
    "瞔": "则",
    "隬": "你",
    "騺": "至",
    "涍": "笑",
    "輄": "光",
    "貑": "家",
    "掝": "或",
    "傓": "善",
    "櫮": "恶",
    "麢": "零",
    "酄": "欢",
    "飶": "必",
    "鎎": "开",
    "峐": "该",
    "盀": "起",
    "廽": "回",
    "鞹": "扩",
    "鷏": "田",
    "驓": "层",
    "禲": "利",
    "蘽": "垒",
    "暥": "燕",
    "衋": "系",
    "鏶": "极",
    "翑": "取",
    "蚛": "重",
    "髸": "工",
    "蘴": "风",
    "蓈": "狼",
    "湈": "梅",
    "怈": "意",
    "鋺": "远",
    "鱐": "速",
    "痥": "夺",
    "譫": "占",
    "櫯": "苏",
    "籜": "拓",
    "庬": "忙",
    "婜": "前",
    "擆": "着",
    "誻": "踏",
    "癑": "弄",
    "骲": "报",
    "茿": "竹",
    "曯": "竹",
    "憘": "洗",
    "稓": "做",
    "媘": "接",
    "邜": "西",
    "氄": "容",
    "蟘": "特",
    "凒": "埃",
    "跀": "月",
    "鮚": "节",
    "轀": "温",
    "勴": "绿",
    "榪": "骂",
    "舥": "趴",
    "蛷": "求",
    "繣": "话",
    "膎": "鞋",
    "骫": "伟",
    "憪": "闲",
    "釽": "屁",
    "颒": "会",
    "窱": "挑",
    "翭": "喉",
    "誗": "缠",
    "灅": "垒",
    "翗": "咳",
    "矋": "垒",
    "箽": "懂",
    "鯟": "东",
    "楑": "奎",
    "墆": "至",
    "賐": "训",
    "蹝": "洗",
    "溣": "论",
    "嚔": "替",
    "襗": "则",
    "蹷": "觉",
    "翿": "到",
    "竩": "意",
    "諽": "格",
    "茦": "次",
    "雿": "掉",
    "瞘": "口",
    "孹": "薄",
    "熌": "闪",
    "剶": "穿",
    "硩": "撤",
    "瀖": "或",
    "妰": "着",
    "濔": "米",
    "芕": "虽",
    "蕍": "鱼",
    "蝹": "晕",
    "裶": "飞",
    "皍": "极",
    "炈": "意",
    "蛢": "平",
    "譄": "增",
    "羵": "坟",
    "穙": "葡",
    "齍": "姿",
    "椩": "耕",
    "軕": "山",
    "杚": "概",
    "匘": "脑",
    "鈛": "锅",
    "髝": "劳",
    "啢": "两",
    "绬": "应",
    "蟅": "这",
    "綨": "其",
    "襼": "意",
    "睭": "肘",
    "浺": "冲",
    "鼮": "停",
    "鏓": "总",
    "鋉": "速",
    "竔": "生",
    "賕": "求",
    "夰": "搞",
    "磢": "闯",
    "菃": "取",
    "轁": "掏",
    "逤": "所",
    "鳒": "间",
    "塸": "欧",
    "棥": "烦",
    "撟": "角",
    "碤": "应",
    "豙": "意",
    "耾": "红",
    "趞": "确",
    "甊": "楼",
    "鎈": "锁",
    "浾": "称",
    "鮜": "后",
    "皳": "求",
    "鱳": "利",
    "咞": "现",
    "轥": "吝",
    "懝": "爱",
    "譸": "周",
    "垼": "意",
    "磽": "敲",
    "鮕": "姑",
    "鳱": "干",
    "訔": "银",
    "鳷": "知",
    "桳": "笨",
    "缿": "向",
    "騽": "习",
    "孡": "胎",
    "齵": "偶",
    "硴": "花",
    "茥": "归",
    "焲": "意",
    "蒷": "云",
    "禷": "泪",
    "嶐": "龙",
    "阦": "羊",
    "鶌": "觉",
    "嬔": "父",
    "灔": "燕",
    "慩": "连",
    "捪": "民",
    "躼": "烙",
    "贐": "进",
    "疛": "肘",
    "璤": "会",
    "艓": "叠",
    "僙": "光",
    "獛": "葡",
    "伳": "谢",
    "哅": "胸",
    "蚏": "月",
    "鼝": "冤",
    "蕧": "父",
    "蚒": "同",
    "蘎": "记",
    "讆": "位",
    "譼": "见",
    "鄏": "乳",
    "籆": "月",
    "鄛": "朝",
    "齻": "颠",
    "滣": "纯",
    "雧": "极",
    "雴": "赤",
    "臗": "宽",
    "髛": "烤",
    "襐": "向",
    "螪": "伤",
    "鵧": "皮",
    "葝": "情",
    "篿": "团",
    "槒": "续",
    "鼥": "拔",
    "斖": "伟",
    "骳": "被",
    "讅": "审",
    "蘦": "零",
    "鉹": "尺",
    "袟": "至",
    "繴": "必",
    "輼": "温",
    "恞": "宜",
    "槴": "互",
    "厇": "哲",
    "炦": "拔",
    "媩": "胡",
    "媫": "节",
    "礯": "应",
    "頱": "罗",
    "栛": "利",
    "褄": "七",
    "飗": "刘",
    "陖": "俊",
    "麠": "精",
    "毝": "采",
    "踋": "角",
    "牃": "叠",
    "稇": "捆",
    "觙": "极",
    "鹝": "意",
    "豤": "肯",
    "邟": "抗",
    "鋑": "窜",
    "蘃": "瑞",
    "鏴": "路",
    "襰": "赖",
    "贘": "赏",
    "溩": "物",
    "蟉": "刘",
    "畭": "鱼",
    "庻": "树",
    "藬": "推",
    "鶿": "瓷",
    "庂": "责",
    "庉": "顿",
    "谽": "憨",
    "嬚": "脸",
    "嬼": "柳",
    "髜": "巧",
    "觺": "宜",
    "閊": "山",
    "蟤": "专",
    "蕆": "铲",
    "齥": "谢",
    "觷": "学",
    "豶": "坟",
    "螱": "位",
    "箚": "炸",
    "繠": "瑞",
    "憗": "印",
    "蜖": "回",
    "雽": "互",
    "糆": "面",
    "鑡": "绰",
    "躒": "利",
    "硱": "捆",
    "鬳": "燕",
    "遚": "臭",
    "錟": "谈",
    "銄": "想",
    "岓": "其",
    "徺": "角",
    "歅": "因",
    "椬": "宜",
    "浨": "懒",
    "梈": "砰",
    "旤": "或",
    "躮": "分",
    "庮": "有",
    "鵖": "逼",
    "糚": "装",
    "蚎": "月",
    "庩": "图",
    "鈬": "夺",
    "鬖": "三",
    "旜": "占",
    "柫": "福",
    "峹": "图",
    "璷": "芦",
    "軲": "姑",
    "陫": "费",
    "轈": "朝",
    "郙": "辅",
    "愗": "帽",
    "撊": "现",
    "駧": "动",
    "杒": "任",
    "揤": "极",
    "藛": "写",
    "鶮": "贺",
    "魾": "批",
    "閌": "抗",
    "荲": "离",
    "嗁": "提",
    "蟧": "劳",
    "齸": "意",
    "皫": "漂",
    "躳": "工",
    "楏": "奎",
    "鑃": "掉",
    "鼦": "雕",
    "筡": "图",
    "輆": "凯",
    "伵": "续",
    "葕": "燕",
    "躘": "龙",
    "赥": "西",
    "撡": "操",
    "庱": "成",
    "曻": "生",
    "袹": "博",
    "潀": "从",
    "靪": "丁",
    "旘": "至",
    "癠": "记",
    "癏": "关",
    "篫": "助",
    "鄊": "相",
    "愘": "恰",
    "莌": "拖",
    "綤": "绍",
    "撽": "巧",
    "醾": "迷",
    "焏": "极",
    "齇": "扎",
    "鶫": "东",
    "鸒": "玉",
    "橂": "电",
    "娽": "路",
    "狵": "忙",
    "椔": "姿",
    "欃": "缠",
    "耣": "伦",
    "暷": "传",
    "跙": "巨",
    "隌": "俺",
    "諔": "处",
    "勏": "不",
    "鴾": "谋",
    "齽": "进",
    "挔": "旅",
    "蝅": "残",
    "鋍": "博",
    "虶": "迂",
    "盚": "求",
    "頏": "行",
    "鋥": "赠",
    "庲": "来",
    "鰠": "骚",
    "葨": "微",
    "躢": "踏",
    "鋖": "思",
    "翨": "赤",
    "颮": "标",
    "曫": "鸾",
    "嬵": "眠",
    "槷": "聂",
    "憼": "井",
    "淁": "妾",
    "蓗": "总",
    "鮥": "落",
    "驔": "电",
    "闙": "起",
    "婛": "精",
    "矕": "满",
    "衈": "二",
    "檭": "银",
    "榝": "沙",
    "筤": "狼",
    "韲": "机",
    "鯣": "意",
    "恎": "叠",
    "櫍": "至",
    "豧": "夫",
    "陙": "纯",
    "谹": "红",
    "鳾": "诗",
    "磭": "绰",
    "黭": "眼",
    "雺": "物",
    "廏": "就",
    "邎": "摇",
    "秵": "因",
    "廥": "快",
    "氉": "懆",
    "鑜": "赏",
    "郬": "青",
    "敐": "陈",
    "幬": "愁",
    "劆": "连",
    "嵪": "敲",
    "嬯": "台",
    "雈": "环",
    "萒": "眼",
    "輁": "拱",
    "嵔": "伟",
    "鵂": "修",
    "諆": "七",
    "秜": "尼",
    "碐": "棱",
    "埾": "巨",
    "馰": "敌",
    "韐": "格",
    "鰙": "弱",
    "肰": "然",
    "謒": "枪",
    "頯": "奎",
    "噖": "银",
    "扊": "眼",
    "餛": "魂",
    "趏": "瓜",
    "鵀": "人",
    "菵": "网",
    "揊": "屁",
    "鈵": "饼",
    "鐆": "岁",
    "跭": "翔",
    "攈": "俊",
    "撏": "闲",
    "諥": "重",
    "宯": "消",
    "酠": "恰",
    "瓹": "捐",
    "攡": "吃",
    "絗": "胡",
    "毧": "容",
    "饛": "盟",
    "漛": "腾",
    "趃": "叠",
    "訄": "求",
    "鴚": "歌",
    "瞨": "葡",
    "涻": "设",
    "矌": "矿",
    "杹": "话",
    "砙": "瓦",
    "碯": "脑",
    "嬂": "直",
    "蝄": "网",
    "郀": "哭",
    "澿": "琴",
    "匧": "妾",
    "嬺": "逆",
    "鬉": "宗",
    "剆": "裸",
    "凗": "催",
    "煔": "闪",
    "橍": "润",
    "攓": "前",
    "髍": "魔",
    "忷": "胸",
    "訿": "子",
    "犈": "全",
    "塣": "挣",
    "噿": "嘴",
    "勂": "告",
    "怷": "树",
    "薕": "连",
    "綐": "对",
    "藭": "穷",
    "麡": "其",
    "鈓": "人",
    "鉪": "地",
    "墇": "帐",
    "韥": "毒",
    "帲": "平",
    "蚟": "王",
    "駇": "文",
    "顉": "亲",
    "鎐": "摇",
    "澢": "当",
    "茾": "前",
    "壏": "现",
    "喢": "煞",
    "匌": "格",
    "喖": "胡",
    "郮": "周",
    "岮": "驮",
    "鏪": "曹",
    "毜": "豪",
    "銂": "周",
    "閛": "砰",
    "齓": "衬",
    "捙": "夜",
    "渪": "如",
    "竌": "处",
    "虴": "哲",
    "鵏": "捕",
    "焭": "穷",
    "蕒": "买",
    "鐊": "羊",
    "礰": "利",
    "釼": "见",
    "摉": "搜",
    "漝": "习",
    "峌": "叠",
    "襱": "龙",
    "燛": "窘",
    "頮": "会",
    "擻": "搜",
    "邥": "审",
    "逪": "错",
    "濚": "营",
    "螡": "文",
    "噡": "占",
    "邖": "山",
    "鑈": "聂",
    "紻": "养",
    "寏": "环",
    "韅": "显",
    "韇": "毒",
    "贙": "炫",
    "饓": "称",
    "鑋": "青",
    "耝": "去",
    "炢": "竹",
    "晐": "该",
    "嗸": "敖",
    "嬐": "先",
    "膗": "揣",
    "稴": "闲",
    "隖": "物",
    "翖": "西",
    "腞": "赚",
    "痬": "意",
    "輲": "传",
    "梤": "坟",
    "駪": "深",
    "翇": "福",
    "臕": "标",
    "傟": "养",
    "嫶": "桥",
    "聀": "直",
    "觘": "吵",
    "馵": "助",
    "璛": "速",
    "灛": "铲",
    "徢": "谢",
    "趶": "裤",
    "螐": "乌",
    "硢": "鱼",
    "魪": "借",
    "鄼": "赞",
    "鮤": "裂",
    "焹": "杠",
    "譵": "对",
    "鋱": "特",
    "鹷": "零",
    "藀": "营",
    "靟": "飞",
    "哰": "劳",
    "廫": "聊",
    "袾": "朱",
    "楐": "借",
    "嬳": "月",
    "琽": "堵",
    "黅": "金",
    "葥": "见",
    "晪": "舔",
    "鑮": "博",
    "瓎": "蜡",
    "嗀": "互",
    "毥": "寻",
    "歒": "替",
    "詾": "胸",
    "夡": "气",
    "誴": "从",
    "埁": "琴",
    "澰": "练",
    "膱": "直",
    "鯚": "记",
    "鋜": "着",
    "尵": "推",
    "砇": "民",
    "揱": "消",
    "峉": "恶",
    "膭": "归",
    "躨": "奎",
    "宲": "宝",
    "蓾": "鲁",
    "瀢": "伟",
    "腉": "奶",
    "羒": "坟",
    "嵱": "永",
    "鑐": "需",
    "襎": "烦",
    "衉": "咖",
    "鳲": "诗",
    "抮": "枕",
    "椲": "伟",
    "踷": "眨",
    "懥": "至",
    "黗": "吞",
    "墧": "确",
    "肹": "西",
    "湂": "恶",
    "嘝": "胡",
    "雗": "汉",
    "蛌": "古",
    "帣": "卷",
    "勡": "票",
    "贕": "毒",
    "蒘": "如",
    "侺": "肾",
    "嬕": "是",
    "頉": "宜",
    "抙": "剖",
    "罤": "提",
    "悹": "灌",
    "鎋": "侠",
    "郶": "不",
    "蛜": "一",
    "耯": "或",
    "瀂": "鲁",
    "蘕": "朋",
    "駥": "容",
    "麧": "和",
    "貗": "巨",
    "迧": "陈",
    "鑝": "朋",
    "榵": "容",
    "蜹": "瑞",
    "瀪": "烦",
    "諻": "黄",
    "鮇": "位",
    "魬": "板",
    "苵": "叠",
    "鮍": "批",
    "墛": "位",
    "橭": "姑",
    "輵": "格",
    "雂": "琴",
    "藵": "宝",
    "錎": "现",
    "攊": "利",
    "馤": "爱",
    "勜": "瓮",
    "蔨": "倦",
    "峷": "深",
    "茒": "原",
    "嬻": "毒",
    "癉": "单",
    "艪": "鲁",
    "匉": "砰",
    "竆": "穷",
    "魛": "刀",
    "錃": "批",
    "齀": "物",
    "艵": "平",
    "瓸": "摆",
    "蕕": "由",
    "捳": "月",
    "佭": "翔",
    "燱": "意",
    "槉": "极",
    "櫾": "由",
    "傠": "罚",
    "扷": "奥",
    "蔙": "炫",
    "梥": "松",
    "螖": "华",
    "楾": "全",
    "痭": "崩",
    "摕": "地",
    "揋": "微",
    "焵": "杠",
    "蠽": "节",
    "谺": "虾",
    "鷾": "意",
    "贉": "蛋",
    "攳": "寻",
    "鏧": "龙",
    "覍": "变",
    "縍": "帮",
    "遳": "搓",
    "葾": "冤",
    "秚": "办",
    "楈": "需",
    "邼": "框",
    "傇": "容",
    "鰚": "宣",
    "蚾": "皮",
    "黤": "眼",
    "梞": "记",
    "懎": "色",
    "鉊": "招",
    "髼": "朋",
    "湒": "极",
    "翪": "宗",
    "妐": "中",
    "簛": "筛",
    "瀳": "见",
    "裷": "冤",
    "頀": "互",
    "糃": "唐",
    "娵": "居",
    "飉": "聊",
    "褯": "借",
    "鮔": "巨",
    "嶯": "极",
    "嵳": "搓",
    "嶀": "突",
    "枤": "地",
    "蘲": "雷",
    "潿": "维",
    "棞": "俊",
    "伜": "翠",
    "虊": "鸾",
    "桗": "堕",
    "曑": "深",
    "覙": "罗",
    "髱": "报",
    "鞖": "虽",
    "銡": "极",
    "氃": "同",
    "隟": "系",
    "隲": "至",
    "螒": "汉",
    "糩": "快",
    "鬤": "嚷",
    "怸": "西",
    "黀": "邹",
    "樄": "陈",
    "妅": "红",
    "蘈": "推",
    "泎": "则",
    "嫴": "姑",
    "鈠": "意",
    "秲": "至",
    "蘐": "宣",
    "貦": "完",
    "沊": "蛋",
    "鄁": "被",
    "閳": "铲",
    "瓭": "胆",
    "樖": "科",
    "軥": "取",
    "邭": "巨",
    "斴": "林",
    "鯺": "朱",
    "萞": "必",
    "嘽": "铲",
    "龓": "垄",
    "鷅": "利",
    "惽": "敏",
    "僁": "谢",
    "溔": "咬",
    "鲓": "烤",
    "鯕": "其",
    "翞": "将",
    "糔": "修",
    "躷": "矮",
    "墔": "催",
    "瓝": "博",
    "轣": "利",
    "橜": "觉",
    "駍": "培",
    "趩": "赤",
    "瘂": "哑",
    "詉": "脑",
    "筗": "重",
    "燩": "确",
    "愳": "巨",
    "悀": "永",
    "縖": "侠",
    "腝": "尼",
    "臅": "处",
    "馢": "间",
    "欮": "觉",
    "趀": "刺",
    "炠": "侠",
    "鼤": "文",
    "駬": "耳",
    "腣": "地",
    "鰿": "记",
    "齘": "谢",
    "崻": "至",
    "銁": "君",
    "堖": "脑",
    "嫷": "妥",
    "鮧": "体",
    "遪": "擦",
    "邌": "离",
    "桞": "柳",
    "縎": "古",
    "翉": "本",
    "靮": "敌",
    "皣": "夜",
    "敆": "和",
    "嵽": "叠",
    "聇": "睁",
    "猉": "其",
    "麭": "炮",
    "鄈": "奎",
    "轇": "教",
    "衇": "卖",
    "魳": "匝",
    "螔": "宜",
    "髊": "刺",
    "臰": "臭",
    "卶": "尺",
    "譠": "谈",
    "詥": "和",
    "籗": "着",
    "崨": "节",
    "烗": "开",
    "慺": "楼",
    "嶚": "聊",
    "恗": "呼",
    "睳": "灰",
    "蹃": "诺",
    "啔": "起",
    "轒": "坟",
    "鶂": "意",
    "愞": "诺",
    "埐": "金",
    "摿": "摇",
    "萕": "其",
    "菷": "肘",
    "棇": "聪",
    "搑": "容",
    "楎": "灰",
    "糛": "唐",
    "搝": "求",
    "蝪": "汤",
    "坕": "精",
    "揁": "睁",
    "苬": "修",
    "匑": "工",
    "胦": "养",
    "觰": "扎",
    "媅": "单",
    "嵭": "崩",
    "鱢": "骚",
    "蹸": "吝",
    "鮯": "格",
    "趭": "教",
    "踙": "聂",
    "鐋": "汤",
    "矲": "爸",
    "燘": "美",
    "蠳": "应",
    "騸": "善",
    "箿": "极",
    "霋": "七",
    "昲": "费",
    "鑟": "毒",
    "獱": "编",
    "錍": "批",
    "瓵": "宜",
    "敪": "多",
    "鮝": "想",
    "婙": "静",
    "珬": "续",
    "靾": "意",
    "巐": "吵",
    "蝒": "眠",
    "槆": "春",
    "澲": "夜",
    "鈌": "觉",
    "騗": "片",
    "刏": "机",
    "粣": "册",
    "鞷": "格",
    "郋": "习",
    "斒": "班",
    "瀱": "记",
    "鵚": "突",
    "麘": "相",
    "尳": "古",
    "漅": "朝",
    "駏": "巨",
    "搚": "拉",
    "鷈": "踢",
    "躗": "位",
    "栚": "镇",
    "沞": "匝",
    "祣": "旅",
    "鞙": "炫",
    "訩": "胸",
    "匶": "就",
    "氁": "木",
    "醥": "漂",
    "艝": "雪",
    "蜦": "伦",
    "紎": "姿",
    "狣": "照",
    "犡": "利",
    "撉": "蹲",
    "鵛": "精",
    "睵": "灾",
    "捾": "卧",
    "獖": "笨",
    "蓘": "滚",
    "烲": "谢",
    "峼": "告",
    "秢": "零",
    "蝊": "定",
    "鎪": "搜",
    "鹶": "金",
    "埩": "睁",
    "鶘": "胡",
    "痯": "管",
    "欈": "维",
    "狧": "踏",
    "郍": "挪",
    "繿": "蓝",
    "骔": "宗",
    "猅": "排",
    "孷": "离",
    "孠": "四",
    "龡": "吹",
    "蘵": "知",
    "蒣": "徐",
    "攟": "俊",
    "禃": "直",
    "蝫": "朱",
    "瓺": "长",
    "蠾": "竹",
    "龣": "觉",
    "釸": "西",
    "剈": "冤",
    "躻": "空",
    "麎": "陈",
    "摍": "缩",
    "葞": "米",
    "鄬": "维",
    "呝": "恶",
    "嵮": "颠",
    "攚": "瓮",
    "閚": "占",
    "搇": "亲",
    "鞊": "节",
    "齖": "牙",
    "攁": "养",
    "酭": "右",
    "鷑": "极",
    "轐": "哺",
    "錁": "果",
    "紴": "波",
    "豾": "批",
    "飌": "风",
    "饊": "三",
    "墶": "哒",
    "宺": "谎",
    "蜐": "节",
    "橶": "极",
    "罆": "灌",
    "倊": "宗",
    "壣": "林",
    "萖": "碗",
    "鮩": "病",
    "縅": "微",
    "腇": "内",
    "蒑": "因",
    "靆": "带",
    "疩": "翠",
    "嵰": "浅",
    "穯": "色",
    "稛": "捆",
    "揨": "陈",
    "宩": "使",
    "禯": "农",
    "頾": "姿",
    "螕": "逼",
    "鶹": "刘",
    "昿": "矿",
    "畘": "南",
    "稘": "机",
    "狫": "老",
    "騊": "桃",
    "溄": "逢",
    "鱹": "灌",
    "憴": "生",
    "縪": "必",
    "鼵": "突",
    "鵥": "判",
    "詴": "微",
    "晎": "红",
    "鵃": "周",
    "魶": "那",
    "鍷": "奎",
    "駺": "狼",
    "覻": "区",
    "餪": "暖",
    "腬": "柔",
    "軮": "养",
    "麲": "现",
    "蛼": "车",
    "鎄": "哀",
    "孈": "会",
    "搄": "根",
    "贚": "弄",
    "毇": "毁",
    "怟": "地",
    "隢": "扰",
    "謣": "鱼",
    "軝": "其",
    "腲": "伟",
    "砓": "哲",
    "崅": "确",
    "廭": "记",
    "溛": "挖",
    "膼": "抓",
    "寭": "会",
    "瑻": "昆",
    "欳": "溃",
    "煛": "窘",
    "輣": "朋",
    "毷": "帽",
    "氋": "盟",
    "硳": "赤",
    "舿": "夸",
    "灐": "营",
    "飥": "拖",
    "髚": "巧",
    "瞚": "顺",
    "炍": "判",
    "輱": "闲",
    "翝": "红",
    "縃": "需",
    "訋": "掉",
    "肵": "其",
    "蜠": "俊",
    "銴": "是",
    "埬": "东",
    "夦": "尘",
    "顐": "问",
    "鈲": "姑",
    "鰦": "姿",
    "嘊": "埃",
    "驈": "玉",
    "訤": "肖",
    "媨": "促",
    "斚": "假",
    "耟": "巨",
    "艍": "居",
    "霩": "扩",
    "轞": "见",
    "娦": "贫",
    "慏": "命",
    "抁": "眼",
    "梊": "地",
    "胅": "叠",
    "桘": "缀",
    "箵": "星",
    "剓": "离",
    "鋙": "雨",
    "洆": "成",
    "觓": "求",
    "胋": "田",
    "蚉": "文",
    "堲": "瓷",
    "鴬": "应",
    "銰": "哀",
    "媀": "玉",
    "猑": "昆",
    "痸": "赤",
    "駼": "图",
    "槝": "导",
    "訹": "续",
    "椝": "归",
    "絼": "镇",
    "嬏": "翻",
    "髿": "缩",
    "疅": "将",
    "捓": "爷",
    "蓛": "册",
    "鄵": "操",
    "鏎": "必",
    "輎": "烧",
    "鑘": "雷",
    "鋣": "爷",
    "懏": "俊",
    "蘟": "引",
    "俕": "散",
    "鄥": "敲",
    "飋": "色",
    "秿": "父",
    "胇": "费",
    "瞖": "意",
    "擏": "情",
    "亄": "意",
    "穳": "攒",
    "硡": "轰",
    "襋": "极",
    "檃": "引",
    "飦": "占",
    "爥": "竹",
    "欯": "系",
    "忰": "翠",
    "枾": "是",
    "鎃": "派",
    "姾": "全",
    "崓": "固",
    "炚": "光",
    "茟": "玉",
    "邒": "停",
    "汿": "续",
    "甇": "应",
    "歋": "夜",
    "闛": "唐",
    "萈": "环",
    "镼": "区",
    "纄": "朋",
    "厏": "眨",
    "蜶": "所",
    "岲": "矿",
    "鱑": "黄",
    "屔": "尼",
    "鎠": "刚",
    "隀": "虫",
    "衸": "借",
    "鳸": "互",
    "昒": "呼",
    "飰": "饭",
    "酀": "燕",
    "蘞": "脸",
    "嬹": "性",
    "趡": "脆",
    "釳": "系",
    "蘏": "窘",
    "蠫": "离",
    "隓": "灰",
    "牏": "鱼",
    "澅": "话",
    "駚": "养",
    "峛": "李",
    "癛": "吝",
    "巸": "宜",
    "欫": "气",
    "櫦": "庆",
    "鼞": "汤",
    "餁": "任",
    "葪": "记",
    "鰵": "敏",
    "恜": "赤",
    "秓": "知",
    "藑": "穷",
    "澵": "真",
    "歱": "种",
    "褹": "意",
    "碵": "田",
    "梷": "静",
    "撋": "软",
    "薚": "汤",
    "麉": "间",
    "攌": "缓",
    "螮": "地",
    "鵒": "玉",
    "蜬": "含",
    "槹": "高",
    "勎": "路",
    "釮": "其",
    "飳": "偷",
    "翸": "喷",
    "坓": "井",
    "躀": "灌",
    "諯": "专",
    "弞": "审",
    "瞮": "撤",
    "矨": "影",
    "蟚": "朋",
    "漡": "伤",
    "躤": "极",
    "濸": "仓",
    "瘱": "意",
    "竰": "离",
    "鷶": "买",
    "虲": "虾",
    "鎁": "爷",
    "挘": "裂",
    "舓": "是",
    "覝": "连",
    "傄": "虾",
    "拞": "底",
    "輰": "羊",
    "醿": "迷",
    "躑": "直",
    "礗": "拼",
    "爗": "夜",
    "躙": "吝",
    "噋": "吞",
    "墢": "拔",
    "鵫": "着",
    "眱": "地",
    "樎": "速",
    "茊": "姿",
    "晘": "汉",
    "諀": "匹",
    "鵴": "局",
    "艆": "狼",
    "赾": "寝",
    "舼": "穷",
    "梙": "换",
    "煂": "贺",
    "釲": "四",
    "嗋": "鞋",
    "熭": "位",
    "纝": "雷",
    "麱": "夫",
    "錗": "内",
    "闎": "全",
    "爋": "熏",
    "躴": "狼",
    "顄": "汉",
    "虇": "犬",
    "蛨": "墨",
    "韰": "谢",
    "濭": "矮",
    "僘": "场",
    "鳺": "夫",
    "溒": "原",
    "踑": "其",
    "鵅": "落",
    "餥": "飞",
    "隇": "微",
    "椣": "点",
    "誵": "肖",
    "裮": "昌",
    "晭": "肘",
    "壉": "巨",
    "顜": "讲",
    "梸": "离",
    "稖": "棒",
    "絉": "树",
    "齈": "弄",
    "媡": "练",
    "隿": "意",
    "蟂": "消",
    "諐": "前",
    "軂": "烙",
    "蠬": "龙",
    "篧": "着",
    "覹": "维",
    "惥": "永",
    "鬀": "替",
    "撨": "辅",
    "袉": "驮",
    "僌": "营",
    "誺": "吃",
    "鼼": "要",
    "槶": "贵",
    "韴": "杂",
    "韖": "柔",
    "鼶": "思",
    "刯": "耕",
    "炥": "福",
    "饻": "西",
    "砿": "矿",
    "鮽": "鱼",
    "葋": "取",
    "坥": "区",
    "醟": "用",
    "殱": "间",
    "鯠": "来",
    "妿": "阿",
    "驉": "需",
    "懩": "养",
    "鈗": "允",
    "貕": "西",
    "懛": "呆",
    "贂": "尘",
    "霌": "周",
    "莡": "错",
    "珕": "利",
    "蠝": "垒",
    "奃": "低",
    "朎": "零",
    "蠥": "聂",
    "孯": "前",
    "鼰": "局",
    "餙": "是",
    "嵦": "凯",
    "駽": "宣",
    "郌": "归",
    "瓄": "毒",
    "醔": "求",
    "髶": "容",
    "矵": "气",
    "軩": "带",
    "饳": "堕",
    "輺": "姿",
    "艬": "缠",
    "鷎": "高",
    "陦": "导",
    "珳": "文",
    "曭": "躺",
    "錖": "毒",
    "覐": "觉",
    "讄": "垒",
    "鰴": "灰",
    "峾": "银",
    "螦": "骚",
    "謼": "呼",
    "囐": "杂",
    "峀": "秀",
    "虄": "萨",
    "腒": "居",
    "鑏": "凝",
    "忀": "相",
    "獇": "枪",
    "瓋": "替",
    "殥": "银",
    "惼": "扁",
    "揟": "需",
    "嬦": "愁",
    "靕": "真",
    "雭": "色",
    "饚": "害",
    "匲": "连",
    "劷": "羊",
    "鰮": "温",
    "硻": "坑",
    "踕": "节",
    "瞗": "雕",
    "瀎": "墨",
    "葏": "精",
    "旞": "岁",
    "袸": "见",
    "斊": "其",
    "遉": "真",
    "梎": "凹",
    "渨": "微",
    "潝": "西",
    "庪": "鬼",
    "擜": "恶",
    "銒": "行",
    "憢": "消",
    "闦": "文",
    "翐": "至",
    "檕": "记",
    "騘": "聪",
    "歑": "呼",
    "陒": "鬼",
    "嘳": "溃",
    "艕": "棒",
    "黋": "矿",
    "肞": "插",
    "輚": "战",
    "餕": "俊",
    "鷢": "觉",
    "怬": "系",
    "逘": "以",
    "樭": "机",
    "猆": "飞",
    "螊": "连",
    "竗": "庙",
    "鈱": "民",
    "竧": "静",
    "鍹": "宣",
    "抍": "整",
    "蔋": "敌",
    "婒": "谈",
    "鶎": "尊",
    "犩": "维",
    "艐": "客",
    "焍": "地",
    "藡": "敌",
    "瀗": "现",
    "鑎": "溃",
    "躈": "巧",
    "鱎": "角",
    "詿": "挂",
    "矈": "眠",
    "謲": "灿",
    "砋": "指",
    "朑": "替",
    "誯": "唱",
    "戃": "躺",
    "睮": "鱼",
    "徱": "票",
    "袲": "尺",
    "蝵": "秋",
    "瘚": "觉",
    "嶭": "聂",
    "煰": "造",
    "銔": "批",
    "鯐": "走",
    "噞": "眼",
    "疀": "插",
    "樇": "修",
    "騝": "钱",
    "濐": "主",
    "覼": "罗",
    "璳": "田",
    "絈": "墨",
    "碀": "成",
    "爙": "嚷",
    "眪": "饼",
    "跮": "赤",
    "鉡": "办",
    "癨": "或",
    "厁": "三",
    "鵱": "路",
    "愲": "古",
    "鷥": "思",
    "薟": "先",
    "耓": "听",
    "棛": "玉",
    "峵": "容",
    "匔": "工",
    "烉": "换",
    "蔧": "会",
    "顭": "盟",
    "樢": "尿",
    "僲": "先",
    "魫": "审",
    "蹪": "推",
    "銌": "尊",
    "鏼": "色",
    "璭": "滚",
    "鞉": "桃",
    "鯴": "诗",
    "襇": "减",
    "炄": "纽",
    "暭": "号",
    "膢": "驴",
    "芌": "玉",
    "蹫": "局",
    "驜": "夜",
    "颴": "炫",
    "慻": "倦",
    "鬠": "扩",
    "燰": "微",
    "稒": "固",
    "鵊": "夹",
    "覕": "灭",
    "諹": "羊",
    "窙": "消",
    "瀈": "灰",
    "熮": "柳",
    "羦": "环",
    "譈": "对",
    "痮": "帐",
    "顅": "前",
    "軉": "玉",
    "藫": "谈",
    "斔": "雨",
    "壥": "缠",
    "鍁": "先",
    "歬": "钱",
    "殶": "助",
    "鱡": "贼",
    "粚": "吃",
    "懧": "诺",
    "攑": "前",
    "靍": "贺",
    "趻": "尘",
    "蜔": "电",
    "嗈": "庸",
    "榹": "思",
    "髉": "博",
    "蜌": "必",
    "氌": "鲁",
    "箳": "平",
    "鮅": "必",
    "鮳": "烤",
    "塛": "利",
    "袳": "尺",
    "薣": "古",
    "愅": "格",
    "飵": "做",
    "蠮": "椰",
    "稐": "伦",
    "藲": "欧",
    "橏": "展",
    "踲": "顿",
    "顋": "塞",
    "霟": "红",
    "鶓": "描",
    "擑": "接",
    "瑼": "专",
    "鵗": "西",
    "炂": "中",
    "盶": "远",
    "軁": "楼",
    "敽": "角",
    "駩": "圈",
    "濥": "引",
    "弫": "枕",
    "燆": "敲",
    "磠": "鲁",
    "駵": "刘",
    "郆": "极",
    "蟷": "当",
    "艃": "离",
    "庽": "玉",
    "谾": "轰",
    "趢": "路",
    "蟏": "消",
    "燍": "思",
    "隒": "眼",
    "攕": "先",
    "徟": "周",
    "曍": "号",
    "鮌": "滚",
    "掚": "两",
    "惖": "替",
    "裫": "院",
    "鄸": "盟",
    "劕": "至",
    "懱": "灭",
    "馲": "哲",
    "鴰": "瓜",
    "磶": "系",
    "娎": "谢",
    "憄": "至",
    "騪": "搜",
    "覉": "机",
    "蠩": "朱",
    "狿": "颜",
    "魵": "坟",
    "揧": "蜡",
    "踁": "静",
    "獤": "蹲",
    "魤": "额",
    "鸖": "贺",
    "窤": "关",
    "鰖": "妥",
    "跾": "书",
    "譢": "岁",
    "燽": "愁",
    "緽": "称",
    "騡": "全",
    "榲": "温",
    "蜏": "有",
    "鋿": "长",
    "蠯": "皮",
    "蘙": "意",
    "螲": "至",
    "蜤": "思",
    "掶": "节",
    "鑍": "应",
    "閝": "零",
    "葈": "洗",
    "毭": "豆",
    "袶": "降",
    "戵": "取",
    "螛": "和",
    "鶑": "应",
    "镽": "了",
    "陠": "铺",
    "榁": "使",
    "豴": "敌",
    "馟": "图",
    "綥": "其",
    "圽": "墨",
    "朇": "皮",
    "磇": "批",
    "趗": "促",
    "躖": "断",
    "豂": "聊",
    "蒕": "晕",
    "鶭": "访",
    "焳": "觉",
    "溳": "云",
    "縜": "云",
    "蠇": "利",
    "愌": "换",
    "溤": "马",
    "頢": "扩",
    "溊": "波",
    "溌": "坡",
    "椞": "系",
    "藰": "刘",
    "擨": "爷",
    "墂": "标",
    "醀": "维",
    "踸": "尘",
    "鞇": "因",
    "橯": "烙",
    "鸆": "鱼",
    "噒": "连",
    "俼": "玉",
    "鷧": "意",
    "檅": "会",
    "鑂": "训",
    "羷": "脸",
    "蔜": "敖",
    "梋": "宣",
    "囅": "铲",
    "垘": "福",
    "頨": "雨",
    "幊": "工",
    "逳": "玉",
    "溨": "灾",
    "莻": "共",
    "豅": "龙",
    "韷": "乐",
    "蕔": "包",
    "燤": "太",
    "硵": "鲁",
    "焥": "卧",
    "奞": "训",
    "釛": "八",
    "庰": "病",
    "蠜": "烦",
    "虉": "意",
    "瘬": "帐",
    "竱": "转",
    "镾": "迷",
    "穲": "离",
    "貖": "意",
    "瀊": "盘",
    "螰": "路",
    "瓗": "穷",
    "鴡": "居",
    "礈": "缀",
    "襽": "蓝",
    "筕": "行",
    "齂": "谢",
    "坾": "助",
    "豼": "皮",
    "霶": "旁",
    "桏": "穷",
    "馷": "配",
    "騆": "周",
    "睝": "离",
    "匩": "框",
    "柼": "咬",
    "螴": "陈",
    "褮": "应",
    "鉕": "坡",
    "闣": "荡",
    "軵": "容",
    "爦": "懒",
    "曥": "芦",
    "毠": "家",
    "釥": "巧",
    "瓳": "胡",
    "匥": "烦",
    "嶳": "地",
    "踓": "伟",
    "籢": "连",
    "蛥": "蛇",
    "蘉": "盟",
    "焝": "混",
    "逫": "觉",
    "鐰": "敲",
    "歝": "意",
    "镻": "叠",
    "竳": "灯",
    "麔": "就",
    "槣": "机",
    "歵": "则",
    "襉": "减",
    "矡": "觉",
    "雓": "鱼",
    "覄": "父",
    "赮": "侠",
    "蠗": "着",
    "臄": "觉",
    "廎": "请",
    "搈": "容",
    "嬊": "燕",
    "牄": "枪",
    "嬘": "岁",
    "礢": "养",
    "鸋": "凝",
    "娺": "着",
    "礏": "夜",
    "圸": "山",
    "崫": "哭",
    "贎": "万",
    "煘": "缠",
    "磤": "引",
    "燺": "贺",
    "顀": "垂",
    "釟": "八",
    "矎": "宣",
    "攗": "梅",
    "曊": "费",
    "垑": "尺",
    "鐷": "夜",
    "笽": "敏",
    "哛": "分",
    "鼿": "物",
    "蚭": "尼",
    "箃": "邹",
    "蜽": "两",
    "鑙": "机",
    "趘": "习",
    "癧": "利",
    "諅": "记",
    "耊": "叠",
    "懘": "赤",
    "黊": "话",
    "橁": "春",
    "豓": "燕",
    "跜": "尼",
    "騻": "双",
    "錓": "空",
    "鵣": "赖",
    "縘": "西",
    "榺": "胜",
    "疦": "觉",
    "覒": "帽",
    "襔": "满",
    "廜": "图",
    "擙": "奥",
    "獿": "脑",
    "瓾": "猛",
    "踃": "消",
    "耺": "云",
    "敡": "意",
    "鈯": "图",
    "闧": "他",
    "縙": "容",
    "祽": "最",
    "襺": "减",
    "橠": "挪",
    "餶": "古",
    "樐": "鲁",
    "錈": "卷",
    "庍": "败",
    "鵓": "博",
    "檱": "其",
    "鳭": "雕",
    "諃": "陈",
    "嚪": "蛋",
    "拀": "处",
    "輡": "砍",
    "毤": "拓",
    "陯": "伦",
    "駫": "窘",
    "鴶": "夹",
    "頿": "姿",
    "蠤": "秋",
    "燇": "俊",
    "齃": "恶",
    "菞": "离",
    "櫷": "归",
    "榏": "意",
    "鞽": "桥",
    "甉": "闲",
    "崣": "伟",
    "嘕": "先",
    "憏": "赤",
    "塧": "爱",
    "訰": "准",
    "睶": "春",
    "餄": "夹",
    "贀": "意",
    "騦": "思",
    "庌": "哑",
    "貄": "四",
    "墵": "谈",
    "檘": "平",
    "蛽": "被",
    "襳": "先",
    "嚝": "轰",
    "虝": "虎",
    "謵": "习",
    "塷": "鲁",
    "魧": "行",
    "糑": "诺",
    "翲": "飘",
    "裍": "捆",
    "趥": "秋",
    "蘨": "摇",
    "鬗": "瞒",
    "巀": "节",
    "烥": "巨",
    "櫇": "婆",
    "蘣": "偷",
    "澩": "学",
    "糄": "扁",
    "蔝": "米",
    "鸄": "机",
    "榸": "摘",
    "碖": "伦",
    "燲": "鞋",
    "籊": "替",
    "欆": "双",
    "遀": "随",
    "巕": "聂",
    "鈂": "陈",
    "餝": "是",
    "馪": "拼",
    "駋": "招",
    "鉇": "诗",
    "曎": "意",
    "魿": "零",
    "烅": "续",
    "稁": "搞",
    "弳": "静",
    "烡": "光",
    "蔖": "搓",
    "徿": "弄",
    "蛝": "闲",
    "鋛": "矿",
    "逧": "古",
    "豱": "温",
    "靲": "琴",
    "涄": "平",
    "縔": "双",
    "鼭": "石",
    "廅": "恶",
    "癄": "桥",
    "瓇": "柔",
    "嗂": "摇",
    "鳻": "班",
    "蛿": "汉",
    "珱": "应",
    "蕱": "烧",
    "屒": "枕",
    "蛡": "意",
    "餎": "了",
    "鰝": "号",
    "褿": "曹",
    "詋": "昼",
    "訲": "意",
    "轋": "魂",
    "戂": "迷",
    "霬": "意",
    "崺": "以",
    "麆": "助",
    "蛚": "裂",
    "藱": "会",
    "濗": "密",
    "壗": "进",
    "樚": "路",
    "藃": "消",
    "牫": "歌",
    "艁": "造",
    "覭": "明",
    "撛": "吝",
    "軯": "砰",
    "輫": "排",
    "蚙": "琴",
    "踗": "聂",
    "烢": "撤",
    "曃": "带",
    "鱍": "波",
    "驖": "铁",
    "夞": "外",
    "麍": "刘",
    "艜": "带",
    "崉": "踏",
    "鏿": "称",
    "庺": "松",
    "踜": "愣",
    "饖": "位",
    "蕛": "提",
    "絩": "跳",
    "濍": "松",
    "謻": "宜",
    "鬁": "利",
    "螑": "秀",
    "燢": "学",
    "虦": "战",
    "廀": "搜",
    "嬆": "西",
    "嵟": "堆",
    "竀": "称",
    "靃": "或",
    "瞈": "瓮",
    "蕮": "系",
    "櫅": "机",
    "奟": "崩",
    "嚉": "多",
    "鴑": "如",
    "欔": "觉",
    "烞": "破",
    "蜳": "蹲",
    "幧": "敲",
    "焩": "平",
    "鸃": "宜",
    "軇": "到",
    "擮": "节",
    "鬡": "凝",
    "萗": "册",
    "嚺": "踏",
    "穥": "玉",
    "灇": "从",
    "焨": "奉",
    "蔉": "滚",
    "爏": "利",
    "婎": "灰",
    "壾": "忙",
    "懫": "至",
    "鸉": "羊",
    "遃": "眼",
    "涋": "突",
    "鼨": "中",
    "觾": "燕",
    "鑧": "宽",
    "瞣": "万",
    "鑆": "缀",
    "磖": "啦",
    "訦": "陈",
    "噊": "玉",
    "灁": "冤",
    "懖": "扩",
    "陮": "对",
    "熽": "笑",
    "暽": "林",
    "攂": "泪",
    "浌": "罚",
    "磰": "善",
    "肑": "博",
    "銐": "赤",
    "殈": "续",
    "愹": "永",
    "賹": "意",
    "暬": "谢",
    "覟": "至",
    "鬫": "罕",
    "韗": "运",
    "鶷": "侠",
    "娹": "闲",
    "懬": "矿",
    "蟵": "除",
    "樳": "寻",
    "薞": "孙",
    "螼": "寝",
    "醏": "督",
    "牊": "朝",
    "魲": "芦",
    "鷷": "尊",
    "慂": "永",
    "魺": "和",
    "澷": "慢",
    "衑": "零",
    "駾": "退",
    "肳": "稳",
    "黆": "光",
    "濌": "踏",
    "灖": "米",
    "殬": "度",
    "翓": "鞋",
    "篖": "唐",
    "腪": "运",
    "蹨": "年",
    "懤": "愁",
    "銸": "哲",
    "漽": "提",
    "鈋": "额",
    "觨": "混",
    "醈": "谈",
    "鉠": "养",
    "馶": "知",
    "嶬": "宜",
    "暺": "坦",
    "懢": "蓝",
    "螸": "鱼",
    "跉": "零",
    "輽": "笨",
    "鄓": "夜",
    "譒": "薄",
    "貇": "昆",
    "憌": "穷",
    "娏": "忙",
    "毢": "塞",
    "籑": "赚",
    "艠": "灯",
    "槞": "龙",
    "嶛": "聊",
    "謭": "减",
    "顦": "桥",
    "腛": "卧",
    "鰪": "额",
    "軜": "那",
    "鸍": "迷",
    "灓": "鸾",
    "烵": "着",
    "鄻": "脸",
    "鶧": "应",
    "鶀": "其",
    "鎥": "条",
    "羻": "呛",
    "郹": "局",
    "贒": "闲",
    "艥": "极",
    "檴": "或",
    "鳵": "宝",
    "鏫": "离",
    "諁": "着",
    "憦": "烙",
    "嶩": "脑",
    "嶱": "可",
    "鏙": "催",
    "鉟": "批",
    "軬": "饭",
    "錰": "树",
    "鑬": "见",
    "惐": "玉",
    "欰": "续",
    "熪": "宜",
    "錪": "舔",
    "炨": "谢",
    "夓": "下",
    "瀶": "林",
    "藆": "减",
    "焈": "西",
    "譿": "会",
    "鬝": "前",
    "驧": "局",
    "軈": "应",
    "謶": "着",
    "顂": "赖",
    "濷": "费",
    "嚽": "绰",
    "脋": "鞋",
    "顝": "亏",
    "碊": "间",
    "焁": "西",
    "顩": "眼",
    "滜": "高",
    "燅": "寻",
    "焣": "吵",
    "壧": "颜",
    "肒": "换",
    "嶹": "导",
    "鴯": "而",
    "樈": "情",
    "漐": "直",
    "鉣": "节",
    "鍽": "编",
    "鯑": "西",
    "蜁": "旋",
    "燌": "坟",
    "魞": "八",
    "踾": "福",
    "跒": "恰",
    "唟": "去",
    "櫗": "灭",
    "萙": "枕",
    "跊": "妹",
    "硟": "颤",
    "飸": "掏",
    "賝": "陈",
    "韄": "互",
    "踿": "族",
    "鶋": "居",
    "裗": "刘",
    "愱": "极",
    "銿": "中",
    "嚍": "进",
    "溭": "则",
    "歽": "哲",
    "奊": "鞋",
    "熧": "宗",
    "髵": "而",
    "瀐": "间",
    "貥": "行",
    "銞": "君",
    "烌": "修",
    "鵌": "图",
    "閕": "虾",
    "谻": "极",
    "魱": "胡",
    "磮": "伦",
    "韒": "巧",
    "鉘": "福",
    "錔": "踏",
    "軤": "呼",
    "蘌": "雨",
    "鼧": "驮",
    "榌": "逼",
    "釯": "忙",
    "憠": "觉",
    "蟍": "离",
    "騥": "柔",
    "滰": "降",
    "顨": "训",
    "慸": "地",
    "駎": "昼",
    "焤": "辅",
    "茰": "鱼",
    "螷": "皮",
    "葤": "昼",
    "斪": "取",
    "幒": "中",
    "錷": "嘎",
    "矏": "眠",
    "濝": "其",
    "堫": "宗",
    "濻": "伟",
    "熍": "穷",
    "詸": "迷",
    "藒": "妾",
    "駷": "耸",
    "贆": "标",
    "颬": "虾",
    "嗩": "锁",
    "硛": "意",
    "諓": "见",
    "擳": "至",
    "詄": "叠",
    "瞁": "续",
    "怾": "指",
    "樤": "条",
    "讇": "铲",
    "筙": "来",
    "隭": "而",
    "爑": "觉",
    "鱌": "向",
    "骩": "伟",
    "欁": "农",
    "髰": "替",
    "釫": "华",
    "蓵": "节",
    "鎉": "达",
    "靅": "费",
    "尀": "坡",
    "碅": "君",
    "繱": "聪",
    "鮛": "书",
    "鍲": "民",
    "陱": "居",
    "讔": "引",
    "竐": "处",
    "籚": "芦",
    "褣": "容",
    "瀃": "四",
    "蜸": "浅",
    "謤": "标",
    "踥": "妾",
    "虠": "教",
    "蠞": "节",
    "謮": "则",
    "歶": "鱼",
    "鷪": "应",
    "耛": "宜",
    "鸈": "夜",
    "蘝": "脸",
    "慀": "系",
    "鞃": "红",
    "喡": "维",
    "頧": "堆",
    "覵": "见",
    "撪": "笨",
    "頕": "单",
    "聄": "枕",
    "趇": "系",
    "覛": "密",
    "飿": "堕",
    "磸": "定",
    "躵": "忍",
    "鯦": "就",
    "雵": "养",
    "藣": "杯",
    "聉": "袜",
    "袰": "波",
    "鋵": "突",
    "餩": "恶",
    "謱": "楼",
    "慗": "赤",
    "擛": "夜",
    "毺": "书",
    "鏥": "秀",
    "撎": "意",
    "譇": "扎",
    "橨": "坟",
    "鋓": "搀",
    "魩": "墨",
    "蹞": "魁",
    "頝": "敲",
    "釻": "求",
    "愵": "逆",
    "鴹": "羊",
    "遾": "是",
    "鰞": "乌",
    "釚": "求",
    "獔": "豪",
    "鷞": "双",
    "諑": "着",
    "瀄": "至",
    "軙": "陈",
    "謽": "降",
    "箲": "显",
    "踍": "敲",
    "灍": "觉",
    "螏": "极",
    "鶣": "偏",
    "筂": "持",
    "腗": "皮",
    "錊": "最",
    "燯": "零",
    "猈": "败",
    "顪": "会",
    "箺": "春",
    "坄": "意",
    "焷": "皮",
    "晇": "需",
    "謺": "哲",
    "軐": "信",
    "弲": "宣",
    "艔": "到",
    "熃": "物",
    "藖": "闲",
    "樦": "助",
    "蔐": "敌",
    "穁": "容",
    "駀": "由",
    "鱱": "利",
    "壛": "颜",
    "賟": "舔",
    "檹": "一",
    "鮾": "内",
    "襑": "信",
    "犥": "飘",
    "豍": "逼",
    "錌": "按",
    "錉": "民",
    "矃": "凝",
    "鈘": "以",
    "瞺": "会",
    "秛": "批",
    "鉙": "窄",
    "褬": "桑",
    "筟": "夫",
    "蓔": "咬",
    "瀩": "对",
    "霯": "腾",
    "硹": "松",
    "蔛": "胡",
    "暛": "锁",
    "螧": "其",
    "虥": "战",
    "鷌": "马",
    "詽": "颜",
    "檈": "旋",
    "鞺": "汤",
    "殔": "意",
    "蹮": "先",
    "馩": "坟",
    "浫": "罕",
    "欨": "需",
    "虃": "间",
    "餫": "运",
    "暞": "角",
    "毟": "裂",
    "熫": "至",
    "稪": "福",
    "嚋": "愁",
    "歚": "善",
    "睊": "倦",
    "蕽": "农",
    "豃": "罕",
    "鷭": "烦",
    "鯼": "宗",
    "幩": "坟",
    "碷": "顿",
    "籕": "昼",
    "鴭": "堆",
    "嶜": "金",
    "弡": "觉",
    "櫏": "前",
    "顤": "摇",
    "裐": "捐",
    "鋠": "肾",
    "廤": "裤",
    "篞": "聂",
    "貈": "和",
    "賌": "该",
    "踂": "聂",
    "鎀": "修",
    "諚": "偏",
    "駨": "熏",
    "塦": "镇",
    "旚": "飘",
    "鏔": "宜",
    "擈": "铺",
    "蜝": "其",
    "鮂": "求",
    "簢": "敏",
    "骪": "伟",
    "臹": "修",
    "浳": "意",
    "糐": "夫",
    "駣": "桃",
    "鱁": "竹",
    "燞": "角",
    "鴼": "落",
    "榒": "诺",
    "袎": "要",
    "鳨": "利",
    "鏯": "双",
    "沀": "续",
    "憁": "从",
    "鱃": "修",
    "艊": "博",
    "諩": "普",
    "覫": "旁",
    "頪": "泪",
    "顃": "谈",
    "鑉": "和",
    "饆": "必",
    "毩": "局",
    "騼": "路",
    "萔": "条",
    "鯄": "求",
    "毈": "断",
    "颹": "伟",
    "頛": "泪",
    "鶃": "意",
    "銺": "藏",
    "鴩": "铁",
    "顲": "懒",
    "塐": "速",
    "霘": "动",
    "駠": "刘",
    "騿": "张",
    "镺": "袄",
    "弤": "底",
    "焒": "旅",
    "魻": "侠",
    "贃": "万",
    "霕": "吞",
    "暳": "会",
    "駤": "至",
    "鎨": "损",
    "鶦": "胡",
    "槂": "孙",
    "頶": "胡",
    "襊": "翠",
    "嶎": "玉",
    "馸": "信",
    "樮": "烟",
    "誁": "病",
    "橩": "穷",
    "惾": "宗",
    "瘶": "嗽",
    "隵": "西",
    "鬇": "睁",
    "嶖": "烟",
    "隚": "唐",
    "橽": "踏",
    "鸅": "则",
    "橳": "胜",
    "銵": "坑",
    "騌": "宗",
    "蝷": "利",
    "毻": "拓",
    "蹗": "路",
    "鷤": "提",
    "嶥": "觉",
    "鬑": "连",
    "飷": "解",
    "蔅": "颜",
    "毲": "多",
    "猐": "枪",
    "肍": "求",
    "誝": "安",
    "稩": "记",
    "沎": "或",
    "袬": "玉",
    "蝆": "养",
    "鴮": "乌",
    "糋": "见",
    "鏩": "见",
    "飹": "宝",
    "鶳": "诗",
    "旫": "挑",
    "譑": "角",
    "錥": "玉",
    "鱛": "增",
    "韕": "扩",
    "誙": "坑",
    "錜": "聂",
    "薓": "深",
    "餢": "不",
    "穒": "贺",
    "鶙": "提",
    "誟": "笑",
    "謴": "滚",
    "驠": "燕",
    "誈": "乌",
    "鍻": "节",
    "鵋": "记",
    "擹": "贪",
    "硽": "烟",
    "襏": "博",
    "糣": "三",
    "祪": "鬼",
    "襨": "对",
    "隁": "燕",
    "餇": "同",
    "覣": "微",
    "靵": "纽",
    "鴺": "提",
    "鯏": "离",
    "鎫": "万",
    "軠": "狂",
    "軡": "钱",
    "錹": "肯",
    "鍿": "姿",
    "垥": "鞋",
    "烐": "周",
    "驏": "战",
    "賋": "角",
    "蔒": "熏",
    "覢": "闪",
    "鵘": "俊",
    "鴘": "扁",
    "溬": "枪",
    "趝": "见",
    "鴁": "邀",
    "渆": "冤",
    "跠": "宜",
    "籡": "妾",
    "毮": "沙",
    "訙": "训",
    "盕": "饭",
    "躎": "年",
    "鴱": "爱",
    "腵": "家",
    "愥": "应",
    "簅": "铲",
    "鮺": "眨",
    "鋧": "现",
    "瀒": "色",
    "迱": "驮",
    "鯅": "山",
    "瞸": "夜",
    "櫀": "其",
    "讍": "恶",
    "躸": "机",
    "彏": "觉",
    "窏": "乌",
    "鷱": "高",
    "磫": "宗",
    "貱": "必",
    "樬": "聪",
    "鬔": "朋",
    "鶾": "汉",
    "諊": "居",
    "鯜": "妾",
    "豒": "至",
    "嶾": "引",
    "攍": "营",
    "讑": "要",
    "骮": "意",
    "蠴": "鼠",
    "飻": "贴",
    "鉜": "福",
    "礍": "节",
    "鮷": "提",
    "橣": "凝",
    "鷠": "鱼",
    "顮": "彬",
    "銽": "瓜",
    "鋷": "最",
    "飅": "刘",
    "軣": "轰",
    "鯂": "苏",
    "魥": "恶",
    "鬎": "蜡",
    "鋴": "镇",
    "糮": "现",
    "鏭": "西",
    "爴": "觉",
    "諙": "话",
    "溑": "锁",
    "霼": "系",
    "霷": "羊",
    "燪": "总",
    "窲": "朝",
    "瞊": "荡",
    "謥": "从",
    "鰬": "钱",
    "愂": "被",
    "諿": "七",
    "壦": "熏",
    "驐": "蹲",
    "蹥": "连",
    "擌": "色",
    "餰": "间",
    "騚": "钱",
    "鯲": "鱼",
    "蹘": "聊",
    "聓": "续",
    "袻": "而",
    "濖": "树",
    "覮": "营",
    "軶": "恶",
    "鍯": "聪",
    "饇": "玉",
    "焎": "谢",
    "韯": "先",
    "攐": "前",
    "慃": "养",
    "噕": "灰",
    "縇": "宣",
    "隫": "坟",
    "踻": "瓜",
    "鵵": "兔",
    "橬": "钱",
    "薒": "灿",
    "橌": "现",
    "靀": "盟",
    "樥": "朋",
    "錅": "离",
    "駳": "蛋",
    "魝": "节",
    "稝": "朋",
    "瘷": "色",
    "鶈": "七",
    "襓": "扰",
    "隝": "导",
    "澖": "闲",
    "巈": "局",
    "蜟": "玉",
    "顊": "宜",
    "豟": "恶",
    "釠": "乱",
    "驝": "拖",
    "駯": "朱",
    "鮖": "石",
    "軭": "框",
    "蕵": "孙",
    "憥": "劳",
    "韀": "间",
    "猏": "间",
    "睤": "必",
    "踚": "伦",
    "銯": "思",
    "鞰": "温",
    "鮉": "雕",
    "鵆": "横",
    "鵎": "妥",
    "鉖": "同",
    "攇": "显",
    "鴲": "知",
    "訯": "洒",
    "睈": "成",
    "隦": "角",
    "殦": "雕",
    "鮬": "哭",
    "貋": "按",
    "誛": "亲",
    "謯": "接",
    "潂": "红",
    "鴪": "玉",
    "驨": "习",
    "愸": "整",
    "歄": "瓜",
    "驙": "占",
    "鯯": "至",
    "鞱": "掏",
    "籅": "鱼",
    "艀": "福",
    "鱜": "相",
    "躛": "位",
    "鮼": "亲",
    "鯌": "烤",
    "謰": "连",
    "賆": "偏",
    "讏": "位",
    "鵢": "深",
    "貵": "偏",
    "豛": "意",
    "銟": "插",
    "澻": "岁",
    "訵": "吃",
    "鰘": "是",
    "軖": "狂",
    "驞": "拼",
    "駲": "周",
    "詜": "掏",
    "徚": "东",
    "衻": "然",
    "韢": "岁",
    "駗": "枕",
    "鳹": "琴",
    "鵇": "年",
    "裚": "记",
    "鴤": "中",
    "懄": "琴",
    "訠": "审",
    "軪": "凹",
    "憉": "朋",
    "鮙": "踏",
    "鳫": "燕",
    "霻": "风",
    "韚": "格",
    "鶰": "原",
    "軅": "燕",
    "喸": "捕",
    "蘒": "秋",
    "騇": "设",
    "睓": "舔",
    "幥": "长",
    "騹": "其",
    "髬": "批",
    "鶍": "意",
    "鬜": "前",
    "鶐": "树",
    "誢": "现",
    "褼": "先",
    "鞩": "巧",
    "蕷": "玉",
    "譋": "蓝",
    "餆": "摇",
    "覱": "战",
    "鯞": "肘",
    "潉": "昆",
    "驑": "刘",
    "鯳": "底",
    "鵈": "饿",
    "隯": "导",
    "訍": "拆",
    "鮲": "福"
}

================================================
FILE: ChatTTS/res/sha256_map.json
================================================
{
	"sha256_asset_Decoder_pt"   : "9964e36e840f0e3a748c5f716fe6de6490d2135a5f5155f4a642d51860e2ec38",
	"sha256_asset_DVAE_full_pt"      : "553eb75763511e23f3e5f86303e2163c5ca775489d637fb635d979c8ae58bbe5",
	"sha256_asset_GPT_pt"       : "d7d4ee6461ea097a2be23eb40d73fb94ad3b3d39cb64fbb50cb3357fd466cadb",
	"sha256_asset_spk_stat_pt"  : "3228d8a4cbbf349d107a1b76d2f47820865bd3c9928c4bdfe1cefd5c7071105f",
	"sha256_asset_tokenizer_pt" : "e911ae7c6a7c27953433f35c44227a67838fe229a1f428503bdb6cd3d1bcc69c",
	"sha256_asset_Vocos_pt"     : "09a670eda1c08b740013679c7a90ebb7f1a97646ea7673069a6838e6b51d6c58"
}


================================================
FILE: ChatTTS/utils/__init__.py
================================================
from .dl import check_all_assets, download_all_assets
from .gpu import select_device
from .io import get_latest_modified_file, del_all
from .log import logger


================================================
FILE: ChatTTS/utils/dl.py
================================================
import os
from pathlib import Path
import hashlib
import requests
from io import BytesIO
from typing import Dict
from mmap import mmap, ACCESS_READ

from .log import logger


def sha256(fileno: int) -> str:
    data = mmap(fileno, 0, access=ACCESS_READ)
    h = hashlib.sha256(data).hexdigest()
    del data
    return h


def check_model(
    dir_name: Path, model_name: str, hash: str, remove_incorrect=False
) -> bool:
    target = dir_name / model_name
    relname = target.as_posix()
    logger.get_logger().debug(f"checking {relname}...")
    if not os.path.exists(target):
        logger.get_logger().info(f"{target} not exist.")
        return False
    with open(target, "rb") as f:
        digest = sha256(f.fileno())
        bakfile = f"{target}.bak"
        if digest != hash:
            logger.get_logger().warning(f"{target} sha256 hash mismatch.")
            logger.get_logger().info(f"expected: {hash}")
            logger.get_logger().info(f"real val: {digest}")
            if remove_incorrect:
                if not os.path.exists(bakfile):
                    os.rename(str(target), bakfile)
                else:
                    os.remove(str(target))
            return False
        if remove_incorrect and os.path.exists(bakfile):
            os.remove(bakfile)
    return True


def check_all_assets(base_dir: Path, sha256_map: Dict[str, str], update=False) -> bool:
    logger.get_logger().info("checking assets...")
    current_dir = base_dir / "asset"
    names = [
        "Decoder.pt",
        "DVAE_full.pt",
        "GPT.pt",
        "spk_stat.pt",
        "tokenizer.pt",
        "Vocos.pt",
    ]
    for model in names:
        menv = model.replace(".", "_")
        if not check_model(
            current_dir, model, sha256_map[f"sha256_asset_{menv}"], update
        ):
            return False

    logger.get_logger().info("all assets are already latest.")
    return True


def download_and_extract_tar_gz(url: str, folder: str):
    import tarfile

    logger.get_logger().info(f"downloading {url}")
    response = requests.get(url, stream=True, timeout=(5, 10))
    with BytesIO() as out_file:
        out_file.write(response.content)
        out_file.seek(0)
        logger.get_logger().info(f"downloaded.")
        with tarfile.open(fileobj=out_file, mode="r:gz") as tar:
            tar.extractall(folder)
        logger.get_logger().info(f"extracted into {folder}")


def download_and_extract_zip(url: str, folder: str):
    import zipfile

    logger.get_logger().info(f"downloading {url}")
    response = requests.get(url, stream=True, timeout=(5, 10))
    with BytesIO() as out_file:
        out_file.write(response.content)
        out_file.seek(0)
        logger.get_logger().info(f"downloaded.")
        with zipfile.ZipFile(out_file) as zip_ref:
            zip_ref.extractall(folder)
        logger.get_logger().info(f"extracted into {folder}")


def download_dns_yaml(url: str, folder: str):
    logger.get_logger().info(f"downloading {url}")
    response = requests.get(url, stream=True, timeout=(5, 10))
    with open(os.path.join(folder, "dns.yaml"), "wb") as out_file:
        out_file.write(response.content)
        logger.get_logger().info(f"downloaded into {folder}")


def download_all_assets(tmpdir: str, version="0.2.6"):
    import subprocess
    import platform

    archs = {
        "aarch64": "arm64",
        "armv8l": "arm64",
        "arm64": "arm64",
        "x86": "386",
        "i386": "386",
        "i686": "386",
        "386": "386",
        "x86_64": "amd64",
        "x64": "amd64",
        "amd64": "amd64",
    }
    system_type = platform.system().lower()
    architecture = platform.machine().lower()
    is_win = system_type == "windows"

    architecture = archs.get(architecture, None)
    if not architecture:
        logger.get_logger().error(f"architecture {architecture} is not supported")
        exit(1)
    try:
        BASE_URL = "https://github.com/fumiama/RVC-Models-Downloader/releases/download/"
        suffix = "zip" if is_win else "tar.gz"
        RVCMD_URL = BASE_URL + f"v{version}/rvcmd_{system_type}_{architecture}.{suffix}"
        cmdfile = os.path.join(tmpdir, "rvcmd")
        print(f'{RVCMD_URL=},{tmpdir=}')
        if is_win:
            download_and_extract_zip(RVCMD_URL, tmpdir)
            cmdfile += ".exe"
        else:
            download_and_extract_tar_gz(RVCMD_URL, tmpdir)
            os.chmod(cmdfile, 0o755)
        print(f'{cmdfile=}')
        subprocess.run([cmdfile, "-notui", "-w", "0", "assets/chtts"])
    except Exception:
        BASE_URL = "https://raw.gitcode.com/u011570312/RVC-Models-Downloader/assets/"
        suffix = {
            "darwin_amd64": "987",
            "darwin_arm64": "988",
            "linux_386": "989",
            "linux_amd64": "990",
            "linux_arm64": "991",
            "windows_386": "992",
            "windows_amd64": "993",
        }[f"{system_type}_{architecture}"]
        RVCMD_URL = BASE_URL + suffix
        download_dns_yaml(
            "https://raw.gitcode.com/u011570312/RVC-Models-Downloader/raw/main/dns.yaml",
            tmpdir,
        )
        if is_win:
            download_and_extract_zip(RVCMD_URL, tmpdir)
            cmdfile += ".exe"
        else:
            download_and_extract_tar_gz(RVCMD_URL, tmpdir)
            os.chmod(cmdfile, 0o755)
        subprocess.run(
            [
                cmdfile,
                "-notui",
                "-w",
                "0",
                "-dns",
                os.path.join(tmpdir, "dns.yaml"),
                "assets/chtts",
            ]
        )


================================================
FILE: ChatTTS/utils/download.py
================================================
import os
from pathlib import Path
import hashlib
import requests
from io import BytesIO
import logging

logger = logging.getLogger(__name__)


def sha256(f) -> str:
    sha256_hash = hashlib.sha256()
    # Read and update hash in chunks of 4M
    for byte_block in iter(lambda: f.read(4 * 1024 * 1024), b""):
        sha256_hash.update(byte_block)
    return sha256_hash.hexdigest()


def check_model(
    dir_name: Path, model_name: str, hash: str, remove_incorrect=False
) -> bool:
    target = dir_name / model_name
    relname = target.as_posix()
    logger.debug(f"checking {relname}...")
    if not os.path.exists(target):
        logger.info(f"{target} not exist.")
        return False
    with open(target, "rb") as f:
        digest = sha256(f)
        bakfile = f"{target}.bak"
        if digest != hash:
            logger.warn(f"{target} sha256 hash mismatch.")
            logger.info(f"expected: {hash}")
            logger.info(f"real val: {digest}")
            logger.warn("please add parameter --update to download the latest assets.")
            if remove_incorrect:
                if not os.path.exists(bakfile):
                    os.rename(str(target), bakfile)
                else:
                    os.remove(str(target))
            return False
        if remove_incorrect and os.path.exists(bakfile):
            os.remove(bakfile)
    return True


def check_all_assets(update=False) -> bool:
    BASE_DIR = Path(__file__).resolve().parent.parent.parent

    logger.info("checking assets...")
    current_dir = BASE_DIR / "asset"
    names = [
        "Decoder.pt",
        "DVAE.pt",
        "GPT.pt",
        "spk_stat.pt",
        "tokenizer.pt",
        "Vocos.pt",
    ]
    for model in names:
        menv = model.replace(".", "_")
        if not check_model(
            current_dir, model, os.environ[f"sha256_asset_{menv}"], update
        ):
            return False

    logger.info("checking configs...")
    current_dir = BASE_DIR / "config"
    names = [
        "decoder.yaml",
        "dvae.yaml",
        "gpt.yaml",
        "path.yaml",
        "vocos.yaml",
    ]
    for model in names:
        menv = model.replace(".", "_")
        if not check_model(
            current_dir, model, os.environ[f"sha256_config_{menv}"], update
        ):
            return False

    logger.info("all assets are already latest.")
    return True


def download_and_extract_tar_gz(url: str, folder: str):
    import tarfile

    logger.info(f"downloading {url}")
    response = requests.get(url, stream=True, timeout=(5, 10))
    with BytesIO() as out_file:
        out_file.write(response.content)
        out_file.seek(0)
        logger.info(f"downloaded.")
        with tarfile.open(fileobj=out_file, mode="r:gz") as tar:
            tar.extractall(folder)
        logger.info(f"extracted into {folder}")


def download_and_extract_zip(url: str, folder: str):
    import zipfile

    logger.info(f"downloading {url}")
    response = requests.get(url, stream=True, timeout=(5, 10))
    with BytesIO() as out_file:
        out_file.write(response.content)
        out_file.seek(0)
        logger.info(f"downloaded.")
        with zipfile.ZipFile(out_file) as zip_ref:
            zip_ref.extractall(folder)
        logger.info(f"extracted into {folder}")


def download_dns_yaml(url: str, folder: str):
    logger.info(f"downloading {url}")
    response = requests.get(url, stream=True, timeout=(5, 10))
    with open(os.path.join(folder, "dns.yaml"), "wb") as out_file:
        out_file.write(response.content)
        logger.info(f"downloaded into {folder}")


def download_all_assets(tmpdir: str, version="0.2.5"):
    import subprocess
    import platform

    archs = {
        "aarch64": "arm64",
        "armv8l": "arm64",
        "arm64": "arm64",
        "x86": "386",
        "i386": "386",
        "i686": "386",
        "386": "386",
        "x86_64": "amd64",
        "x64": "amd64",
        "amd64": "amd64",
    }
    system_type = platform.system().lower()
    architecture = platform.machine().lower()
    is_win = system_type == "windows"

    architecture = archs.get(architecture, None)
    if not architecture:
        logger.error(f"architecture {architecture} is not supported")
        exit(1)
    try:
        BASE_URL = "https://github.com/fumiama/RVC-Models-Downloader/releases/download/"
        suffix = "zip" if is_win else "tar.gz"
        RVCMD_URL = BASE_URL + f"v{version}/rvcmd_{system_type}_{architecture}.{suffix}"
        cmdfile = os.path.join(tmpdir, "rvcmd")
        if is_win:
            download_and_extract_zip(RVCMD_URL, tmpdir)
            cmdfile += ".exe"
        else:
            download_and_extract_tar_gz(RVCMD_URL, tmpdir)
            os.chmod(cmdfile, 0o755)
        subprocess.run([cmdfile, "-notui", "-w", "0", "assets/chtts"])
    except Exception:
        BASE_URL = "https://raw.gitcode.com/u011570312/RVC-Models-Downloader/assets/"
        suffix = {
            "darwin_amd64": "555",
            "darwin_arm64": "556",
            "linux_386": "557",
            "linux_amd64": "558",
            "linux_arm64": "559",
            "windows_386": "562",
            "windows_amd64": "563",
        }[f"{system_type}_{architecture}"]
        RVCMD_URL = BASE_URL + suffix
        download_dns_yaml(
            "https://raw.gitcode.com/u011570312/RVC-Models-Downloader/raw/main/dns.yaml",
            tmpdir,
        )
        if is_win:
            download_and_extract_zip(RVCMD_URL, tmpdir)
            cmdfile += ".exe"
        else:
            download_and_extract_tar_gz(RVCMD_URL, tmpdir)
            os.chmod(cmdfile, 0o755)
        subprocess.run(
            [
                cmdfile,
                "-notui",
                "-w",
                "0",
                "-dns",
                os.path.join(tmpdir, "dns.yaml"),
                "assets/chtts",
            ]
        )


================================================
FILE: ChatTTS/utils/gpu.py
================================================
import torch

from .log import logger


def select_device(min_memory=2047, experimental=False):
    if torch.cuda.is_available():
        selected_gpu = 0
        max_free_memory = -1
        for i in range(torch.cuda.device_count()):
            props = torch.cuda.get_device_properties(i)
            free_memory = props.total_memory - torch.cuda.memory_reserved(i)
            if max_free_memory < free_memory:
                selected_gpu = i
                max_free_memory = free_memory
        free_memory_mb = max_free_memory / (1024 * 1024)
        if free_memory_mb < min_memory:
            logger.get_logger().warning(
                f"GPU {selected_gpu} has {round(free_memory_mb, 2)} MB memory left. Switching to CPU."
            )
            device = torch.device("cpu")
        else:
            device = torch.device(f"cuda:{selected_gpu}")
    elif torch.backends.mps.is_available():
        """
        Currently MPS is slower than CPU while needs more memory and core utility,
        so only enable this for experimental use.
        """
        if experimental:
            # For Apple M1/M2 chips with Metal Performance Shaders
            logger.get_logger().warning("experimantal: found apple GPU, using MPS.")
            device = torch.device("mps")
        else:
            logger.get_logger().info("found Apple GPU, but use CPU.")
            device = torch.device("cpu")
    else:
        logger.get_logger().warning("no GPU found, use CPU instead")
        device = torch.device("cpu")

    return device


================================================
FILE: ChatTTS/utils/gpu_utils.py
================================================

import torch
import logging

def select_device(min_memory=2048):
    logger = logging.getLogger(__name__)
    if torch.cuda.is_available():
        available_gpus = []
        for i in range(torch.cuda.device_count()):
            props = torch.cuda.get_device_properties(i)
            free_memory = props.total_memory - torch.cuda.memory_reserved(i)
            available_gpus.append((i, free_memory))
        selected_gpu, max_free_memory = max(available_gpus, key=lambda x: x[1])
        device = torch.device(f'cuda:{selected_gpu}')
        free_memory_mb = max_free_memory / (1024 * 1024)
        if free_memory_mb < min_memory:
            logger.warning(f'GPU {selected_gpu} has {round(free_memory_mb, 2)} MB memory left. Switching to CPU.')
            device = torch.device('cpu')
    elif torch.backends.mps.is_available():
        # For Apple M1/M2 chips with Metal Performance Shaders
        logger.info('Apple GPU found, using MPS.')
        device = torch.device('mps')
    else:
        logger.warning('No GPU found, use CPU instead')
        device = torch.device('cpu')

    return device


================================================
FILE: ChatTTS/utils/infer_utils.py
================================================

import re
import torch
import torch.nn.functional as F
import os
import json

    
class CustomRepetitionPenaltyLogitsProcessorRepeat():

    def __init__(self, penalty: float, max_input_ids, past_window):
        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:
        
        input_ids = input_ids[:, -self.past_window:]
        freq = F.one_hot(input_ids, scores.size(1)).sum(1)
        freq[self.max_input_ids:] = 0
        alpha = self.penalty**freq
        scores = scores.contiguous()
        scores = torch.where(scores < 0, scores*alpha, scores/alpha)

        return scores
    
class CustomRepetitionPenaltyLogitsProcessor():

    def __init__(self, penalty: float, max_input_ids, past_window):
        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:
        
        input_ids = input_ids[:, -self.past_window:]
        score = torch.gather(scores, 1, input_ids)
        _score = score.detach().clone()
        score = torch.where(score < 0, score * self.penalty, score / self.penalty)
        score[input_ids>=self.max_input_ids] = _score[input_ids>=self.max_input_ids]
        scores.scatter_(1, input_ids, score)
        
        return scores

class HomophonesReplacer:
    """
    Homophones Replacer

    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)

    """
    def __init__(self, map_file_path):
        self.homophones_map = self.load_homophones_map(map_file_path)

    def load_homophones_map(self, map_file_path):
        with open(map_file_path, 'r', encoding='utf-8') as f:
            homophones_map = json.load(f)
        return homophones_map

    def replace(self, text):
        result = []
        for char in text:
            if char in self.homophones_map:
                result.append(self.homophones_map[char])
            else:
                result.append(char)
        return ''.join(result)

def count_invalid_characters(s):
    
    s = re.sub(r'\[uv_break\]|\[laugh\]|\[lbreak\]', '', s)
    pattern = re.compile(r'[^\u4e00-\u9fffA-Za-z，。、,\. ]')
    non_alphabetic_chinese_chars = pattern.findall(s)
    return set(non_alphabetic_chinese_chars)

def detect_language(sentence):

    chinese_char_pattern = re.compile(r'[\u4e00-\u9fff]')
    english_word_pattern = re.compile(r'\b[A-Za-z]+\b')

    chinese_chars = chinese_char_pattern.findall(sentence)
    english_words = english_word_pattern.findall(sentence)

    if len(chinese_chars) > len(english_words):
        return "zh"
    else:
        return "en"
    
    
character_map = {
    '：': '，',
    '；': '，',
    '！': '。',
    '（': '，',
    '）': '，',
    '【': '，',
    '】': '，',
    '『': '，',
    '』': '，',
    '「': '，',
    '」': '，',
    '《': '，',
    '》': '，',
    '－': '，',
    '‘': '',
    '“': '',
    '’': '',
    '”': '',
    ':': ',',
    ';': ',',
    '!': '.',
    '(': ',',
    ')': ',',
    #'[': ',',
    #']': ',',
    '>': ',',
    '<': ',',
    '-': ',',
}

halfwidth_2_fullwidth_map = {
        '!': '！',
        '"': '“',
        "'": '‘',
        '#': '＃',
        '$': '＄',
        '%': '％',
        '&': '＆',
        '(': '（',
        ')': '）',
        ',': '，',
        '-': '－',
        '*': '＊',
        '+': '＋',
        '.': '。',
        '/': '／',
        ':': '：',
        ';': '；',
        '<': '＜',
        '=': '＝',
        '>': '＞',
        '?': '？',
        '@': '＠',
        # '[': '［',
        '\\': '＼',
        # ']': '］',
        '^': '＾',
        # '_': '＿',
        '`': '｀',
        '{': '｛',
        '|': '｜',
        '}': '｝',
        '~': '～'
    }

def apply_half2full_map(text):
    translation_table = str.maketrans(halfwidth_2_fullwidth_map)
    return text.translate(translation_table)

def apply_character_map(text):
    translation_table = str.maketrans(character_map)
    return text.translate(translation_table)


================================================
FILE: ChatTTS/utils/io.py
================================================
import os
import logging
from typing import Union
from dataclasses import is_dataclass

from .log import logger


def get_latest_modified_file(directory):

    files = [os.path.join(directory, f) for f in os.listdir(directory)]
    if not files:
        logger.get_logger().log(
            logging.WARNING, f"no files found in the directory: {directory}"
        )
        return None
    latest_file = max(files, key=os.path.getmtime)

    return latest_file


def del_all(d: Union[dict, list]):
    if is_dataclass(d):
        for k in list(vars(d).keys()):
            x = getattr(d, k)
            if isinstance(x, dict) or isinstance(x, list) or is_dataclass(x):
                del_all(x)
            del x
            delattr(d, k)
    elif isinstance(d, dict):
        lst = list(d.keys())
        for k in lst:
            x = d.pop(k)
            if isinstance(x, dict) or isinstance(x, list) or is_dataclass(x):
                del_all(x)
            del x
    elif isinstance(d, list):
        while len(d):
            x = d.pop()
            if isinstance(x, dict) or isinstance(x, list) or is_dataclass(x):
                del_all(x)
            del x
    else:
        del d


================================================
FILE: ChatTTS/utils/io_utils.py
================================================

import os
import logging

def get_latest_modified_file(directory):
    logger = logging.getLogger(__name__)
    
    files = [os.path.join(directory, f) for f in os.listdir(directory)] 
    if not files:
        logger.log(logging.WARNING, f'No files found in the directory: {directory}')
        return None
    latest_file = max(files, key=os.path.getmtime)

    return latest_file

================================================
FILE: ChatTTS/utils/log.py
================================================
import logging
from pathlib import Path


class Logger:
    def __init__(self, logger=logging.getLogger(Path(__file__).parent.name)):
        self.logger = logger

    def set_logger(self, logger: logging.Logger):
        self.logger = logger

    def get_logger(self) -> logging.Logger:
        return self.logger


logger = Logger()


================================================
FILE: Dockerfile.cpu
================================================
FROM pytorch/torchserve:0.11.0-cpu as builder

USER root

RUN apt-get update && apt-get install -y ffmpeg

WORKDIR /app

COPY . ./

RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple


================================================
FILE: Dockerfile.gpu
================================================
FROM pytorch/torchserve:0.11.0-gpu as builder

USER root

RUN apt-get update && apt-get install -y ffmpeg

WORKDIR /app

COPY . ./

RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple


================================================
FILE: LICENSE
================================================
# Attribution-NonCommercial-NoDerivatives 4.0 International

> *Creative Commons Corporation (“Creative Commons”) is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an “as-is” basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.*
>
> ### Using Creative Commons Public Licenses
>
> Creative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.
>
> * __Considerations for licensors:__ Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. [More considerations for licensors](http://wiki.creativecommons.org/Considerations_for_licensors_and_licensees#Considerations_for_licensors).
>
> * __Considerations for the public:__ By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor’s permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. [More considerations for the public](http://wiki.creativecommons.org/Considerations_for_licensors_and_licensees#Considerations_for_licensees).

## Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License

By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.

### Section 1 – Definitions.

a. __Adapted Material__ means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.

b. __Copyright and Similar Rights__ means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.

e. __Effective Technological Measures__ means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.

f. __Exceptions and Limitations__ means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.

h. __Licensed Material__ means the artistic or literary work, database, or other material to which the Licensor applied this Public License.

i. __Licensed Rights__ means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.

h. __Licensor__ means the individual(s) or entity(ies) granting rights under this Public License.

i. __NonCommercial__ means not primarily intended for or directed towards commercial advantage or monetary compensation. For purposes of this Public License, the exchange of the Licensed Material for other material subject to Copyright and Similar Rights by digital file-sharing or similar means is NonCommercial provided there is no payment of monetary compensation in connection with the exchange.

j. __Share__ means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.

k. __Sui Generis Database Rights__ means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.

l. __You__ means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.

### Section 2 – Scope.

a. ___License grant.___

   1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:

        A. reproduce and Share the Licensed Material, in whole or in part, for NonCommercial purposes only; and

        B. produce and reproduce, but not Share, Adapted Material for NonCommercial purposes only.

   2. __Exceptions and Limitations.__ For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.

   3. __Term.__ The term of this Public License is specified in Section 6(a).

   4. __Media and formats; technical modifications allowed.__ The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.

   5. __Downstream recipients.__

        A. __Offer from the Licensor – Licensed Material.__ Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.

        B. __No downstream restrictions.__ You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.

   6. __No endorsement.__ Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).

b. ___Other rights.___

   1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.

   2. Patent and trademark rights are not licensed under this Public License.

   3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties, including when the Licensed Material is used other than for NonCommercial purposes.

### Section 3 – License Conditions.

Your exercise of the Licensed Rights is expressly made subject to the following conditions.

a. ___Attribution.___

   1. If You Share the Licensed Material, You must:

      A. retain the following if it is supplied by the Licensor with the Licensed Material:

         i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);

         ii. a copyright notice;

         iii. a notice that refers to this Public License;

         iv. a notice that refers to the disclaimer of warranties;

         v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;

      B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and

      C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.
 
        For the avoidance of doubt, You do not have permission under this Public License to Share Adapted Material.

   2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.

   3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.

### Section 4 – Sui Generis Database Rights.

Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:

a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database for NonCommercial purposes only and provided You do not Share Adapted Material;

b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and

c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.

For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.

### Section 5 – Disclaimer of Warranties and Limitation of Liability.

a. __Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.__

b. __To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.__

c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.

### Section 6 – Term and Termination.

a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.

b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:

   1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or

   2. upon express reinstatement by the Licensor.

   For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.

c. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.

d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.

### Section 7 – Other Terms and Conditions.

a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.

b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.

### Section 8 – Interpretation.

a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.

b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.

c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.

d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.

> Creative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the “Licensor.” Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at [creativecommons.org/policies](http://creativecommons.org/policies), Creative Commons does not authorize the use of the trademark “Creative Commons” or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.
>
> Creative Commons may be contacted at [creativecommons.org](http://creativecommons.org).


================================================
FILE: README.md
================================================

[English README](README_EN.md) | [打赏项目](https://github.com/jianchang512/ChatTTS-ui/issues/122) | [Discord Discussion Group](https://discord.gg/y9gUweVCCJ)


# ChatTTS webUI & API 

一个简单的本地网页界面，在网页使用 ChatTTS 将文字合成为语音，支持中英文、数字混杂，并提供API接口.


原 [ChatTTS](https://github.com/2noise/chattts) 项目. 0.96版起，源码部署必须先安装ffmpeg ,之前的音色文件csv和pt已不可用，请填写音色值重新生成.[获取音色](?tab=readme-ov-file#音色获取)



**界面预览**

![image](https://github.com/jianchang512/ChatTTS-ui/assets/3378335/669876cf-5061-4d7d-86c5-3333d0882ee8)






文字数字符号 控制符混杂效果

https://github.com/jianchang512/ChatTTS-ui/assets/3378335/e2a08ea0-32af-4a30-8880-3a91f6cbea55


## Windows预打包版

1. 从 [Releases](https://github.com/jianchang512/chatTTS-ui/releases)中下载压缩包，解压后双击 app.exe 即可使用
2. 某些安全软件可能报毒，请退出或使用源码部署
3. 英伟达显卡大于4G显存，并安装了CUDA11.8+后，将启用GPU加速

## 手动下载模型

第一次将从huggingface.co或github下载模型到asset目录下，如果网络不稳，可能下载失败，若是失败，请单独下载

下载后解压后，会看到asset文件夹，该文件夹内有多个pt文件，将所有pt文件复制到asset目录下，然后重启软件

GitHub下载地址: https://github.com/jianchang512/ChatTTS-ui/releases/download/v1.0/all-models.7z

百度网盘下载地址: https://pan.baidu.com/s/1yGDZM9YNN7kW9e7SFo8lLw?pwd=ct5x



## Linux 下容器部署

### 安装

1. 拉取项目仓库

   在任意路径下克隆项目，例如：

   ```bash
   git clone https://github.com/jianchang512/ChatTTS-ui.git chat-tts-ui
   ```

2. 启动 Runner

   进入到项目目录：

   ```bash
   cd chat-tts-ui
   ```

   启动容器并查看初始化日志：

   ```bash
   gpu版本
   docker compose -f docker-compose.gpu.yaml up -d 

   cpu版本    
   docker compose -f docker-compose.cpu.yaml up -d

   docker compose logs -f --no-log-prefix

3. 访问 ChatTTS WebUI

   `启动:['0.0.0.0', '9966']`，也即，访问部署设备的 `IP:9966` 即可，例如：

   - 本机：`http://127.0.0.1:9966`
   - 服务器: `http://192.168.1.100:9966`

### 更新

1. Get the latest code from the main branch:

   ```bash
   git checkout main
   git pull origin main
   ```

2. Go to the next step and update to the latest image:

   ```bash
   docker compose down

   gpu版本
   docker compose -f docker-compose.gpu.yaml up -d --build

   cpu版本
   docker compose -f docker-compose.cpu.yaml up -d --build
   
   docker compose logs -f --no-log-prefix
   ```

## Linux 下源码部署

1. 配置好 python3.9-3.11环境，安装 ffmpeg。 `yum install ffmpeg` 或 `apt-get install ffmpeg`等
2. 创建空目录 `/data/chattts` 执行命令 `cd /data/chattts &&  git clone https://github.com/jianchang512/chatTTS-ui .`
3. 创建虚拟环境 `python3 -m venv venv`
4. 激活虚拟环境 `source ./venv/bin/activate`
5. 安装依赖 `pip3 install -r requirements.txt`
6. 如果不需要CUDA加速，执行 
	
	`pip3 install torch==2.2.0 torchaudio==2.2.0`

	如果需要CUDA加速，执行 
	
	```
	pip install torch==2.2.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118

	pip install nvidia-cublas-cu11 nvidia-cudnn-cu11
		
	```
	
	另需安装 CUDA11.8+ ToolKit，请自行搜索安装方法 或参考 https://juejin.cn/post/7318704408727519270

   	除CUDA外，也可以使用AMD GPU进行加速，这需要安装ROCm和PyTorch_ROCm版本。AMG GPU借助ROCm，在PyTorch开箱即用，无需额外修改代码。
   	1. 请参考https://rocm.docs.amd.com/projects/install-on-linux/en/latest/tutorial/quick-start.html 来安装AMD GPU Driver及ROCm.
	1. 再通过https://pytorch.org/ 安装PyTorch_ROCm版本。


	`pip3 install torch==2.2.0  torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/rocm6.0`
	
    安装完成后，可以通过rocm-smi命令来查看系统中的AMD GPU。也可以用以下Torch代码(query_gpu.py)来查询当前AMD GPU Device.
	
	```
	import torch
	
	print(torch.__version__)
	
	if torch.cuda.is_available():
	    device = torch.device("cuda")          # a CUDA device object
	    print('Using GPU:', torch.cuda.get_device_name(0))
	else:
	    device = torch.device("cpu")
	    print('Using CPU')
	
	torch.cuda.get_device_properties(0)

	```

 	使用以上代码，以AMD Radeon Pro W7900为例，查询设备如下。

 	```
	
 	$ python ~/query_gpu.py
	
	2.4.0.dev20240401+rocm6.0
	
 	Using GPU: AMD Radeon PRO W7900
	
 	```


 
7. 执行 `python3 app.py` 启动，将自动打开浏览器窗口，默认地址 `http://127.0.0.1:9966` (注意：默认从 modelscope 魔塔下载模型，不可使用代理下载，请关闭代理)


## MacOS 下源码部署

1. 配置好 python3.9-3.11 环境,安装git ，执行命令  `brew install libsndfile git python@3.10`
   继续执行

    ```
	brew install ffmpeg
	
    export PATH="/usr/local/opt/python@3.10/bin:$PATH"
	
    source ~/.bash_profile 
	
	source ~/.zshrc
	
    ```
	
2. 创建空目录 `/data/chattts` 执行命令 `cd /data/chattts &&  git clone https://github.com/jianchang512/chatTTS-ui .`
3. 创建虚拟环境 `python3 -m venv venv`
4. 激活虚拟环境 `source ./venv/bin/activate`
5. 安装依赖 `pip3 install -r requirements.txt`
6. 安装torch `pip3 install torch==2.2.0 torchaudio==2.2.0`
7. 执行 `python3 app.py` 启动，将自动打开浏览器窗口，默认地址 `http://127.0.0.1:9966`  (注意：默认从 modelscope 魔塔下载模型，不可使用代理下载，请关闭代理)


## Windows源码部署

1. 下载python3.9-3.11，安装时注意选中`Add Python to environment variables`
2. 下载 ffmpeg.exe 放在 软件目录下的ffmpeg文件夹内
3. 下载并安装git，https://github.com/git-for-windows/git/releases/download/v2.45.1.windows.1/Git-2.45.1-64-bit.exe 
4. 创建空文件夹 `D:/chattts` 并进入，地址栏输入 `cmd`回车，在弹出的cmd窗口中执行命令 `git clone https://github.com/jianchang512/chatTTS-ui .`
5. 创建虚拟环境，执行命令 `python -m venv venv`
6. 激活虚拟环境，执行 `.\venv\scripts\activate`
7. 安装依赖,执行 `pip install -r requirements.txt`
8. 如果不需要CUDA加速，

	执行 `pip install torch==2.2.0 torchaudio==2.2.0`

	如果需要CUDA加速，执行 
	
	`pip install torch==2.2.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118`
	
	另需安装 CUDA11.8+ ToolKit，请自行搜索安装方法或参考 https://juejin.cn/post/7318704408727519270
	
9. 执行 `python app.py` 启动，将自动打开浏览器窗口，默认地址 `http://127.0.0.1:9966`  (注意：默认从 modelscope 魔塔下载模型，不可使用代理下载，请关闭代理)


## 源码部署注意 0.96版本起，必须安装ffmpeg

1. 如果GPU显存低于4G，将强制使用CPU。

2. Windows或Linux下如果显存大于4G并且是英伟达显卡，但源码部署后仍使用CPU，可尝试先卸载torch再重装，卸载`pip uninstall -y torch torchaudio` , 重新安装cuda版torch。`pip install torch==2.2.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118`  。必须已安装CUDA11.8+

3. 默认检测 modelscope 是否可连接，如果可以，则从modelscope下载模型，否则从 huggingface.co下载模型



## 音色获取

0.96版本后，因ChatTTS内核升级，已无法直接使用从该站点下载的pt文件(https://modelscope.cn/studios/ttwwwaa/ChatTTS_Speaker)

因此增加转换脚本 cover-pt.py [Win整合包可以直接下载 cover-pt.exe 文件，和 app.exe 放在同一目录下双击执行](https://github.com/jianchang512/ChatTTS-ui/releases)

执行  `python cover-pt.py` 后将把 `speaker` 目录下的，以 `seed_` 开头，以  `_emb.pt` 结尾的文件，即下载后的默认文件名pt，
转换为可用的编码格式，转换后的pt将改名为以 `_emb-covert.pt` 结尾。

例：

假如  `speaker/seed_2155_restored_emb.pt` 存在这个文件,将被转换为 `speaker/seed_2155_restored_emb-cover.pt`, 然后删掉原pt文件，仅保留该转换后的文件即可





## [常见问题与报错解决方法](faq.md)




## 修改http地址

默认地址是 `http://127.0.0.1:9966`,如果想修改，可打开目录下的 `.env`文件，将 `WEB_ADDRESS=127.0.0.1:9966`改为合适的ip和端口，比如修改为`WEB_ADDRESS=192.168.0.10:9966`以便局域网可访问

## 使用API请求 v0.5+

**请求方法:** POST

**请求地址:** http://127.0.0.1:9966/tts

**请求参数:**

text:	str| 必须， 要合成语音的文字

voice:	可选，默认 2222,  决定音色的数字， 2222 | 7869 | 6653 | 4099 | 5099，可选其一，或者任意传入将随机使用音色

prompt:	str| 可选，默认 空， 设定 笑声、停顿，例如 [oral_2][laugh_0][break_6]

temperature:	float| 可选，  默认 0.3

top_p:	float|  可选， 默认 0.7

top_k:	int|  可选， 默认 20

skip_refine:	int|   可选， 默认0， 1=跳过 refine text，0=不跳过

custom_voice:	int|  可选， 默认0，自定义获取音色值时的种子值，需要大于0的整数，如果设置了则以此为准，将忽略 `voice`


**返回:json数据**

成功返回:
	{code:0,msg:ok,audio_files:[dict1,dict2]}
	
	其中 audio_files 是字典数组，每个元素dict为 {filename:wav文件绝对路径，url:可下载的wav网址}

失败返回:

	{code:1,msg:错误原因}

```

# API调用代码

import requests

res = requests.post('http://127.0.0.1:9966/tts', data={
  "text": "若不懂无需填写",
  "prompt": "",
  "voice": "3333",
  "temperature": 0.3,
  "top_p": 0.7,
  "top_k": 20,
  "skip_refine": 0,
  "custom_voice": 0
})
print(res.json())

#ok
{code:0, msg:'ok', audio_files:[{filename: E:/python/chattts/static/wavs/20240601-22_12_12-c7456293f7b5e4dfd3ff83bbd884a23e.wav, url: http://127.0.0.1:9966/static/wavs/20240601-22_12_12-c7456293f7b5e4dfd3ff83bbd884a23e.wav}]}

#error
{code:1, msg:"error"}


```


## 在pyVideoTrans软件中使用

> 升级 pyVideoTrans 到 1.82+ https://github.com/jianchang512/pyvideotrans

1. 点击菜单-设置-ChatTTS，填写请求地址，默认应该填写 http://127.0.0.1:9966
2. 测试无问题后，在主界面中选择`ChatTTS`

![image](https://github.com/jianchang512/ChatTTS-ui/assets/3378335/7118325f-2b9a-46ce-a584-1d5c6dc8e2da)



================================================
FILE: README_EN.md
================================================

[简体中文](README.md) | [Discord Discussion Group](https://discord.gg/y9gUweVCCJ) | [Support the Project](https://github.com/jianchang512/ChatTTS-ui/issues/122)

# ChatTTS webUI & API 

A simple local web interface to use ChatTTS for text-to-speech synthesis on the web, supporting mixed Chinese and English text and numbers, and providing an API interface.

> The original [ChatTTS](https://github.com/2noise/chattts) project

**Interface Preview**

![image](https://github.com/jianchang512/ChatTTS-ui/assets/3378335/8d9b36d4-29b9-4cd7-ae70-3e3bd3225108)


Sample synthesized voice effects

https://github.com/jianchang512/ChatTTS-ui/assets/3378335/bd6aaef9-a49a-4a81-803a-91e3320bf808

Text and control symbols mixed effect

https://github.com/jianchang512/ChatTTS-ui/assets/3378335/e2a08ea0-32af-4a30-8880-3a91f6cbea55


## Windows Pre-packaged Version

1. Download the compressed package from [Releases](https://github.com/jianchang512/chatTTS-ui/releases), unzip it, and double-click app.exe to use.
2. Some security software may flag it as a virus, please disable or deploy from source.
3. If you have an Nvidia graphics card with more than 4GB of memory and have installed CUDA11.8+, GPU acceleration will be enabled.

## Linux Container Deployment

### Installation

1. Clone the project repository

   Clone the project to any directory, for example:

   ```bash
   git clone https://github.com/jianchang512/ChatTTS-ui.git chat-tts-ui
   ```

2. Start Runner

   Enter the project directory:

   ```bash
   cd chat-tts-ui
   ```

   Start the container and view the initialization logs:

   ```bash
   For GPU version
   docker compose -f docker-compose.gpu.yaml up -d 

   For CPU version    
   docker compose -f docker-compose.cpu.yaml up -d

   docker compose logs -f --no-log-prefix
   ```

3. Access ChatTTS WebUI

   `Started at:['0.0.0.0', '9966']`, meaning you can access it via `IP:9966` of the deployment device, for example:

   - Localhost: `http://127.0.0.1:9966`
   - Server: `http://192.168.1.100:9966`

### Update

1. Get the latest code from the main branch:

   ```bash
   git checkout main
   git pull origin main
   ```

2. Go to the next step and update to the latest image:

   ```bash
   docker compose down

   For GPU version
   docker compose -f docker-compose.gpu.yaml up -d --build

   For CPU version
   docker compose -f docker-compose.cpu.yaml up -d --build
   
   docker compose logs -f --no-log-prefix
   ```

## Linux Source Code Deployment

1. Prepare python3.9-3.11 environment. Install FFmpeg
2. Create an empty directory `/data/chattts` and execute `cd /data/chattts &&  git clone https://github.com/jianchang512/chatTTS-ui .`.
3. Create a virtual environment `python3 -m venv venv`.
4. Activate the virtual environment `source ./venv/bin/activate`.
5. Install dependencies `pip3 install -r requirements.txt`.
6. If CUDA acceleration is not needed, execute 

   `pip3 install torch==2.2.0 torchaudio==2.2.0`

   If CUDA acceleration is needed, execute
   
   ```
   pip install torch==2.2.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118

   pip install nvidia-cublas-cu11 nvidia-cudnn-cu11
   ```
   
   Additionally, install CUDA11.8+ ToolKit, search for installation methods or refer to https://juejin.cn/post/7318704408727519270

   Besides CUDA, AMD GPU acceleration can also be used by installing ROCm and PyTorch_ROCm version. For AMD GPU, with the help of ROCm, PyTorch works out of the box without further modifications.
   1. Refer to https://rocm.docs.amd.com/projects/install-on-linux/en/latest/tutorial/quick-start.html to install AMD GPU Driver and ROCm.
   2. Then install PyTorch_ROCm version from https://pytorch.org/. 

   `pip3 install torch==2.2.0  torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/rocm6.0`

   After installation, you can use the command `rocm-smi` to view the AMD GPUs in the system. The following Torch code(query_gpu.py) can also be used to query the current AMD GPU Device.

   ```
   import torch
   
   print(torch.__version__)
   
   if torch.cuda.is_available():
       device = torch.device("cuda")          # a CUDA device object
       print('Using GPU:', torch.cuda.get_device_name(0))
   else:
       device = torch.device("cpu")
       print('Using CPU')
   
   torch.cuda.get_device_properties(0)

   ```

   Using the code above, for instance, with AMD Radeon Pro W7900, the device query is as follows.

   ```
   
   $ python ~/query_gpu.py
   
   2.4.0.dev20240401+rocm6.0
   
   Using GPU: AMD Radeon PRO W7900
   
   ```


 
7. Execute `python3 app.py` to start. It will automatically open a browser window at `http://127.0.0.1:9966`. Note: Models are downloaded from modelscope by default without using a proxy, please disable the proxy.


## MacOS Source Code Deployment

1. Prepare the python3.9-3.11 environment and install git. Execute command `brew install libsndfile git python@3.10`. Then continue with

   ```
   brew install ffmpeg
   
   export PATH="/usr/local/opt/python@3.10/bin:$PATH"
   
   source ~/.bash_profile 
   
   source ~/.zshrc
   
   ```
   
2. Create an empty directory `/data/chattts` and execute command `cd /data/chattts &&  git clone https://github.com/jianchang512/chatTTS-ui .`.
3. Create a virtual environment `python3 -m venv venv`.
4. Activate the virtual environment `source ./venv/bin/activate`.
5. Install dependencies `pip3 install -r requirements.txt`.
6. Install torch `pip3 install torch==2.2.0 torchaudio==2.2.0`.
7. Execute `python3 app.py` to start. It will automatically open a browser window at `http://127.0.0.1:9966`. Note: Models are downloaded from modelscope by default without using a proxy, please disable the proxy.


## Windows Source Code Deployment

1. Download python3.9-3.11, make sure to check `Add Python to environment variables` during installation. install ffmpeg.exe
2. Download and install git from https://github.com/git-for-windows/git/releases/download/v2.45.1.windows.1/Git-2.45.1-64-bit.exe.
3. Create an empty folder `D:/chattts` and enter it, type `cmd` in the address bar and press Enter. In the cmd window that pops up, execute command `git clone https://github.com/jianchang512/chatTTS-ui .`.
4. Create a virtual environment by executing command `python -m venv venv`.
5. Activate the virtual environment by executing `.\venv\scripts\activate`.
6. Install dependencies by executing `pip install -r requirements.txt`.
7. If CUDA acceleration is not needed,

   execute `pip install torch==2.2.0 torchaudio==2.2.0`.

   If CUDA acceleration is needed, execute 
   
   `pip install torch==2.2.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118`.
   
   Additionally, install CUDA11.8+ ToolKit, search for installation methods or refer to https://juejin.cn/post/7318704408727519270.
   
8. Execute `python app.py` to start. It will automatically open a browser window at `http://127.0.0.1:9966`. Note: Models are downloaded from modelscope by default without using a proxy, please disable the proxy.


## Deployment Notes

0. install ffmpeg since 0.96

1. If the GPU memory is below 4GB, it will forcefully use the CPU.

2. Under Windows or Linux, if the memory is more than 4GB and it is an Nvidia graphics card, but the source code deployment still uses CPU, you may try uninstalling torch first and then reinstalling it. Uninstall with `pip uninstall -y torch torchaudio`, then reinstall the CUDA version of torch `pip install torch==2.2.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118`. CUDA11.8+ must be installed.

3. By default, it checks whether modelscope can be connected. If so, models are downloaded from modelscope; otherwise, models are downloaded from huggingface.co.


## [FAQs and Troubleshooting](faq.md)




## Modify HTTP Address

The default address is `http://127.0.0.1:9966`. If you want to modify it, open the `.env` file in the directory and change `WEB_ADDRESS=127.0.0.1:9966` to the appropriate IP and port, such as changing to `WEB_ADDRESS=192.168.0.10:9966` for LAN access.

## Using API Requests v0.5+

**Method:** POST

**URL:** http://127.0.0.1:9966/tts

**Parameters:**

text: str| Required, text to synthesize.

voice: int| Optional, default 2222. Determines the voice digit, choose from 2222 | 7869 | 6653 | 4099 | 5099, or any input will randomly use a voice.

prompt: str| Optional, default empty. Sets laughter, pause, etc., like [oral_2][laugh_0][break_6].

temperature: float| Optional, default 0.3.

top_p: float| Optional, default 0.7.

top_k: int| Optional, default 20.

skip_refine: int| Optional, default 0. 1=skip refine text, 0=do not skip.

custom_voice: int| Optional, default 0. Sets a custom seed value for obtaining the voice, must be a positive integer. If set, it will take precedence over `voice`.


**Response: JSON**

Success:
	{code:0,msg:ok,audio_files:[dict1,dict2]}
	
	where audio_files is an array of dictionaries, each element dict is {filename:absolute path to wav file, url:downloadable wav URL}

Failure:

	{code:1,msg:error reason}


```

# API Call Code

import requests

res = requests.post('http://127.0.0.1:9966/tts', data={
  "text": "No need to fill if unsure",
  "prompt": "",
  "voice": "3333",
  "temperature": 0.3,
  "top_p": 0.7,
  "top_k": 20,
  "skip_refine": 0,
  "custom_voice": 0,
})
print(res.json())

#ok
{code:0, msg:'ok', audio_files:[{filename: E:/python/chattts/static/wavs/20240601-22_12_12-c7456293f7b5e4dfd3ff83bbd884a23e.wav, url: http://127.0.0.1:9966/static/wavs/20240601-22_12_12-c7456293f7b5e4dfd3ff83bbd884a23e.wav}]}

#error
{code:1, msg:"error"}


```


## Using in pyVideoTrans software

> Upgrade pyVideoTrans to 1.82+ https://github.com/jianchang512/pyvideotrans

1. Click Menu-Settings-ChatTTS and fill in the request address, which should by default be http://127.0.0.1:9966.
2. After ensuring there are no issues, select `ChatTTS` on the main interface.

![image](https://github.com/jianchang512/ChatTTS-ui/assets/3378335/7118325f-2b9a-46ce-a584-1d5c6dc8e2da)



================================================
FILE: app.py
================================================
import os
import re
import sys

if sys.platform == "darwin":
    os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
import io
import json
import torchaudio
import wave
from pathlib import Path

print("Starting...")
import shutil
import time

import torch
import torch._dynamo

torch._dynamo.config.suppress_errors = True
torch._dynamo.config.cache_size_limit = 64
torch._dynamo.config.suppress_errors = True
torch.set_float32_matmul_precision("high")
os.environ["KMP_DUPLICATE_LIB_OK"] = "True"
import subprocess
import soundfile as sf
import ChatTTS
import datetime
from dotenv import load_dotenv

load_dotenv()
from flask import (
    Flask,
    request,
    render_template,
    jsonify,
    send_from_directory,
    send_file,
    Response,
    stream_with_context,
)
import logging
from logging.handlers import RotatingFileHandler
from waitress import serve
from random import random
from modelscope import snapshot_download
import numpy as np
import threading
from uilib.cfg import WEB_ADDRESS, SPEAKER_DIR, LOGS_DIR, WAVS_DIR, MODEL_DIR, ROOT_DIR
from uilib import utils, VERSION
from ChatTTS.utils import select_device
from uilib.utils import is_chinese_os, modelscope_status

merge_size = int(os.getenv("merge_size", 10))
env_lang = os.getenv("lang", "")
if env_lang == "zh":
    is_cn = True
elif env_lang == "en":
    is_cn = False
else:
    is_cn = is_chinese_os()

if not shutil.which("ffmpeg"):
    print("请先安装ffmpeg")
    time.sleep(60)
    exit()


chat = ChatTTS.Chat()
device_str = os.getenv("device", "default")

if device_str in ["default", "mps"]:
    device = select_device(min_memory=2047, experimental=True if device_str == "mps" else False)
elif device_str == "cuda":
    device = select_device(min_memory=2047)
elif device_str == "cpu":
    device = torch.device("cpu")


chat.load(
    source="local" if not os.path.exists(MODEL_DIR + "/DVAE_full.pt") else "custom",
    custom_path=ROOT_DIR,
    device=device,
    compile=True if os.getenv("compile", "true").lower() != "false" else False,
)


# 配置日志
# 禁用 Werkzeug 默认的日志处理器
log = logging.getLogger("werkzeug")
log.handlers[:] = []
log.setLevel(logging.WARNING)

app = Flask(
    __name__,
    static_folder=ROOT_DIR + "/static",
    static_url_path="/static",
    template_folder=ROOT_DIR + "/templates",
)

root_log = logging.getLogger()  # Flask的根日志记录器
root_log.handlers = []
root_log.setLevel(logging.WARNING)
app.logger.setLevel(logging.WARNING)
# 创建 RotatingFileHandler 对象，设置写入的文件路径和大小限制
file_handler = RotatingFileHandler(
    LOGS_DIR + f'/{datetime.datetime.now().strftime("%Y%m%d")}.log',
    maxBytes=1024 * 1024,
    backupCount=5,
)
# 创建日志的格式
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
# 设置文件处理器的级别和格式
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(formatter)
# 将文件处理器添加到日志记录器中
app.logger.addHandler(file_handler)
app.jinja_env.globals.update(enumerate=enumerate)


@app.route("/static/<path:filename>")
def static_files(filename):
    return send_from_directory(app.config["STATIC_FOLDER"], filename)


@app.route("/")
def index():
    speakers = utils.get_speakers()
    return render_template(
        f"index{'' if is_cn else 'en'}.html", weburl=WEB_ADDRESS, speakers=speakers, version=VERSION
    )


# 根据文本返回tts结果，返回 filename=文件名 url=可下载地址
# 请求端根据需要自行选择使用哪个
# params:
#
# text:待合成文字
# prompt：
# voice：音色
# custom_voice：自定义音色值
# skip_refine: 1=跳过refine_text阶段，0=不跳过
# temperature
# top_p
# top_k
# speed
# text_seed
# refine_max_new_token
# infer_max_new_token
# wav

audio_queue = []


@app.route("/tts", methods=["GET", "POST"])
def tts():
    global audio_queue
    # 原始字符串
    text = request.args.get("text", "").strip() or request.form.get("text", "").strip()
    prompt = request.args.get("prompt", "").strip() or request.form.get("prompt", "")

    # 默认值
    defaults = {
        "custom_voice": 0,
        "voice": "2222",
        "temperature": 0.3,
        "top_p": 0.7,
        "top_k": 20,
        "skip_refine": 0,
        "speed": 5,
        "text_seed": 42,
        "refine_max_new_token": 384,
        "infer_max_new_token": 2048,
        "wav": 0,
        "is_stream": 0,
    }

    # 获取
    custom_voice = utils.get_parameter(request, "custom_voice", defaults["custom_voice"], int)
    voice = (
        str(custom_voice)
        if custom_voice > 0
        else utils.get_parameter(request, "voice", defaults["voice"], str)
    )
    temperature = utils.get_parameter(request, "temperature", defaults["temperature"], float)
    top_p = utils.get_parameter(request, "top_p", defaults["top_p"], float)
    top_k = utils.get_parameter(request, "top_k", defaults["top_k"], int)
    skip_refine = utils.get_parameter(request, "skip_refine", defaults["skip_refine"], int)
    is_stream = utils.get_parameter(request, "is_stream", defaults["is_stream"], int)
    speed = utils.get_parameter(request, "speed", defaults["speed"], int)
    text_seed = utils.get_parameter(request, "text_seed", defaults["text_seed"], int)
    refine_max_new_token = utils.get_parameter(
        request, "refine_max_new_token", defaults["refine_max_new_token"], int
    )
    infer_max_new_token = utils.get_parameter(
        request, "infer_max_new_token", defaults["infer_max_new_token"], int
    )
    wav = utils.get_parameter(request, "wav", defaults["wav"], int)

    app.logger.info(f"[tts]{text=}\n{voice=},{skip_refine=}\n")
    if not text:
        return jsonify({"code": 1, "msg": "text params lost"})
    # 固定音色
    rand_spk = None
    # voice可能是 {voice}.csv or {voice}.pt or number
    voice = voice.replace(".csv", ".pt")
    seed_path = f"{SPEAKER_DIR}/{voice}"
    print(f"{voice=}")
    # if voice.endswith('.csv') and os.path.exists(seed_path):
    #    rand_spk=utils.load_speaker(voice)
    #    print(f'当前使用音色 {seed_path=}')
    # el

    if voice.endswith(".pt") and os.path.exists(seed_path):
        # 如果.env中未指定设备，则使用 ChatTTS相同算法找设备，否则使用指定设备
        rand_spk = torch.load(seed_path, map_location=device)
        print(f"当前使用音色 {seed_path=}")
    # 否则 判断是否存在 {voice}.csv
    # elif os.path.exists(f'{SPEAKER_DIR}/{voice}.csv'):
    #    rand_spk=utils.load_speaker(voice)
    #    print(f'当前使用音色 {SPEAKER_DIR}/{voice}.csv')

    if rand_spk is None:
        print(f"当前使用音色：根据seed={voice}获取随机音色")
        voice_int = re.findall(r"^(\d+)", voice)
        if len(voice_int) > 0:
            voice = int(voice_int[0])
        else:
            voice = 2222
        torch.manual_seed(voice)
        # std, mean = chat.sample_random_speaker
        rand_spk = chat.sample_random_speaker()
        # rand_spk = torch.randn(768) * std + mean
        # 保存音色
        torch.save(rand_spk, f"{SPEAKER_DIR}/{voice}.pt")
        # utils.save_speaker(voice,rand_spk)

    audio_files = []

    start_time = time.time()

    # 中英按语言分行
    text_list = [t.strip() for t in text.split("\n") if t.strip()]
    new_text = utils.split_text(text_list)
    if text_seed > 0:
        torch.manual_seed(text_seed)

    params_infer_code = ChatTTS.Chat.InferCodeParams(
        spk_emb=rand_spk,
        prompt=f"[speed_{speed}]",
        top_P=top_p,
        top_K=top_k,
        temperature=temperature,
        max_new_token=infer_max_new_token,
    )
    params_refine_text = ChatTTS.Chat.RefineTextParams(
        prompt=prompt,
        top_P=top_p,
        top_K=top_k,
        temperature=temperature,
        max_new_token=refine_max_new_token,
    )
    print(f"{prompt=}")
    # 将少于30个字符的行同其他行拼接
    retext = []
    short_text = ""
    for it in new_text:
        if len(it) < 30:
            short_text += f"{it} [uv_break] "
            if len(short_text) > 30:
                retext.append(short_text)
                short_text = ""
        else:
            retext.append(short_text + it)
            short_text = ""
    if len(short_text) > 30 or len(retext) < 1:
        retext.append(short_text)
    elif short_text:
        retext[-1] += f" [uv_break] {short_text}"

    new_text = retext

    new_text_list = [new_text[i : i + merge_size] for i in range(0, len(new_text), merge_size)]
    filename_list = []

    audio_time = 0
    inter_time = 0

    for i, te in enumerate(new_text_list):
        print(f"{te=}")
        wavs = chat.infer(
            te,
            # use_decoder=False,
            stream=True if is_stream == 1 else False,
            skip_refine_text=skip_refine,
            do_text_normalization=False,
            do_homophone_replacement=True,
            params_refine_text=params_refine_text,
            params_infer_code=params_infer_code,
        )

        end_time = time.time()
        inference_time = end_time - start_time
        inference_time_rounded = round(inference_time, 2)
        inter_time += inference_time_rounded
        print(f"推理时长: {inference_time_rounded} 秒")

        for j, w in enumerate(wavs):
            filename = (
                datetime.datetime.now().strftime("%H%M%S_")
                + f"use{inference_time_rounded}s-seed{voice}-te{temperature}-tp{top_p}-tk{top_k}-textlen{len(text)}-{str(random())[2:7]}"
                + f"-{i}-{j}.wav"
            )
            filename_list.append(filename)
            torchaudio.save(WAVS_DIR + "/" + filename, torch.from_numpy(w).unsqueeze(0), 24000)

    txt_tmp = "\n".join([f"file '{WAVS_DIR}/{it}'" for it in filename_list])
    txt_name = f"{time.time()}.txt"
    with open(f"{WAVS_DIR}/{txt_name}", "w", encoding="utf-8") as f:
        f.write(txt_tmp)
    outname = (
        datetime.datetime.now().strftime("%H%M%S_")
        + f"use{inter_time}s-audio{audio_time}s-seed{voice}-te{temperature}-tp{top_p}-tk{top_k}-textlen{len(text)}-{str(random())[2:7]}"
        + "-merge.wav"
    )
    try:
        subprocess.run(
            [
                "ffmpeg",
                "-hide_banner",
                "-ignore_unknown",
                "-y",
                "-f",
                "concat",
                "-safe",
                "0",
                "-i",
                f"{WAVS_DIR}/{txt_name}",
                "-c:a",
                "copy",
                WAVS_DIR + "/" + outname,
            ],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            encoding="utf-8",
            check=True,
            text=True,
            creationflags=0 if sys.platform != "win32" else subprocess.CREATE_NO_WINDOW,
        )
    except Exception as e:
        return jsonify({"code": 1, "msg": str(e)})

    audio_path = WAVS_DIR + "/" + outname
    try:
        #  使用 soundfile
        audio_info = sf.info(audio_path)
        audio_duration = round(audio_info.duration, 2)
    except Exception as e:
        print(f"计算音频时长失败: {e}")
        audio_duration = -1

    relative_url = f"/static/wavs/{outname}"
    audio_files.append(
        {
            "filename": audio_path,
            "url": f"http://{request.host}{relative_url}",
            "relative_url": relative_url,
            "inference_time": round(inter_time, 2),
            "audio_duration": audio_duration,
        }
    )
    result_dict = {"code": 0, "msg": "ok", "audio_files": audio_files}
    try:
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
    except Exception:
        pass
    # 兼容pyVideoTrans接口调用
    if len(audio_files) == 1:
        result_dict["filename"] = audio_files[0]["filename"]
        result_dict["url"] = audio_files[0]["url"]
        result_dict["relative_url"] = audio_files[0]["relative_url"]

    if wav > 0:
        return send_file(audio_files[0]["filename"], mimetype="audio/x-wav")
    else:
        return jsonify(result_dict)


@app.route("/clear_wavs", methods=["POST"])
def clear_wavs():
    dir_path = "static/wavs"  # wav音频文件存储目录
    success, message = utils.ClearWav(dir_path)
    if success:
        return jsonify({"code": 0, "msg": message})
    else:
        return jsonify({"code": 1, "msg": message})


try:
    host = WEB_ADDRESS.split(":")
    print(f"Start:{WEB_ADDRESS}")
    threading.Thread(target=utils.openweb, args=(f"http://{WEB_ADDRESS}",)).start()
    serve(app, host=host[0], port=int(host[1]))
except Exception as e:
    print(e)


================================================
FILE: asset/模型下载说明.txt
================================================
如果无法下载模型，请去下载  https://github.com/jianchang512/ChatTTS-ui/releases/download/v1.0/all-models.7z


下载后解压后，会看到asset文件夹，该文件夹内有多个pt文件，将所有pt文件复制到本目录下，然后重启软件

================================================
FILE: cover-pt.py
================================================
'''
0.96版本后，因ChatTTS内核升级，已无法直接使用从该站点下载的pt文件。

https://modelscope.cn/studios/ttwwwaa/ChatTTS_Speaker

因此增加该转换脚本。

执行  python cover-pt.py 后将把 `speaker` 目录下的，以 seed_ 开头，
以  _emb.pt 结尾的文件，即下载后的默认文件名，
转换为可用的编码格式，转换后的pt将改名为以 `_emb-covert.pt` 结尾。

例：

假如  speaker/seed_2155_restored_emb.pt 存在这个文件

将被转换为 speaker/seed_2155_restored_emb-cover.pt, 

然后删掉原pt文件，仅保留该转换后的文件即可



'''

import os
import re
import sys
if sys.platform == "darwin":
    os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
import io
import json
import torchaudio
import wave
from pathlib import Path
print('Starting...')
import shutil
import time


import torch
import torch._dynamo
torch._dynamo.config.suppress_errors = True
torch._dynamo.config.cache_size_limit = 64
torch._dynamo.config.suppress_errors = True
torch.set_float32_matmul_precision('high')
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
import subprocess
import soundfile as sf
import ChatTTS
import datetime
from dotenv import load_dotenv
load_dotenv()

import logging
from logging.handlers import RotatingFileHandler

from random import random
from modelscope import snapshot_download
import numpy as np
import threading
from uilib.cfg import WEB_ADDRESS, SPEAKER_DIR, LOGS_DIR, WAVS_DIR, MODEL_DIR, ROOT_DIR
from uilib import utils,VERSION
from ChatTTS.utils import select_device
from uilib.utils import is_chinese_os,modelscope_status
merge_size=int(os.getenv('merge_size',10))
env_lang=os.getenv('lang','')
if env_lang=='zh':
    is_cn= True
elif env_lang=='en':
    is_cn=False
else:
    is_cn=is_chinese_os()
    


chat = ChatTTS.Chat()
device_str=os.getenv('device','default')

if device_str in ['default','mps']:
    device=select_device(min_memory=2047,experimental=True if device_str=='mps' else False)
elif device_str =='cuda':
    device=select_device(min_memory=2047)
elif device_str == 'cpu':
    device = torch.device("cpu")


chat.load(source="custom",custom_path=ROOT_DIR, device=device,compile=True if os.getenv('compile','true').lower()!='false' else False)
n=0
for it in os.listdir('./speaker'):
    if it.startswith('seed_') and not it.endswith('_emb-covert.pt'):
        print(f'开始转换 {it}')        
        n+=1
        rand_spk=torch.load(f'./speaker/{it}', map_location=device)

        torch.save( chat._encode_spk_emb(rand_spk) ,f"{SPEAKER_DIR}/{it.replace('.pt','-covert.pt')}")
if n==0:
    print('没有可转换的pt文件，仅转换以 seed_ 开头，并以 _emb.pt 结尾的文件')

else:
    print(f'转换完成{n}个，可以删掉以 _emb.pt 结尾的文件了，注意保留 -covert.pt 结尾的文件')

print(f'\n\n30s后本窗口自动关闭')
time.sleep(30)

================================================
FILE: docker-compose.cpu.yaml
================================================
services:
  chat-tts-ui:
    build:
      context: .
      dockerfile: Dockerfile.cpu
    container_name: chat-tts-ui
    restart: always
    volumes:
      - "./:/app"
    ports:
      - 9966:9966
    user: "${UID}:${GID}"
    environment:
      LOG_LEVEL: DEBUG
      WEB_ADDRESS: 0.0.0.0:9966
    command: python3 app.py


================================================
FILE: docker-compose.gpu.yaml
================================================
services:
  chat-tts-ui:
    build:
      context: .
      dockerfile: Dockerfile.gpu
    container_name: chat-tts-ui
    restart: always
    volumes:
      - "./:/app"
    ports:
      - 9966:9966
    user: "${UID}:${GID}"
    environment:
      LOG_LEVEL: DEBUG
      WEB_ADDRESS: 0.0.0.0:9966
      NVIDIA_VISIBLE_DEVICES: all
    command: python3 app.py
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: [gpu]


================================================
FILE: faq.md
================================================
# 常见问题与报错


**注意：不同机器使用相同种子生成的音频音色可能不同，同一机器使用相同种子多次生成的音频音色也可能变化。**


**升级到0.96版后报错**

答： 0.96版起，源码部署必须先安装ffmpeg 

0.96版起，之前的音色文件csv和pt已不可用，请填写音色值重新生成，或到以下站点下载  
 
https://modelscope.cn/studios/ttwwwaa/ChatTTS_Speaker


**0.** 执行app.py报错 FileNotFoundError: [Errno 2] No such file or directory: '../ChatTTS-ui/models/pzc163/chatTTS/config/path.yaml

答：模型不完整，重新下载模型或者 打开 https://www.modelscope.cn/models/pzc163/chatTTS/files 下载 path.yaml 、复制到报错里显示的文件夹内 ChatTTS-ui/models/pzc163/chatTTS/config/



**1.**  MacOS 报错 `Initializing libomp.dylib, but found libiomp5.dylib already initialized`

> 答：在app.py的 `import os` 的下一行，添加代码
>   
> `os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'`


**2.**  MacOS 无报错但进度条一直百分之0 卡住不动

> 答：app.py 中 
> 
> `chat.load_models(source="local",local_path=CHATTTS_DIR)` 
> 
> 改为
> 
> `chat.load_models(source="local",local_path=CHATTTS_DIR,compile=False)`

**3.**  MacOS 报 `libomp` 相关错误

> 答：执行  `brew install libomp`

**4.**  报https相关错误 `ProxyError: HTTPSConnectionPool(host='www.modelscope.cn', port=443)`

> 答：从 modelscope 魔塔下载模型时不可使用代理，请关闭代理


**5.**  报错丢失文件 `Missing spk_stat.pt`

> 答：本项目(ChatTTS-ui)默认从 modelscope 即魔塔社区下载模型，但该库里的模型缺少 spk_stat.pt文件
> 
>   请科学上网后从
>
>   https://huggingface.co/2Noise/ChatTTS/blob/main/asset/spk_stat.pt    
> 
>  下载 spk_stat.pt， 然后复制 spk_stat.pt  到报错提示的目录下，以本项目为例，需要复制到  `models/pzc163/chatTTS/asset`  文件夹内


**6.**  报错 `Dynamo is not supported on Python 3.12`

> 答：不支持python3.12+版本，降级到 python3.10


**7.**  MacOS报错 `NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+`

> 答：执行  `brew install openssl@1.1`  
> 
>  执行   `pip install urllib3==1.26.15



**8.**  Windows上报错：`Windows not yet supported for torch.compile`

> 答：`chat.load_models(compile=False)`  改为   `chat.load_models(compile=False,device="cpu")`


**9.**   Windows上可以运行有GPU，但很慢

> 答：如果是英伟达显卡，请将cuda升级到11.8+


**10**. 下载模型时出现 proxy 类型错误

答：默认会从 modelscope 下载模型，但 modelscope 仅允许中国大陆ip下载，如果遇到 proxy 类错误，请关闭代理。如果你希望从 huggingface.co 下载模型，请打开 `app.py` 查看大约第50行-60行的代码注释。


**11.** 中英分词是怎么回事

答：如果选中中英分词，那么将会把文字中的中文和英文分离出来单独合成，同时将对应的数字 转为相应语言的文字，比如 中文下123转为一二三，英文下123转为 one two three


**12.** Runtime Error:cannot find a working triton installation 

打开 .env  将 compile=true 改为 compile=false

**13.** MacOS下无法安装 soundfile

答：打开终端，执行 `brew install libsndfile` 然后再安装 soundfile


**14.** 如何离线使用

答：

1. 使用源码部署
2. 先运行一次，确保模型下载完毕
3. 打开 app.py 大约35行， `CHATTTS_DIR = snapshot_download('pzc163/chatTTS',cache_dir=MODEL_DIR)` 改为 `CHATTTS_DIR = MODEL_DIR+"/pzc163/chatTTS"`

**15.** ChatTTS原始项目新版本有兼容问题，可能会报错 “报错 Normalizer pynini WeTextProcessing nemo_text_processing ”

解决方法：
新版使用了 nemo_text_processing  和  pynini 来处理中文，但遗憾的是，pynini压根无法在windows平台安装和使用，要使用，也只能安装在WSL子系统上。

不管给出的什么安装方式， 比如 

```
pip install pynini==2.1.5 Cython   WeTextProcessing

```

都是无法在Windows上正确安装的

![image](https://github.com/2noise/ChatTTS/assets/3378335/e32c50d1-492c-4b72-958b-78af0575e662)


----

解决方法:
打开 ChatTTS/core.py, 大约143行，注释掉接下来的7行，

![image](https://github.com/2noise/ChatTTS/assets/3378335/5bdd3dc8-0c7c-485f-b5dc-613f14917319)


问题解决

或者 chat.infer() 添加参数 do_text_normalization=False， chat.infer(do_text_normalization=False)


================================================
FILE: ffmpeg/ffmpeg下载.txt
================================================
Windows源码部署需下载 ffmpeg.exe 放在这里  
https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2023-11-30-12-55/ffmpeg-n6.0.1-win64-gpl-6.0.zip

Mac和Linux需命令行下载

Mac: brew install ffmpeg

Debian:  apt-get install ffmpeg

Centos:  yum install ffmpeg

================================================
FILE: pyproject.toml
================================================
[tool.poetry]
name = "chattts-ui"
version = "0.1.0"
description = "一个简单的本地网页界面，直接使用ChatTTS将文字合成为语音，同时支持对外提供API接口。"
authors = ["jianchang512 <jianchang512@gmail.com>"]
readme = "README.md"
homepage = "https://github.com/jianchang512/ChatTTS-ui"
repository = "https://github.com/jianchang512/ChatTTS-ui"
documentation = "https://github.com/jianchang512/ChatTTS-ui"
package-mode = false

[tool.poetry.dependencies]
python = "^3.10"
soundfile = "^0.12.1"
python-dotenv = "^1.0.1"
flask = "^3.0.3"
waitress = "^3.0.0"
modelscope = "^1.14.0"
langsegment = "^0.3.3"
omegaconf = "^2.3.0"
tokenizers = "^0.19.1"
transformers = "^4.41.2"
torch = [
    { version = "^2.3.0+cu118", source = "pytorch-gpu-src" },
    { platform = "darwin", version = "^2" }
]
torchaudio = [
    { version = "^2.3.0+cu118", source = "pytorch-gpu-src" },
    { platform = "darwin", version = "^2" }
]
vocos = "^0.1.0"
vector-quantize-pytorch = "^1.14.24"
numpy = { version = "^1.26.4" }

# Optional dependencies that are not downloaded by default
fastapi = { version = "*", extras = ["all"], optional = true }
pydantic = { version = "^2", optional = true }

[[tool.poetry.source]]
name = "pytorch-gpu-src"
url = "https://download.pytorch.org/whl/cu118"
priority = "explicit"

[tool.poetry.group.dev.dependencies]
black = "*"
ruff = "*"

[tool.poetry.group.test.dependencies]
# https://docs.pytest.org/en/stable/reference/plugin_list.html#plugin-list
# https://docs.pytest.org/en/stable/contents.html
pytest = "*"
# https://pytest-asyncio.readthedocs.io/en/latest/
pytest-asyncio = "*"

[tool.black]
line-length = 100
target-version = ["py310", "py311", "py312"]
skip-magic-trailing-comma = true
exclude = '''
/(
    ChatTTS
    | .*
    | build
    | dist
    | migrations
    | __pycache__
)/
'''

[tool.pytest.ini_options]
# https://docs.pytest.org/en/stable/reference/reference.html#configuration-options
testpaths = ["tests", "examples"]
asyncio_mode = "auto"
filterwarnings = "ignore::DeprecationWarning"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"


================================================
FILE: requirements.txt
================================================
Flask
ipython
modelscope
numpy==1.26.4
numba
einops
tqdm
omegaconf>=2.3.0
torch>=2.1.0
python-dotenv
requests
soundfile
tokenizers
transformers==4.41.1
vector-quantize-pytorch
vocos
waitress
pybase16384
pynini==2.1.5; sys_platform == 'linux'
WeTextProcessing; sys_platform == 'linux'
nemo_text_processing; sys_platform == 'linux'
av
pydub
pandas


================================================
FILE: run.bat
================================================
@echo off

.\venv\scripts\python.exe app.py
pause

================================================
FILE: run.py
================================================
import os, sys

if sys.platform == "darwin":
    os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"

now_dir = os.getcwd()
sys.path.append(now_dir)

from dotenv import load_dotenv
load_dotenv("sha256.env")

import wave
import ChatTTS
from IPython.display import Audio
import numpy as np

def save_wav_file(wav, index):
    wav_filename = f"output_audio_{index}.wav"
    # Convert numpy array to bytes and write to WAV file
    wav_bytes = (wav * 32768).astype('int16').tobytes()
    with wave.open(wav_filename, "wb") as wf:
        wf.setnchannels(1)  # Mono channel
        wf.setsampwidth(2)  # Sample width in bytes
        wf.setframerate(24000)  # Sample rate in Hz
        wf.writeframes(wav_bytes)
    print(f"Audio saved to {wav_filename}")

def main():
    # Retrieve text from command line argument
    try:
        sys.argv.remove('--stream')
        stream = True
    except:
        stream = False
    text_input = sys.argv[1] if len(sys.argv) > 1 else "<YOUR TEXT HERE>"
    print("Received text input:", text_input)

    chat = ChatTTS.Chat()
    print("Initializing ChatTTS...")
    # if using macbook(M1), I suggest you set `device='cpu', compile=False`
    #chat.load_models()
    chat.load_models(source="custom",custom_path='./models/pzc163/chattts')
    print("Models loaded successfully.")

    texts = [text_input]
    print("Text prepared for inference:", texts)

    wavs_gen = chat.infer(texts, use_decoder=True, stream=stream)
    print("Inference completed. Audio generation successful.")
    # Save each generated wav file to a local file

    if stream:
        print('generate with stream mode ..')
        wavs = [np.array([[]])]
        for gen in wavs_gen:
            print('got new chunk', gen)
            tmp=[np.array([[]])]
            tmp[0]=np.hstack([tmp[0], np.array(gen[0])])
            save_wav_file(tmp[0], 11)
            wavs[0] = np.hstack([wavs[0], np.array(gen[0])])
    else:
        print('generate without stream mode ..')
        wavs = wavs_gen

    for index, wav in enumerate(wavs):
        save_wav_file(wav, index)

    return Audio(wavs[0], rate=24_000, autoplay=True)

if __name__ == "__main__":
    print("Starting the TTS application...")
    main()
    print("TTS application finished.")


================================================
FILE: runtest.bat
================================================
@echo off

.\venv\scripts\python.exe test.py
pause

================================================
FILE: start.bat
================================================
@echo off
cd /d D:\ChatTTS-ui
call .\venv\Scripts\activate
python app.py
pause

================================================
FILE: static/js/layer/layer.js
================================================
/*! layer-v3.5.1 Web 通用弹出层组件 MIT License */
 ;!function(e,t){"use strict";var i,n,a=e.layui&&layui.define,o={getPath:function(){var t=document.currentScript?document.currentScript.src:function(){for(var e,t=document.scripts,i=t.length-1,n=i;n>0;n--)if("interactive"===t[n].readyState){e=t[n].src;break}return e||t[i].src}(),i=e.LAYUI_GLOBAL||{};return i.layer_dir||t.substring(0,t.lastIndexOf("/")+1)}(),config:{},end:{},minIndex:0,minLeft:[],btn:["&#x786E;&#x5B9A;","&#x53D6;&#x6D88;"],type:["dialog","page","iframe","loading","tips"],getStyle:function(t,i){var n=t.currentStyle?t.currentStyle:e.getComputedStyle(t,null);return n[n.getPropertyValue?"getPropertyValue":"getAttribute"](i)},link:function(t,i,n){if(r.path){var a=document.getElementsByTagName("head")[0],s=document.createElement("link");"string"==typeof i&&(n=i);var l=(n||t).replace(/\.|\//g,""),f="layuicss-"+l,c="creating",u=0;s.rel="stylesheet",s.href=r.path+t,s.id=f,document.getElementById(f)||a.appendChild(s),"function"==typeof i&&!function d(t){var n=100,a=document.getElementById(f);return++u>1e4/n?e.console&&console.error(l+".css: Invalid"):void(1989===parseInt(o.getStyle(a,"width"))?(t===c&&a.removeAttribute("lay-status"),a.getAttribute("lay-status")===c?setTimeout(d,n):i()):(a.setAttribute("lay-status",c),setTimeout(function(){d(c)},n)))}()}}},r={v:"3.5.1",ie:function(){var t=navigator.userAgent.toLowerCase();return!!(e.ActiveXObject||"ActiveXObject"in e)&&((t.match(/msie\s(\d+)/)||[])[1]||"11")}(),index:e.layer&&e.layer.v?1e5:0,path:o.getPath,config:function(e,t){return e=e||{},r.cache=o.config=i.extend({},o.config,e),r.path=o.config.path||r.path,"string"==typeof e.extend&&(e.extend=[e.extend]),o.config.path&&r.ready(),e.extend?(a?layui.addcss("modules/layer/"+e.extend):o.link("theme/"+e.extend),this):this},ready:function(e){var t="layer",i="",n=(a?"modules/layer/":"theme/")+"default/layer.css?v="+r.v+i;return a?layui.addcss(n,e,t):o.link(n,e,t),this},alert:function(e,t,n){var a="function"==typeof t;return a&&(n=t),r.open(i.extend({content:e,yes:n},a?{}:t))},confirm:function(e,t,n,a){var s="function"==typeof t;return s&&(a=n,n=t),r.open(i.extend({content:e,btn:o.btn,yes:n,btn2:a},s?{}:t))},msg:function(e,n,a){var s="function"==typeof n,f=o.config.skin,c=(f?f+" "+f+"-msg":"")||"layui-layer-msg",u=l.anim.length-1;return s&&(a=n),r.open(i.extend({content:e,time:3e3,shade:!1,skin:c,title:!1,closeBtn:!1,btn:!1,resize:!1,end:a},s&&!o.config.skin?{skin:c+" layui-layer-hui",anim:u}:function(){return n=n||{},(n.icon===-1||n.icon===t&&!o.config.skin)&&(n.skin=c+" "+(n.skin||"layui-layer-hui")),n}()))},load:function(e,t){return r.open(i.extend({type:3,icon:e||0,resize:!1,shade:.01},t))},tips:function(e,t,n){return r.open(i.extend({type:4,content:[e,t],closeBtn:!1,time:3e3,shade:!1,resize:!1,fixed:!1,maxWidth:260},n))}},s=function(e){var t=this,a=function(){t.creat()};t.index=++r.index,t.config.maxWidth=i(n).width()-30,t.config=i.extend({},t.config,o.config,e),document.body?a():setTimeout(function(){a()},30)};s.pt=s.prototype;var l=["layui-layer",".layui-layer-title",".layui-layer-main",".layui-layer-dialog","layui-layer-iframe","layui-layer-content","layui-layer-btn","layui-layer-close"];l.anim=["layer-anim-00","layer-anim-01","layer-anim-02","layer-anim-03","layer-anim-04","layer-anim-05","layer-anim-06"],l.SHADE="layui-layer-shade",l.MOVE="layui-layer-move",s.pt.config={type:0,shade:.3,fixed:!0,move:l[1],title:"&#x4FE1;&#x606F;",offset:"auto",area:"auto",closeBtn:1,time:0,zIndex:19891014,maxWidth:360,anim:0,isOutAnim:!0,minStack:!0,icon:-1,moveType:1,resize:!0,scrollbar:!0,tips:2},s.pt.vessel=function(e,t){var n=this,a=n.index,r=n.config,s=r.zIndex+a,f="object"==typeof r.title,c=r.maxmin&&(1===r.type||2===r.type),u=r.title?'<div class="layui-layer-title" style="'+(f?r.title[1]:"")+'">'+(f?r.title[0]:r.title)+"</div>":"";return r.zIndex=s,t([r.shade?'<div class="'+l.SHADE+'" id="'+l.SHADE+a+'" times="'+a+'" style="'+("z-index:"+(s-1)+"; ")+'"></div>':"",'<div class="'+l[0]+(" layui-layer-"+o.type[r.type])+(0!=r.type&&2!=r.type||r.shade?"":" layui-layer-border")+" "+(r.skin||"")+'" id="'+l[0]+a+'" type="'+o.type[r.type]+'" times="'+a+'" showtime="'+r.time+'" conType="'+(e?"object":"string")+'" style="z-index: '+s+"; width:"+r.area[0]+";height:"+r.area[1]+";position:"+(r.fixed?"fixed;":"absolute;")+'">'+(e&&2!=r.type?"":u)+'<div id="'+(r.id||"")+'" class="layui-layer-content'+(0==r.type&&r.icon!==-1?" layui-layer-padding":"")+(3==r.type?" layui-layer-loading"+r.icon:"")+'">'+(0==r.type&&r.icon!==-1?'<i class="layui-layer-ico layui-layer-ico'+r.icon+'"></i>':"")+(1==r.type&&e?"":r.content||"")+'</div><span class="layui-layer-setwin">'+function(){var e=c?'<a class="layui-layer-min" href="javascript:;"><cite></cite></a><a class="layui-layer-ico layui-layer-max" href="javascript:;"></a>':"";return r.closeBtn&&(e+='<a class="layui-layer-ico '+l[7]+" "+l[7]+(r.title?r.closeBtn:4==r.type?"1":"2")+'" href="javascript:;"></a>'),e}()+"</span>"+(r.btn?function(){var e="";"string"==typeof r.btn&&(r.btn=[r.btn]);for(var t=0,i=r.btn.length;t<i;t++)e+='<a class="'+l[6]+t+'">'+r.btn[t]+"</a>";return'<div class="'+l[6]+" layui-layer-btn-"+(r.btnAlign||"")+'">'+e+"</div>"}():"")+(r.resize?'<span class="layui-layer-resize"></span>':"")+"</div>"],u,i('<div class="'+l.MOVE+'" id="'+l.MOVE+'"></div>')),n},s.pt.creat=function(){var e=this,t=e.config,a=e.index,s=t.content,f="object"==typeof s,c=i("body");if(!t.id||!i("#"+t.id)[0]){switch("string"==typeof t.area&&(t.area="auto"===t.area?["",""]:[t.area,""]),t.shift&&(t.anim=t.shift),6==r.ie&&(t.fixed=!1),t.type){case 0:t.btn="btn"in t?t.btn:o.btn[0],r.closeAll("dialog");break;case 2:var s=t.content=f?t.content:[t.content||"","auto"];t.content='<iframe scrolling="'+(t.content[1]||"auto")+'" allowtransparency="true" id="'+l[4]+a+'" name="'+l[4]+a+'" onload="this.className=\'\';" class="layui-layer-load" frameborder="0" src="'+t.content[0]+'"></iframe>';break;case 3:delete t.title,delete t.closeBtn,t.icon===-1&&0===t.icon,r.closeAll("loading");break;case 4:f||(t.content=[t.content,"body"]),t.follow=t.content[1],t.content=t.content[0]+'<i class="layui-layer-TipsG"></i>',delete t.title,t.tips="object"==typeof t.tips?t.tips:[t.tips,!0],t.tipsMore||r.closeAll("tips")}if(e.vessel(f,function(n,r,u){c.append(n[0]),f?function(){2==t.type||4==t.type?function(){i("body").append(n[1])}():function(){s.parents("."+l[0])[0]||(s.data("display",s.css("display")).show().addClass("layui-layer-wrap").wrap(n[1]),i("#"+l[0]+a).find("."+l[5]).before(r))}()}():c.append(n[1]),i("#"+l.MOVE)[0]||c.append(o.moveElem=u),e.layero=i("#"+l[0]+a),e.shadeo=i("#"+l.SHADE+a),t.scrollbar||l.html.css("overflow","hidden").attr("layer-full",a)}).auto(a),e.shadeo.css({"background-color":t.shade[1]||"#000",opacity:t.shade[0]||t.shade}),2==t.type&&6==r.ie&&e.layero.find("iframe").attr("src",s[0]),4==t.type?e.tips():function(){e.offset(),parseInt(o.getStyle(document.getElementById(l.MOVE),"z-index"))||function(){e.layero.css("visibility","hidden"),r.ready(function(){e.offset(),e.layero.css("visibility","visible")})}()}(),t.fixed&&n.on("resize",function(){e.offset(),(/^\d+%$/.test(t.area[0])||/^\d+%$/.test(t.area[1]))&&e.auto(a),4==t.type&&e.tips()}),t.time<=0||setTimeout(function(){r.close(e.index)},t.time),e.move().callback(),l.anim[t.anim]){var u="layer-anim "+l.anim[t.anim];e.layero.addClass(u).one("webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend",function(){i(this).removeClass(u)})}t.isOutAnim&&e.layero.data("isOutAnim",!0)}},s.pt.auto=function(e){var t=this,a=t.config,o=i("#"+l[0]+e);""===a.area[0]&&a.maxWidth>0&&(r.ie&&r.ie<8&&a.btn&&o.width(o.innerWidth()),o.outerWidth()>a.maxWidth&&o.width(a.maxWidth));var s=[o.innerWidth(),o.innerHeight()],f=o.find(l[1]).outerHeight()||0,c=o.find("."+l[6]).outerHeight()||0,u=function(e){e=o.find(e),e.height(s[1]-f-c-2*(0|parseFloat(e.css("padding-top"))))};switch(a.type){case 2:u("iframe");break;default:""===a.area[1]?a.maxHeight>0&&o.outerHeight()>a.maxHeight?(s[1]=a.maxHeight,u("."+l[5])):a.fixed&&s[1]>=n.height()&&(s[1]=n.height(),u("."+l[5])):u("."+l[5])}return t},s.pt.offset=function(){var e=this,t=e.config,i=e.layero,a=[i.outerWidth(),i.outerHeight()],o="object"==typeof t.offset;e.offsetTop=(n.height()-a[1])/2,e.offsetLeft=(n.width()-a[0])/2,o?(e.offsetTop=t.offset[0],e.offsetLeft=t.offset[1]||e.offsetLeft):"auto"!==t.offset&&("t"===t.offset?e.offsetTop=0:"r"===t.offset?e.offsetLeft=n.width()-a[0]:"b"===t.offset?e.offsetTop=n.height()-a[1]:"l"===t.offset?e.offsetLeft=0:"lt"===t.offset?(e.offsetTop=0,e.offsetLeft=0):"lb"===t.offset?(e.offsetTop=n.height()-a[1],e.offsetLeft=0):"rt"===t.offset?(e.offsetTop=0,e.offsetLeft=n.width()-a[0]):"rb"===t.offset?(e.offsetTop=n.height()-a[1],e.offsetLeft=n.width()-a[0]):e.offsetTop=t.offset),t.fixed||(e.offsetTop=/%$/.test(e.offsetTop)?n.height()*parseFloat(e.offsetTop)/100:parseFloat(e.offsetTop),e.offsetLeft=/%$/.test(e.offsetLeft)?n.width()*parseFloat(e.offsetLeft)/100:parseFloat(e.offsetLeft),e.offsetTop+=n.scrollTop(),e.offsetLeft+=n.scrollLeft()),i.attr("minLeft")&&(e.offsetTop=n.height()-(i.find(l[1]).outerHeight()||0),e.offsetLeft=i.css("left")),i.css({top:e.offsetTop,left:e.offsetLeft})},s.pt.tips=function(){var e=this,t=e.config,a=e.layero,o=[a.outerWidth(),a.outerHeight()],r=i(t.follow);r[0]||(r=i("body"));var s={width:r.outerWidth(),height:r.outerHeight(),top:r.offset().top,left:r.offset().left},f=a.find(".layui-layer-TipsG"),c=t.tips[0];t.tips[1]||f.remove(),s.autoLeft=function(){s.left+o[0]-n.width()>0?(s.tipLeft=s.left+s.width-o[0],f.css({right:12,left:"auto"})):s.tipLeft=s.left},s.where=[function(){s.autoLeft(),s.tipTop=s.top-o[1]-10,f.removeClass("layui-layer-TipsB").addClass("layui-layer-TipsT").css("border-right-color",t.tips[1])},function(){s.tipLeft=s.left+s.width+10,s.tipTop=s.top,f.removeClass("layui-layer-TipsL").addClass("layui-layer-TipsR").css("border-bottom-color",t.tips[1])},function(){s.autoLeft(),s.tipTop=s.top+s.height+10,f.removeClass("layui-layer-TipsT").addClass("layui-layer-TipsB").css("border-right-color",t.tips[1])},function(){s.tipLeft=s.left-o[0]-10,s.tipTop=s.top,f.removeClass("layui-layer-TipsR").addClass("layui-layer-TipsL").css("border-bottom-color",t.tips[1])}],s.where[c-1](),1===c?s.top-(n.scrollTop()+o[1]+16)<0&&s.where[2]():2===c?n.width()-(s.left+s.width+o[0]+16)>0||s.where[3]():3===c?s.top-n.scrollTop()+s.height+o[1]+16-n.height()>0&&s.where[0]():4===c&&o[0]+16-s.left>0&&s.where[1](),a.find("."+l[5]).css({"background-color":t.tips[1],"padding-right":t.closeBtn?"30px":""}),a.css({left:s.tipLeft-(t.fixed?n.scrollLeft():0),top:s.tipTop-(t.fixed?n.scrollTop():0)})},s.pt.move=function(){var e=this,t=e.config,a=i(document),s=e.layero,l=s.find(t.move),f=s.find(".layui-layer-resize"),c={};return t.move&&l.css("cursor","move"),l.on("mousedown",function(e){e.preventDefault(),t.move&&(c.moveStart=!0,c.offset=[e.clientX-parseFloat(s.css("left")),e.clientY-parseFloat(s.css("top"))],o.moveElem.css("cursor","move").show())}),f.on("mousedown",function(e){e.preventDefault(),c.resizeStart=!0,c.offset=[e.clientX,e.clientY],c.area=[s.outerWidth(),s.outerHeight()],o.moveElem.css("cursor","se-resize").show()}),a.on("mousemove",function(i){if(c.moveStart){var a=i.clientX-c.offset[0],o=i.clientY-c.offset[1],l="fixed"===s.css("position");if(i.preventDefault(),c.stX=l?0:n.scrollLeft(),c.stY=l?0:n.scrollTop(),!t.moveOut){var f=n.width()-s.outerWidth()+c.stX,u=n.height()-s.outerHeight()+c.stY;a<c.stX&&(a=c.stX),a>f&&(a=f),o<c.stY&&(o=c.stY),o>u&&(o=u)}s.css({left:a,top:o})}if(t.resize&&c.resizeStart){var a=i.clientX-c.offset[0],o=i.clientY-c.offset[1];i.preventDefault(),r.style(e.index,{width:c.area[0]+a,height:c.area[1]+o}),c.isResize=!0,t.resizing&&t.resizing(s)}}).on("mouseup",function(e){c.moveStart&&(delete c.moveStart,o.moveElem.hide(),t.moveEnd&&t.moveEnd(s)),c.resizeStart&&(delete c.resizeStart,o.moveElem.hide())}),e},s.pt.callback=function(){function e(){var e=a.cancel&&a.cancel(t.index,n);e===!1||r.close(t.index)}var t=this,n=t.layero,a=t.config;t.openLayer(),a.success&&(2==a.type?n.find("iframe").on("load",function(){a.success(n,t.index)}):a.success(n,t.index)),6==r.ie&&t.IE6(n),n.find("."+l[6]).children("a").on("click",function(){var e=i(this).index();if(0===e)a.yes?a.yes(t.index,n):a.btn1?a.btn1(t.index,n):r.close(t.index);else{var o=a["btn"+(e+1)]&&a["btn"+(e+1)](t.index,n);o===!1||r.close(t.index)}}),n.find("."+l[7]).on("click",e),a.shadeClose&&t.shadeo.on("click",function(){r.close(t.index)}),n.find(".layui-layer-min").on("click",function(){var e=a.min&&a.min(n,t.index);e===!1||r.min(t.index,a)}),n.find(".layui-layer-max").on("click",function(){i(this).hasClass("layui-layer-maxmin")?(r.restore(t.index),a.restore&&a.restore(n,t.index)):(r.full(t.index,a),setTimeout(function(){a.full&&a.full(n,t.index)},100))}),a.end&&(o.end[t.index]=a.end)},o.reselect=function(){i.each(i("select"),function(e,t){var n=i(this);n.parents("."+l[0])[0]||1==n.attr("layer")&&i("."+l[0]).length<1&&n.removeAttr("layer").show(),n=null})},s.pt.IE6=function(e){i("select").each(function(e,t){var n=i(this);n.parents("."+l[0])[0]||"none"===n.css("display")||n.attr({layer:"1"}).hide(),n=null})},s.pt.openLayer=function(){var e=this;r.zIndex=e.config.zIndex,r.setTop=function(e){var t=function(){r.zIndex++,e.css("z-index",r.zIndex+1)};return r.zIndex=parseInt(e[0].style.zIndex),e.on("mousedown",t),r.zIndex}},o.record=function(e){var t=[e.width(),e.height(),e.position().top,e.position().left+parseFloat(e.css("margin-left"))];e.find(".layui-layer-max").addClass("layui-layer-maxmin"),e.attr({area:t})},o.rescollbar=function(e){l.html.attr("layer-full")==e&&(l.html[0].style.removeProperty?l.html[0].style.removeProperty("overflow"):l.html[0].style.removeAttribute("overflow"),l.html.removeAttr("layer-full"))},e.layer=r,r.getChildFrame=function(e,t){return t=t||i("."+l[4]).attr("times"),i("#"+l[0]+t).find("iframe").contents().find(e)},r.getFrameIndex=function(e){return i("#"+e).parents("."+l[4]).attr("times")},r.iframeAuto=function(e){if(e){var t=r.getChildFrame("html",e).outerHeight(),n=i("#"+l[0]+e),a=n.find(l[1]).outerHeight()||0,o=n.find("."+l[6]).outerHeight()||0;n.css({height:t+a+o}),n.find("iframe").css({height:t})}},r.iframeSrc=function(e,t){i("#"+l[0]+e).find("iframe").attr("src",t)},r.style=function(e,t,n){var a=i("#"+l[0]+e),r=a.find(".layui-layer-content"),s=a.attr("type"),f=a.find(l[1]).outerHeight()||0,c=a.find("."+l[6]).outerHeight()||0;a.attr("minLeft");s!==o.type[3]&&s!==o.type[4]&&(n||(parseFloat(t.width)<=260&&(t.width=260),parseFloat(t.height)-f-c<=64&&(t.height=64+f+c)),a.css(t),c=a.find("."+l[6]).outerHeight(),s===o.type[2]?a.find("iframe").css({height:parseFloat(t.height)-f-c}):r.css({height:parseFloat(t.height)-f-c-parseFloat(r.css("padding-top"))-parseFloat(r.css("padding-bottom"))}))},r.min=function(e,t){t=t||{};var a=i("#"+l[0]+e),s=i("#"+l.SHADE+e),f=a.find(l[1]).outerHeight()||0,c=a.attr("minLeft")||181*o.minIndex+"px",u=a.css("position"),d={width:180,height:f,position:"fixed",overflow:"hidden"};o.record(a),o.minLeft[0]&&(c=o.minLeft[0],o.minLeft.shift()),t.minStack&&(d.left=c,d.top=n.height()-f,a.attr("minLeft")||o.minIndex++,a.attr("minLeft",c)),a.attr("position",u),r.style(e,d,!0),a.find(".layui-layer-min").hide(),"page"===a.attr("type")&&a.find(l[4]).hide(),o.rescollbar(e),s.hide()},r.restore=function(e){var t=i("#"+l[0]+e),n=i("#"+l.SHADE+e),a=t.attr("area").split(",");t.attr("type");r.style(e,{width:parseFloat(a[0]),height:parseFloat(a[1]),top:parseFloat(a[2]),left:parseFloat(a[3]),position:t.attr("position"),overflow:"visible"},!0),t.find(".layui-layer-max").removeClass("layui-layer-maxmin"),t.find(".layui-layer-min").show(),"page"===t.attr("type")&&t.find(l[4]).show(),o.rescollbar(e),n.show()},r.full=function(e){var t,a=i("#"+l[0]+e);o.record(a),l.html.attr("layer-full")||l.html.css("overflow","hidden").attr("layer-full",e),clearTimeout(t),t=setTimeout(function(){var t="fixed"===a.css("position");r.style(e,{top:t?0:n.scrollTop(),left:t?0:n.scrollLeft(),width:n.width(),height:n.height()},!0),a.find(".layui-layer-min").hide()},100)},r.title=function(e,t){var n=i("#"+l[0]+(t||r.index)).find(l[1]);n.html(e)},r.close=function(e,t){var n=i("#"+l[0]+e),a=n.attr("type"),s="layer-anim-close";if(n[0]){var f="layui-layer-wrap",c=function(){if(a===o.type[1]&&"object"===n.attr("conType")){n.children(":not(."+l[5]+")").remove();for(var r=n.find("."+f),s=0;s<2;s++)r.unwrap();r.css("display",r.data("display")).removeClass(f)}else{if(a===o.type[2])try{var c=i("#"+l[4]+e)[0];c.contentWindow.document.write(""),c.contentWindow.close(),n.find("."+l[5])[0].removeChild(c)}catch(u){}n[0].innerHTML="",n.remove()}"function"==typeof o.end[e]&&o.end[e](),delete o.end[e],"function"==typeof t&&t()};n.data("isOutAnim")&&n.addClass("layer-anim "+s),i("#layui-layer-moves, #"+l.SHADE+e).remove(),6==r.ie&&o.reselect(),o.rescollbar(e),n.attr("minLeft")&&(o.minIndex--,o.minLeft.push(n.attr("minLeft"))),r.ie&&r.ie<10||!n.data("isOutAnim")?c():setTimeout(function(){c()},200)}},r.closeAll=function(e,t){"function"==typeof e&&(t=e,e=null);var n=i("."+l[0]);i.each(n,function(a){var o=i(this),s=e?o.attr("type")===e:1;s&&r.close(o.attr("times"),a===n.length-1?t:null),s=null}),0===n.length&&"function"==typeof t&&t()};var f=r.cache||{},c=function(e){return f.skin?" "+f.skin+" "+f.skin+"-"+e:""};r.prompt=function(e,t){var a="";if(e=e||{},"function"==typeof e&&(t=e),e.area){var o=e.area;a='style="width: '+o[0]+"; height: "+o[1]+';"',delete e.area}var s,l=2==e.formType?'<textarea class="layui-layer-input"'+a+"></textarea>":function(){return'<input type="'+(1==e.formType?"password":"text")+'" class="layui-layer-input">'}(),f=e.success;return delete e.success,r.open(i.extend({type:1,btn:["&#x786E;&#x5B9A;","&#x53D6;&#x6D88;"],content:l,skin:"layui-layer-prompt"+c("prompt"),maxWidth:n.width(),success:function(t){s=t.find(".layui-layer-input"),s.val(e.value||"").focus(),"function"==typeof f&&f(t)},resize:!1,yes:function(i){var n=s.val();""===n?s.focus():n.length>(e.maxlength||500)?r.tips("&#x6700;&#x591A;&#x8F93;&#x5165;"+(e.maxlength||500)+"&#x4E2A;&#x5B57;&#x6570;",s,{tips:1}):t&&t(n,i,s)}},e))},r.tab=function(e){e=e||{};var t=e.tab||{},n="layui-this",a=e.success;return delete e.success,r.open(i.extend({type:1,skin:"layui-layer-tab"+c("tab"),resize:!1,title:function(){var e=t.length,i=1,a="";if(e>0)for(a='<span class="'+n+'">'+t[0].title+"</span>";i<e;i++)a+="<span>"+t[i].title+"</span>";return a}(),content:'<ul class="layui-layer-tabmain">'+function(){var e=t.length,i=1,a="";if(e>0)for(a='<li class="layui-layer-tabli '+n+'">'+(t[0].content||"no content")+"</li>";i<e;i++)a+='<li class="layui-layer-tabli">'+(t[i].content||"no  content")+"</li>";return a}()+"</ul>",success:function(t){var o=t.find(".layui-layer-title").children(),r=t.find(".layui-layer-tabmain").children();o.on("mousedown",function(t){t.stopPropagation?t.stopPropagation():t.cancelBubble=!0;var a=i(this),o=a.index();a.addClass(n).siblings().removeClass(n),r.eq(o).show().siblings().hide(),"function"==typeof e.change&&e.change(o)}),"function"==typeof a&&a(t)}},e))},r.photos=function(t,n,a){function o(e,t,i){var n=new Image;return n.src=e,n.complete?t(n):(n.onload=function(){n.onload=null,t(n)},void(n.onerror=function(e){n.onerror=null,i(e)}))}var s={};if(t=t||{},t.photos){var l=!("string"==typeof t.photos||t.photos instanceof i),f=l?t.photos:{},u=f.data||[],d=f.start||0;s.imgIndex=(0|d)+1,t.img=t.img||"img";var y=t.success;if(delete t.success,l){if(0===u.length)return r.msg("&#x6CA1;&#x6709;&#x56FE;&#x7247;")}else{var p=i(t.photos),h=function(){u=[],p.find(t.img).each(function(e){var t=i(this);t.attr("layer-index",e),u.push({alt:t.attr("alt"),pid:t.attr("layer-pid"),src:t.attr("layer-src")||t.attr("src"),thumb:t.attr("src")})})};if(h(),0===u.length)return;if(n||p.on("click",t.img,function(){h();var e=i(this),n=e.attr("layer-index");r.photos(i.extend(t,{photos:{start:n,data:u,tab:t.tab},full:t.full}),!0)}),!n)return}s.imgprev=function(e){s.imgIndex--,s.imgIndex<1&&(s.imgIndex=u.length),s.tabimg(e)},s.imgnext=function(e,t){s.imgIndex++,s.imgIndex>u.length&&(s.imgIndex=1,t)||s.tabimg(e)},s.keyup=function(e){if(!s.end){var t=e.keyCode;e.preventDefault(),37===t?s.imgprev(!0):39===t?s.imgnext(!0):27===t&&r.close(s.index)}},s.tabimg=function(e){if(!(u.length<=1))return f.start=s.imgIndex-1,r.close(s.index),r.photos(t,!0,e)},s.event=function(){s.bigimg.find(".layui-layer-imgprev").on("click",function(e){e.preventDefault(),s.imgprev(!0)}),s.bigimg.find(".layui-layer-imgnext").on("click",function(e){e.preventDefault(),s.imgnext(!0)}),i(document).on("keyup",s.keyup)},s.loadi=r.load(1,{shade:!("shade"in t)&&.9,scrollbar:!1}),o(u[d].src,function(n){r.close(s.loadi),a&&(t.anim=-1),s.index=r.open(i.extend({type:1,id:"layui-layer-photos",area:function(){var a=[n.width,n.height],o=[i(e).width()-100,i(e).height()-100];if(!t.full&&(a[0]>o[0]||a[1]>o[1])){var r=[a[0]/o[0],a[1]/o[1]];r[0]>r[1]?(a[0]=a[0]/r[0],a[1]=a[1]/r[0]):r[0]<r[1]&&(a[0]=a[0]/r[1],a[1]=a[1]/r[1])}return[a[0]+"px",a[1]+"px"]}(),title:!1,shade:.9,shadeClose:!0,closeBtn:!1,move:".layui-layer-phimg img",moveType:1,scrollbar:!1,moveOut:!0,anim:5,isOutAnim:!1,skin:"layui-layer-photos"+c("photos"),content:'<div class="layui-layer-phimg"><img src="'+u[d].src+'" alt="'+(u[d].alt||"")+'" layer-pid="'+u[d].pid+'">'+function(){return u.length>1?'<div class="layui-layer-imgsee"><span class="layui-layer-imguide"><a href="javascript:;" class="layui-layer-iconext layui-layer-imgprev"></a><a href="javascript:;" class="layui-layer-iconext layui-layer-imgnext"></a></span><div class="layui-layer-imgbar" style="display:'+(a?"block":"")+'"><span class="layui-layer-imgtit"><a href="javascript:;">'+(u[d].alt||"")+"</a><em>"+s.imgIndex+" / "+u.length+"</em></span></div></div>":""}()+"</div>",success:function(e,i){s.bigimg=e.find(".layui-layer-phimg"),s.imgsee=e.find(".layui-layer-imgbar"),s.event(e),t.tab&&t.tab(u[d],e),"function"==typeof y&&y(e)},end:function(){s.end=!0,i(document).off("keyup",s.keyup)}},t))},function(){r.close(s.loadi),r.msg("&#x5F53;&#x524D;&#x56FE;&#x7247;&#x5730;&#x5740;&#x5F02;&#x5E38;<br>&#x662F;&#x5426;&#x7EE7;&#x7EED;&#x67E5;&#x770B;&#x4E0B;&#x4E00;&#x5F20;&#xFF1F;",{time:3e4,btn:["&#x4E0B;&#x4E00;&#x5F20;","&#x4E0D;&#x770B;&#x4E86;"],yes:function(){u.length>1&&s.imgnext(!0,!0)}})})}},o.run=function(t){i=t,n=i(e),l.html=i("html"),r.open=function(e){var t=new s(e);return t.index}},e.layui&&layui.define?(r.ready(),layui.define("jquery",function(t){r.path=layui.cache.dir,o.run(layui.$),e.layer=r,t("layer",r)})):"function"==typeof define&&define.amd?define(["jquery"],function(){return o.run(e.jQuery),r}):function(){r.ready(),o.run(e.jQuery)}()}(window);

================================================
FILE: static/js/layer/mobile/layer.js
================================================
/*! layer mobile-v2.0.0 Web 通用弹出层组件 MIT License */
 ;!function(e){"use strict";var t=document,n="querySelectorAll",i="getElementsByClassName",a=function(e){return t[n](e)},s={type:0,shade:!0,shadeClose:!0,fixed:!0,anim:"scale"},l={extend:function(e){var t=JSON.parse(JSON.stringify(s));for(var n in e)t[n]=e[n];return t},timer:{},end:{}};l.touch=function(e,t){e.addEventListener("click",function(e){t.call(this,e)},!1)};var r=0,o=["layui-m-layer"],c=function(e){var t=this;t.config=l.extend(e),t.view()};c.prototype.view=function(){var e=this,n=e.config,s=t.createElement("div");e.id=s.id=o[0]+r,s.setAttribute("class",o[0]+" "+o[0]+(n.type||0)),s.setAttribute("index",r);var l=function(){var e="object"==typeof n.title;return n.title?'<h3 style="'+(e?n.title[1]:"")+'">'+(e?n.title[0]:n.title)+"</h3>":""}(),c=function(){"string"==typeof n.btn&&(n.btn=[n.btn]);var e,t=(n.btn||[]).length;return 0!==t&&n.btn?(e='<span yes type="1">'+n.btn[0]+"</span>",2===t&&(e='<span no type="0">'+n.btn[1]+"</span>"+e),'<div class="layui-m-layerbtn">'+e+"</div>"):""}();if(n.fixed||(n.top=n.hasOwnProperty("top")?n.top:100,n.style=n.style||"",n.style+=" top:"+(t.body.scrollTop+n.top)+"px"),2===n.type&&(n.content='<i></i><i class="layui-m-layerload"></i><i></i><p>'+(n.content||"")+"</p>"),n.skin&&(n.anim="up"),"msg"===n.skin&&(n.shade=!1),s.innerHTML=(n.shade?"<div "+("string"==typeof n.shade?'style="'+n.shade+'"':"")+' class="layui-m-layershade"></div>':"")+'<div class="layui-m-layermain" '+(n.fixed?"":'style="position:static;"')+'><div class="layui-m-layersection"><div class="layui-m-layerchild '+(n.skin?"layui-m-layer-"+n.skin+" ":"")+(n.className?n.className:"")+" "+(n.anim?"layui-m-anim-"+n.anim:"")+'" '+(n.style?'style="'+n.style+'"':"")+">"+l+'<div class="layui-m-layercont">'+n.content+"</div>"+c+"</div></div></div>",!n.type||2===n.type){var d=t[i](o[0]+n.type),y=d.length;y>=1&&layer.close(d[0].getAttribute("index"))}document.body.appendChild(s);var u=e.elem=a("#"+e.id)[0];n.success&&n.success(u),e.index=r++,e.action(n,u)},c.prototype.action=function(e,t){var n=this;e.time&&(l.timer[n.index]=setTimeout(function(){layer.close(n.index)},1e3*e.time));var a=function(){var t=this.getAttribute("type");0==t?(e.no&&e.no(),layer.close(n.index)):e.yes?e.yes(n.index):layer.close(n.index)};if(e.btn)for(var s=t[i]("layui-m-layerbtn")[0].children,r=s.length,o=0;o<r;o++)l.touch(s[o],a);if(e.shade&&e.shadeClose){var c=t[i]("layui-m-layershade")[0];l.touch(c,function(){layer.close(n.index,e.end)})}e.end&&(l.end[n.index]=e.end)},e.layer={v:"2.0",index:r,open:function(e){var t=new c(e||{});return t.index},close:function(e){var n=a("#"+o[0]+e)[0];n&&(n.innerHTML="",t.body.removeChild(n),clearTimeout(l.timer[e]),delete l.timer[e],"function"==typeof l.end[e]&&l.end[e](),delete l.end[e])},closeAll:function(){for(var e=t[i](o[0]),n=0,a=e.length;n<a;n++)layer.close(0|e[0].getAttribute("index"))}},"function"==typeof define?define(function(){return layer}):function(){var e=document.scripts,n=e[e.length-1],i=n.src,a=i.substring(0,i.lastIndexOf("/")+1);n.getAttribute("merge")||document.head.appendChild(function(){var e=t.createElement("link");return e.href=a+"need/layer.css?2.0",e.type="text/css",e.rel="styleSheet",e.id="layermcss",e}())}()}(window);

================================================
FILE: static/js/layer/mobile/need/layer.css
================================================
.layui-m-layer{position:relative;z-index:19891014}.layui-m-layer *{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}.layui-m-layermain,.layui-m-layershade{position:fixed;left:0;top:0;width:100%;height:100%}.layui-m-layershade{background-color:rgba(0,0,0,.7);pointer-events:auto}.layui-m-layermain{display:table;font-family:Helvetica,arial,sans-serif;pointer-events:none}.layui-m-layermain .layui-m-layersection{display:table-cell;vertical-align:middle;text-align:center}.layui-m-layerchild{position:relative;display:inline-block;text-align:left;background-color:#fff;font-size:14px;border-radius:5px;box-shadow:0 0 8px rgba(0,0,0,.1);pointer-events:auto;-webkit-overflow-scrolling:touch;-webkit-animation-fill-mode:both;animation-fill-mode:both;-webkit-animation-duration:.2s;animation-duration:.2s}@-webkit-keyframes layui-m-anim-scale{0%{opacity:0;-webkit-transform:scale(.5);transform:scale(.5)}100%{opacity:1;-webkit-transform:scale(1);transform:scale(1)}}@keyframes layui-m-anim-scale{0%{opacity:0;-webkit-transform:scale(.5);transform:scale(.5)}100%{opacity:1;-webkit-transform:scale(1);transform:scale(1)}}.layui-m-anim-scale{animation-name:layui-m-anim-scale;-webkit-animation-name:layui-m-anim-scale}@-webkit-keyframes layui-m-anim-up{0%{opacity:0;-webkit-transform:translateY(800px);transform:translateY(800px)}100%{opacity:1;-webkit-transform:translateY(0);transform:translateY(0)}}@keyframes layui-m-anim-up{0%{opacity:0;-webkit-transform:translateY(800px);transform:translateY(800px)}100%{opacity:1;-webkit-transform:translateY(0);transform:translateY(0)}}.layui-m-anim-up{-webkit-animation-name:layui-m-anim-up;animation-name:layui-m-anim-up}.layui-m-layer0 .layui-m-layerchild{width:90%;max-width:640px}.layui-m-layer1 .layui-m-layerchild{border:none;border-radius:0}.layui-m-layer2 .layui-m-layerchild{width:auto;max-width:260px;min-width:40px;border:none;background:0 0;box-shadow:none;color:#fff}.layui-m-layerchild h3{padding:0 10px;height:60px;line-height:60px;font-size:16px;font-weight:400;border-radius:5px 5px 0 0;text-align:center}.layui-m-layerbtn span,.layui-m-layerchild h3{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.layui-m-layercont{padding:50px 30px;line-height:22px;text-align:center}.layui-m-layer1 .layui-m-layercont{padding:0;text-align:left}.layui-m-layer2 .layui-m-layercont{text-align:center;padding:0;line-height:0}.layui-m-layer2 .layui-m-layercont i{width:25px;height:25px;margin-left:8px;display:inline-block;background-color:#fff;border-radius:100%;-webkit-animation:layui-m-anim-loading 1.4s infinite ease-in-out;animation:layui-m-anim-loading 1.4s infinite ease-in-out;-webkit-animation-fill-mode:both;animation-fill-mode:both}.layui-m-layerbtn,.layui-m-layerbtn span{position:relative;text-align:center;border-radius:0 0 5px 5px}.layui-m-layer2 .layui-m-layercont p{margin-top:20px}@-webkit-keyframes layui-m-anim-loading{0%,100%,80%{transform:scale(0);-webkit-transform:scale(0)}40%{transform:scale(1);-webkit-transform:scale(1)}}@keyframes layui-m-anim-loading{0%,100%,80%{transform:scale(0);-webkit-transform:scale(0)}40%{transform:scale(1);-webkit-transform:scale(1)}}.layui-m-layer2 .layui-m-layercont i:first-child{margin-left:0;-webkit-animation-delay:-.32s;animation-delay:-.32s}.layui-m-layer2 .layui-m-layercont i.layui-m-layerload{-webkit-animation-delay:-.16s;animation-delay:-.16s}.layui-m-layer2 .layui-m-layercont>div{line-height:22px;padding-top:7px;margin-bottom:20px;font-size:14px}.layui-m-layerbtn{display:box;display:-moz-box;display:-webkit-box;width:100%;height:50px;line-height:50px;font-size:0;border-top:1px solid #D0D0D0;background-color:#F2F2F2}.layui-m-layerbtn span{display:block;-moz-box-flex:1;box-flex:1;-webkit-box-flex:1;font-size:14px;cursor:pointer}.layui-m-layerbtn span[yes]{color:#40AFFE}.layui-m-layerbtn span[no]{border-right:1px solid #D0D0D0;border-radius:0 0 0 5px}.layui-m-layerbtn span:active{background-color:#F6F6F6}.layui-m-layerend{position:absolute;right:7px;top:10px;width:30px;height:30px;border:0;font-weight:400;background:0 0;cursor:pointer;-webkit-appearance:none;font-size:30px}.layui-m-layerend::after,.layui-m-layerend::before{position:absolute;left:5px;top:15px;content:'';width:18px;height:1px;background-color:#999;transform:rotate(45deg);-webkit-transform:rotate(45deg);border-radius:3px}.layui-m-layerend::after{transform:rotate(-45deg);-webkit-transform:rotate(-45deg)}body .layui-m-layer .layui-m-layer-footer{position:fixed;width:95%;max-width:100%;margin:0 auto;left:0;right:0;bottom:10px;background:0 0}.layui-m-layer-footer .layui-m-layercont{padding:20px;border-radius:5px 5px 0 0;background-color:rgba(255,255,255,.8)}.layui-m-layer-footer .layui-m-layerbtn{display:block;height:auto;background:0 0;border-top:none}.layui-m-layer-footer .layui-m-layerbtn span{background-color:rgba(255,255,255,.8)}.layui-m-layer-footer .layui-m-layerbtn span[no]{color:#FD482C;border-top:1px solid #c2c2c2;border-radius:0 0 5px 5px}.layui-m-layer-footer .layui-m-layerbtn span[yes]{margin-top:10px;border-radius:5px}body .layui-m-layer .layui-m-layer-msg{width:auto;max-width:90%;margin:0 auto;bottom:-150px;background-color:rgba(0,0,0,.7);color:#fff}.layui-m-layer-msg .layui-m-layercont{padding:10px 20px}

================================================
FILE: static/js/layer/theme/default/layer.css
================================================
.layui-layer-imgbar,.layui-layer-imgtit a,.layui-layer-tab .layui-layer-title span,.layui-layer-title{text-overflow:ellipsis;white-space:nowrap}html #layuicss-layer{display:none;position:absolute;width:1989px}.layui-layer,.layui-layer-shade{position:fixed;_position:absolute;pointer-events:auto}.layui-layer-shade{top:0;left:0;width:100%;height:100%;_height:expression(document.body.offsetHeight+"px")}.layui-layer{-webkit-overflow-scrolling:touch;top:150px;left:0;margin:0;padding:0;background-color:#fff;-webkit-background-clip:content;border-radius:2px;box-shadow:1px 1px 50px rgba(0,0,0,.3)}.layui-layer-close{position:absolute}.layui-layer-content{position:relative}.layui-layer-border{border:1px solid #B2B2B2;border:1px solid rgba(0,0,0,.1);box-shadow:1px 1px 5px rgba(0,0,0,.2)}.layui-layer-load{background:url(loading-1.gif) center center no-repeat #eee}.layui-layer-ico{background:url(icon.png) no-repeat}.layui-layer-btn a,.layui-layer-dialog .layui-layer-ico,.layui-layer-setwin a{display:inline-block;*display:inline;*zoom:1;vertical-align:top}.layui-layer-move{display:none;position:fixed;*position:absolute;left:0;top:0;width:100%;height:100%;cursor:move;opacity:0;filter:alpha(opacity=0);background-color:#fff;z-index:2147483647}.layui-layer-resize{position:absolute;width:15px;height:15px;right:0;bottom:0;cursor:se-resize}.layer-anim{-webkit-animation-fill-mode:both;animation-fill-mode:both;-webkit-animation-duration:.3s;animation-duration:.3s}@-webkit-keyframes layer-bounceIn{0%{opacity:0;-webkit-transform:scale(.5);transform:scale(.5)}100%{opacity:1;-webkit-transform:scale(1);transform:scale(1)}}@keyframes layer-bounceIn{0%{opacity:0;-webkit-transform:scale(.5);-ms-transform:scale(.5);transform:scale(.5)}100%{opacity:1;-webkit-transform:scale(1);-ms-transform:scale(1);transform:scale(1)}}.layer-anim-00{-webkit-animation-name:layer-bounceIn;animation-name:layer-bounceIn}@-webkit-keyframes layer-zoomInDown{0%{opacity:0;-webkit-transform:scale(.1) translateY(-2000px);transform:scale(.1) translateY(-2000px);-webkit-animation-timing-function:ease-in-out;animation-timing-function:ease-in-out}60%{opacity:1;-webkit-transform:scale(.475) translateY(60px);transform:scale(.475) translateY(60px);-webkit-animation-timing-function:ease-out;animation-timing-function:ease-out}}@keyframes layer-zoomInDown{0%{opacity:0;-webkit-transform:scale(.1) translateY(-2000px);-ms-transform:scale(.1) translateY(-2000px);transform:scale(.1) translateY(-2000px);-webkit-animation-timing-function:ease-in-out;animation-timing-function:ease-in-out}60%{opacity:1;-webkit-transform:scale(.475) translateY(60px);-ms-transform:scale(.475) translateY(60px);transform:scale(.475) translateY(60px);-webkit-animation-timing-function:ease-out;animation-timing-function:ease-out}}.layer-anim-01{-webkit-animation-name:layer-zoomInDown;animation-name:layer-zoomInDown}@-webkit-keyframes layer-fadeInUpBig{0%{opacity:0;-webkit-transform:translateY(2000px);transform:translateY(2000px)}100%{opacity:1;-webkit-transform:translateY(0);transform:translateY(0)}}@keyframes layer-fadeInUpBig{0%{opacity:0;-webkit-transform:translateY(2000px);-ms-transform:translateY(2000px);transform:translateY(2000px)}100%{opacity:1;-webkit-transform:translateY(0);-ms-transform:translateY(0);transform:translateY(0)}}.layer-anim-02{-webkit-animation-name:layer-fadeInUpBig;animation-name:layer-fadeInUpBig}@-webkit-keyframes layer-zoomInLeft{0%{opacity:0;-webkit-transform:scale(.1) translateX(-2000px);transform:scale(.1) translateX(-2000px);-webkit-animation-timing-function:ease-in-out;animation-timing-function:ease-in-out}60%{opacity:1;-webkit-transform:scale(.475) translateX(48px);transform:scale(.475) translateX(48px);-webkit-animation-timing-function:ease-out;animation-timing-function:ease-out}}@keyframes layer-zoomInLeft{0%{opacity:0;-webkit-transform:scale(.1) translateX(-2000px);-ms-transform:scale(.1) translateX(-2000px);transform:scale(.1) translateX(-2000px);-webkit-animation-timing-function:ease-in-out;animation-timing-function:ease-in-out}60%{opacity:1;-webkit-transform:scale(.475) translateX(48px);-ms-transform:scale(.475) translateX(48px);transform:scale(.475) translateX(48px);-webkit-animation-timing-function:ease-out;animation-timing-function:ease-out}}.layer-anim-03{-webkit-animation-name:layer-zoomInLeft;animation-name:layer-zoomInLeft}@-webkit-keyframes layer-rollIn{0%{opacity:0;-webkit-transform:translateX(-100%) rotate(-120deg);transform:translateX(-100%) rotate(-120deg)}100%{opacity:1;-webkit-transform:translateX(0) rotate(0);transform:translateX(0) rotate(0)}}@keyframes layer-rollIn{0%{opacity:0;-webkit-transform:translateX(-100%) rotate(-120deg);-ms-transform:translateX(-100%) rotate(-120deg);transform:translateX(-100%) rotate(-120deg)}100%{opacity:1;-webkit-transform:translateX(0) rotate(0);-ms-transform:translateX(0) rotate(0);transform:translateX(0) rotate(0)}}.layer-anim-04{-webkit-animation-name:layer-rollIn;animation-name:layer-rollIn}@keyframes layer-fadeIn{0%{opacity:0}100%{opacity:1}}.layer-anim-05{-webkit-animation-name:layer-fadeIn;animation-name:layer-fadeIn}@-webkit-keyframes layer-shake{0%,100%{-webkit-transform:translateX(0);transform:translateX(0)}10%,30%,50%,70%,90%{-webkit-transform:translateX(-10px);transform:translateX(-10px)}20%,40%,60%,80%{-webkit-transform:translateX(10px);transform:translateX(10px)}}@keyframes layer-shake{0%,100%{-webkit-transform:translateX(0);-ms-transform:translateX(0);transform:translateX(0)}10%,30%,50%,70%,90%{-webkit-transform:translateX(-10px);-ms-transform:translateX(-10px);transform:translateX(-10px)}20%,40%,60%,80%{-webkit-transform:translateX(10px);-ms-transform:translateX(10px);transform:translateX(10px)}}.layer-anim-06{-webkit-animation-name:layer-shake;animation-name:layer-shake}@-webkit-keyframes fadeIn{0%{opacity:0}100%{opacity:1}}.layui-layer-title{padding:0 80px 0 20px;height:50px;line-height:50px;border-bottom:1px solid #F0F0F0;font-size:14px;color:#333;overflow:hidden;border-radius:2px 2px 0 0}.layui-layer-setwin{position:absolute;right:15px;*right:0;top:17px;font-size:0;line-height:initial}.layui-layer-setwin a{position:relative;width:16px;height:16px;margin-left:10px;font-size:12px;_overflow:hidden}.layui-layer-setwin .layui-layer-min cite{position:absolute;width:14px;height:2px;left:0;top:50%;margin-top:-1px;background-color:#2E2D3C;cursor:pointer;_overflow:hidden}.layui-layer-setwin .layui-layer-min:hover cite{background-color:#2D93CA}.layui-layer-setwin .layui-layer-max{background-position:-32px -40px}.layui-layer-setwin .layui-layer-max:hover{background-position:-16px -40px}.layui-layer-setwin .layui-layer-maxmin{background-position:-65px -40px}.layui-layer-setwin .layui-layer-maxmin:hover{background-position:-49px -40px}.layui-layer-setwin .layui-layer-close1{background-position:1px -40px;cursor:pointer}.layui-layer-setwin .layui-layer-close1:hover{opacity:.7}.layui-layer-setwin .layui-layer-close2{position:absolute;right:-28px;top:-28px;width:30px;height:30px;margin-left:0;background-position:-149px -31px;*right:-18px;_display:none}.layui-layer-setwin .layui-layer-close2:hover{background-position:-180px -31px}.layui-layer-btn{text-align:right;padding:0 15px 12px;pointer-events:auto;user-select:none;-webkit-user-select:none}.layui-layer-btn a{height:28px;line-height:28px;margin:5px 5px 0;padding:0 15px;border:1px solid #dedede;background-color:#fff;color:#333;border-radius:2px;font-weight:400;cursor:pointer;text-decoration:none}.layui-layer-btn a:hover{opacity:.9;text-decoration:none}.layui-layer-btn a:active{opacity:.8}.layui-layer-btn .layui-layer-btn0{border-color:#1E9FFF;background-color:#1E9FFF;color:#fff}.layui-layer-btn-l{text-align:left}.layui-layer-btn-c{text-align:center}.layui-layer-dialog{min-width:300px}.layui-layer-dialog .layui-layer-content{position:relative;padding:20px;line-height:24px;word-break:break-all;overflow:hidden;font-size:14px;overflow-x:hidden;overflow-y:auto}.layui-layer-dialog .layui-layer-content .layui-layer-ico{position:absolute;top:16px;left:15px;_left:-40px;width:30px;height:30px}.layui-layer-ico1{background-position:-30px 0}.layui-layer-ico2{background-position:-60px 0}.layui-layer-ico3{background-position:-90px 0}.layui-layer-ico4{background-position:-120px 0}.layui-layer-ico5{background-position:-150px 0}.layui-layer-ico6{background-position:-180px 0}.layui-layer-rim{border:6px solid #8D8D8D;border:6px solid rgba(0,0,0,.3);border-radius:5px;box-shadow:none}.layui-layer-msg{min-width:180px;border:1px solid #D3D4D3;box-shadow:none}.layui-layer-hui{min-width:100px;background-color:#000;filter:alpha(opacity=60);background-color:rgba(0,0,0,.6);color:#fff;border:none}.layui-layer-hui .layui-layer-content{padding:12px 25px;text-align:center}.layui-layer-dialog .layui-layer-padding{padding:20px 20px 20px 55px;text-align:left}.layui-layer-page .layui-layer-content{position:relative;overflow:auto}.layui-layer-iframe .layui-layer-btn,.layui-layer-page .layui-layer-btn{padding-top:10px}.layui-layer-nobg{background:0 0}.layui-layer-iframe iframe{display:block;width:100%}.layui-layer-loading{border-radius:100%;background:0 0;box-shadow:none;border:none}.layui-layer-loading .layui-layer-content{width:60px;height:24px;background:url(loading-0.gif) no-repeat}.layui-layer-loading .layui-layer-loading1{width:37px;height:37px;background:url(loading-1.gif) no-repeat}.layui-layer-ico16,.layui-layer-loading .layui-layer-loading2{width:32px;height:32px;background:url(loading-2.gif) no-repeat}.layui-layer-tips{background:0 0;box-shadow:none;border:none}.layui-layer-tips .layui-layer-content{position:relative;line-height:22px;min-width:12px;padding:8px 15px;font-size:12px;_float:left;border-radius:2px;box-shadow:1px 1px 3px rgba(0,0,0,.2);background-color:#000;color:#fff}.layui-layer-tips .layui-layer-close{right:-2px;top:-1px}.layui-layer-tips i.layui-layer-TipsG{position:absolute;width:0;height:0;border-width:8px;border-color:transparent;border-style:dashed;*overflow:hidden}.layui-layer-tips i.layui-layer-TipsB,.layui-layer-tips i.layui-layer-TipsT{left:5px;border-right-style:solid;border-right-color:#000}.layui-layer-tips i.layui-layer-TipsT{bottom:-8px}.layui-layer-tips i.layui-layer-TipsB{top:-8px}.layui-layer-tips i.layui-layer-TipsL,.layui-layer-tips i.layui-layer-TipsR{top:5px;border-bottom-style:solid;border-bottom-color:#000}.layui-layer-tips i.layui-layer-TipsR{left:-8px}.layui-layer-tips i.layui-layer-TipsL{right:-8px}.layui-layer-lan[type=dialog]{min-width:280px}.layui-layer-lan .layui-layer-title{background:#4476A7;color:#fff;border:none}.layui-layer-lan .layui-layer-btn{padding:5px 10px 10px;text-align:right;border-top:1px solid #E9E7E7}.layui-layer-lan .layui-layer-btn a{background:#fff;border-color:#E9E7E7;color:#333}.layui-layer-lan .layui-layer-btn .layui-layer-btn1{background:#C9C5C5}.layui-layer-molv .layui-layer-title{background:#009f95;color:#fff;border:none}.layui-layer-molv .layui-layer-btn a{background:#009f95;border-color:#009f95}.layui-layer-molv .layui-layer-btn .layui-layer-btn1{background:#92B8B1}.layui-layer-iconext{background:url(icon-ext.png) no-repeat}.layui-layer-prompt .layui-layer-input{display:block;width:260px;height:36px;margin:0 auto;line-height:30px;padding-left:10px;border:1px solid #e6e6e6;color:#333}.layui-layer-prompt textarea.layui-layer-input{width:300px;height:100px;line-height:20px;padding:6px 10px}.layui-layer-prompt .layui-layer-content{padding:20px}.layui-layer-prompt .layui-layer-btn{padding-top:0}.layui-layer-tab{box-shadow:1px 1px 50px rgba(0,0,0,.4)}.layui-layer-tab .layui-layer-title{padding-left:0;overflow:visible}.layui-layer-tab .layui-layer-title span{position:relative;float:left;min-width:80px;max-width:300px;padding:0 20px;text-align:center;overflow:hidden;cursor:pointer}.layui-layer-tab .layui-layer-title span.layui-this{height:51px;border-left:1px solid #eee;border-right:1px solid #eee;background-color:#fff;z-index:10}.layui-layer-tab .layui-layer-title span:first-child{border-left:none}.layui-layer-tabmain{line-height:24px;clear:both}.layui-layer-tabmain .layui-layer-tabli{display:none}.layui-layer-tabmain .layui-layer-tabli.layui-this{display:block}.layui-layer-photos{background:0 0;box-shadow:none}.layui-layer-photos .layui-layer-content{overflow:hidden;text-align:center}.layui-layer-photos .layui-layer-phimg img{position:relative;width:100%;display:inline-block;*display:inline;*zoom:1;vertical-align:top}.layui-layer-imgnext,.layui-layer-imgprev{position:fixed;top:50%;width:27px;_width:44px;height:44px;margin-top:-22px;outline:0;blr:expression(this.onFocus=this.blur())}.layui-layer-imgprev{left:30px;background-position:-5px -5px;_background-position:-70px -5px}.layui-layer-imgprev:hover{background-position:-33px -5px;_background-position:-120px -5px}.layui-layer-imgnext{right:30px;_right:8px;background-position:-5px -50px;_background-position:-70px -50px}.layui-layer-imgnext:hover{background-position:-33px -50px;_background-position:-120px -50px}.layui-layer-imgbar{position:fixed;left:0;right:0;bottom:0;width:100%;height:40px;line-height:40px;background-color:#000\9;filter:Alpha(opacity=60);background-color:rgba(2,0,0,.35);color:#fff;overflow:hidden;font-size:0}.layui-layer-imgtit *{display:inline-block;*display:inline;*zoom:1;vertical-align:top;font-size:12px}.layui-layer-imgtit a{max-width:65%;overflow:hidden;color:#fff}.layui-layer-imgtit a:hover{color:#fff;text-decoration:underline}.layui-layer-imgtit em{padding-left:10px;font-style:normal}@-webkit-keyframes layer-bounceOut{100%{opacity:0;-webkit-transform:scale(.7);transform:scale(.7)}30%{-webkit-transform:scale(1.05);transform:scale(1.05)}0%{-webkit-transform:scale(1);transform:scale(1)}}@keyframes layer-bounceOut{100%{opacity:0;-webkit-transform:scale(.7);-ms-transform:scale(.7);transform:scale(.7)}30%{-webkit-transform:scale(1.05);-ms-transform:scale(1.05);transform:scale(1.05)}0%{-webkit-transform:scale(1);-ms-transform:scale(1);transform:scale(1)}}.layer-anim-close{-webkit-animation-name:layer-bounceOut;animation-name:layer-bounceOut;-webkit-animation-fill-mode:both;animation-fill-mode:both;-webkit-animation-duration:.2s;animation-duration:.2s}@media screen and (max-width:1100px){.layui-layer-iframe{overflow-y:auto;-webkit-overflow-scrolling:touch}}

================================================
FILE: templates/index.html
================================================
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
	<title>ChatTTS WebUI & API - v{{version}}</title>
    <link href="/static/js/bootstrap.min.css" rel="stylesheet">
	
	<style>
	#upload-btn{
		position:relative;
	}
	#file-input{
		position:absolute;
		left:0;
		right:0;
		top:0;
		bottom:0;
		width:100%;
		height:100%;
		z-index:1;
		opacity:0;
		cursor:pointer;
		font-size:0;
		
	}
	#text-input{
		min-height:200px
	}

    .btn-warning {
      background-color: #ffc107;
      border-color: #ffc107;
    }
	.font12{
		font-size:12px
	}
	.w-50px{
		display:inline-block;
		width:50px;
		white-space:nowrap;
		overflow:visible
	}
	
	</style>
</head>
<body>	

<div class="container my-4 px-0">
	<div>
		<h1 class="text-center">ChatTTS WebUI & API<span class="fs-6">(v{{version}})</span></h1>
	</div>
	<hr>
    <div class="row justify-content-center">
        <div class="col-12  my-2">
            <textarea id="text-input" class="form-control d-block" rows="3" placeholder="在此输入要转换的文本,以行为单位合成..."></textarea>
			<span class="text-secondary fs-6">除文本框必填外，其他均为可选，若不懂无需填写</span>
        </div>
		<div class="col-12 my-2 ">
			<div class="row align-items-center gx-1">
				<div class="col align-items-center input-group">
					<span class="input-group-text">选择音色</span>
					<select id="voice" class="form-control">
						{% for speaker in speakers %}
							<option value="{{speaker}}">{{speaker}}</option>
						{% endfor %}
					</select>
				</div>
				<div class="col align-items-center input-group">
						<span class="input-group-text" id="">音色值</span>
						<input id="custom_voice" data-toggle="tooltip" title="填写后将忽略左侧音色选择，以该填写值获取音色,例如 2000，8000等" class="form-control" placeholder="自定义音色种子值，大于1,如 3000 9000等" type="number" min="0" />
				</div>
				<div class="col align-items-center input-group">
					<span class="input-group-text  rounded-0 px-1" id="">text seed</span>
					<input id="text_seed" class="form-control  rounded-0 " value="42" type="number" min="0" >
				</div>
				<div class="col align-items-center input-group"> 
						<span class="input-group-text" id="">Prompt</span>
						<input id="prompt" value="[break_6]" class="form-control" data-toggle="tooltip" title="填写prompt，如 [oral_2][laugh_0][break_6]" placeholder="如 [oral_2][laugh_0][break_6]" />
				</div>
				
				<div class="col-2 align-items-center">
				  <div class="form-check" title="如果文本中加入了控制符或效果较差，可尝试选中该项" data-toggle="tooltip">
					<input type="checkbox" checked class="form-check-input" id="skip_refine">
					<label class="form-check-label" for="skip_refine">跳过refine text</label>
				  </div>
				</div>
				<div class="col-2 align-items-center d-none">
				  <div class="form-check" title="是否流式" data-toggle="tooltip">
					<input type="checkbox" class="form-check-input" id="is_stream">
					<label class="form-check-label" for="is_stream">流式?</label>
				  </div>
				</div>
			</div>
		</div>
		<div class="col-12 my-2 d-flex align-items-center justify-content-between" id="temper_wrap">
			<div class="row gx-1">
			<div class="align-items-center col d-flex">
					<span class="input-group-text  rounded-0 px-1" id="">infer token</span>
					<input id="infer_max_new_token" data-toggle="tooltip" class="form-control rounded-0 " value="2048" type="number" min="1024"  title="推理最大token，默认2048">
			</div>
			<div class="align-items-center col d-flex">
					<span class="input-group-text  rounded-0 px-1" id="">refine token</span>
					<input id="refine_max_new_token" data-toggle="tooltip" class="form-control  rounded-0 " value="384" type="number" min="1" title="refine text 最大token，默认384，未跳过refine text时有效">
			</div>
			<div class="form-group d-flex col-auto align-items-center">
				<label for="speed">语速</label>
				<input type="range" class="form-control-range" id="speed" min="1" max="9" step="1" value="5">
				<span class="w-50px text-secondary font12">5</span>
			</div>
			
			<div class="form-group d-flex col align-items-center">
				<label for="temperature">temperature</label>
				<input type="range" class="form-control-range" id="temperature" min="0.00001" max="1.0" step="0.00001" value="0.1">
				<span class="w-50px text-secondary font12">0.1</span>
			</div>
			
			<div class="form-group d-flex col align-items-center">
				<label for="top_p">top_p</label>
				<input type="range" class="form-control-range" id="top_p" min="0.001" max="0.9" step="0.05" value="0.7">
				<span class="w-50px text-secondary font12">0.05</span>

			</div>
			
			<div class="form-group d-flex col align-items-center">
				<label for="top_k">top_k</label>
				<input type="range" class="form-control-range" id="top_k" min="1" max="20" step="1" value="20">
				<span class="w-50px text-secondary font12">20</span>				
			</div>			
			</div>
		</div>
        <div class="col-12  my-4 text-center">
            <button id="submit-btn" class="btn btn-primary">立即合成声音</button>
			<button id="upload-btn" class="btn btn-secondary">导入txt
				<input type="file" id="file-input" accept=".txt"  >
			</button>
            <button id="clear-btn" class="btn btn-warning text-light" data-toggle="tooltip" title="删除所有已生成的wav文件">清理所有wav文件</button>
        </div>
        <div class="col-12  mt-4" >
			<div class="row" id="audio-container"></div>
            <div class="m-2 bg-black text-white d-none" id="code"></div>
        </div>
    </div>
	
	<div id="stream" class="d-none">
		<audio controls id="stream_audio"></audio>
	</div>
	
	<div class="text-center my-4">
		<a class="btn btn-link text-secondary" href="https://github.com/jianchang512/chatTTS-ui" target="_blank">GitHub ChatTTS-UI</a>
		<a class="btn btn-link text-secondary" href="https://github.com/2noise/ChatTTS" target="_blank">GitHub ChatTTS</a>
	</div>
</div>

<script src="/static/js/jquery.min.js"></script>
<script src="/static/js/layer/layer.js"></script>
<script src="/static/js/bootstrap.bundle.min.js"></script>
<script>
$(document).ready(function() {
  $('[data-toggle="tooltip"]').tooltip();

    let audioGenerated = false;

  $('#temper_wrap input[type="range"]').on('input',function(){
	$(this).next().text(($(this).val()));
  });
    $('#submit-btn').click(function() {
        var text = $('#text-input').val().trim();
        if (text === '') {
            layer.alert('必须输入文本',{title:false});
        } else {
			let index=layer.load();
			let custom_voice=$('#custom_voice').val();
			/*
			text_list=text.split("\n").map(it=>{
				it=it.trim()
				if(it.length>150 && /。/.test(it)){
					return it.replace(/。/g,"。\n")
				}
				return it    
			});
			text=text_list.join("")
			*/
			let data={
				text: text,
				prompt:$('#prompt').val(),
				voice:$('#voice').val(),
				speed:parseInt($('#speed').val()),
				temperature:parseFloat($('#temperature').val()),
				top_p:parseFloat($('#top_p').val()),
				top_k:parseFloat($('#top_k').val()),
				refine_max_new_token:parseInt($('#refine_max_new_token').val()),
				infer_max_new_token:parseInt($('#infer_max_new_token').val()),
				text_seed:parseInt($(text_seed).val()),
				skip_refine:$('#skip_refine').prop('checked')?1:0,
				is_stream:0,
				custom_voice:custom_voice?parseInt(custom_voice):0
			};

      $.ajax({
        url: '/tts',
        type: 'POST',
        data: data,
        timeout: 3600000,
        success: function(response) {
          if (response.code === 0) {
            console.log(response);
            if (response.audio_files) {
              response.audio_files.forEach(function(audio, index) {
                let pos = audio.filename.lastIndexOf('/') + 1;
                let filename = audio.filename.substr(pos);
                let jsCode = `# API调用代码

import requests

res = requests.post('http://${location.host}/tts', data=${JSON.stringify(data, null, 2)})
print(res.json())

#ok
{code:0, msg:'ok', audio_files:[{filename: ${audio.filename}, url: ${audio.url}}]}

#error
{code:1, msg:"error"}
`;
				let n=$('#audio-container > div').length+1;
                $('#audio-container').prepend(
				`
                  <div class="col-12 mb-2 pb-2 border-bottom">
                    <div>						
						[${n}] ${filename} 
					</div>
					<div class="d-flex align-items-center my-1">
						<a title="移除显示，不删除wav文件" href="javascripts:;" onclick="$(this).parent().parent().remove()" class="btn btn-close font12 me-2"></a>
						<audio controls autoplay src="${audio.url}"></audio>
                                                <a href="${audio.url}" download="${filename}" class="btn btn-success ms-2">下载音频</a>
					</div>
                    <div class="d-flex align-items-center text-secondary fs-6">
						<button class="btn btn-info text-light me-2 show-js-btn" data-js-code="${encodeURIComponent(jsCode)}">显示API调用</button>
						<span>
						推理时长: ${audio.inference_time} 秒
						</span>
					</div>
                    <div class="m-2 bg-black text-white d-none code-container p-1"></div>
                  </div>
                `);
              });

              audioGenerated = true;
            } else {
              layer.alert('音频文件生成失败', {title: false});
            }
          } else {
            layer.alert(response.msg, {title: false});
          }
        },
        error: function(xhr, status, error) {
          layer.alert('发生错误: ' + error, {title: false});
        },
        complete: function() {
          layer.close(index);
        }
      });
    }
  });

  $(document).on('click', '.show-js-btn', function() {
    let codeContainer = $(this).parent().next('.code-container');
    codeContainer.toggleClass('d-none');
    if (!codeContainer.hasClass('d-none')) {
      codeContainer.html(`<pre><code>${decodeURIComponent($(this).data('js-code'))}</code></pre>`);
    }
  });


	$('#upload-btn').click(function() {
        $('#file-input').click()
    });
    
    $('#file-input').change(function(e) {
        var file = e.target.files[0];
        if(file) {
            var reader = new FileReader();
            reader.onload = function(e) {
                $('#text-input').val(e.target.result);
            };
            reader.readAsText(file, 'UTF-8');
        }
    });

    $('#clear-btn').click(function() {
    layer.confirm('是否要清除所有wav文件', {
      btn: ['是', '否'],
	  title:false
    }, function() {
	  layer.msg('清理中...')	 
      $.ajax({
        url: '/clear_wavs',
        type: 'POST',
        success: function(response) {
          if (response.code === 0) {
		    $('#audio-container').html('')
            layer.alert('清理成功', {title: false});
          } else {
            layer.alert('清理失败: ' + response.msg, {title: false});
          }
        },
        error: function(xhr, status, error) {
          layer.alert('发生错误: ' + error, {title: false});
        }
      });
    });
  });

	
	


});


/*
let audio_queue=[]
let audio_el=document.getElementById('stream_audio')
const eventSource = new EventSource('/streamtts');
eventSource.onmessage = function(event) {
	console.log(event);
	try{
		let t=JSON.parse(event.data);
		audio_queue.push(t)
		if(audio_el.ended || !audio_el.getAttribute('src')){
			goon_play();
		}
	}catch(e){}
};
function goon_play(){
	if(audio_queue.length>0){
		let t=audio_queue.shift();
		audio_el.src=t['url']
		audio_el.play()
	}
}



audio_el.addEventListener("ended", (event) => {
	goon_play()
});
audio_el.addEventListener("waiting", (event) => {
	goon_play()
});

*/
</script>
</body></html>

================================================
FILE: templates/indexen.html
================================================
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
	<title>ChatTTS WebUI & API - v{{version}}</title>
    <link href="/static/js/bootstrap.min.css" rel="stylesheet">
	
	<style>
	#upload-btn{
		position:relative;
	}
	#file-input{
		position:absolute;
		left:0;
		right:0;
		top:0;
		bottom:0;
		width:100%;
		height:100%;
		z-index:1;
		opacity:0;
		cursor:pointer;
		font-size:0;
		
	}
	#text-input{
		min-height:200px
	}

    .btn-warning {
      background-color: #ffc107;
      border-color: #ffc107;
    }
	.font12{
		font-size:12px
	}
	.w-50px{
		display:inline-block;
		width:50px;
		white-space:nowrap;
		overflow:visible
	}
	
	</style>
</head>
<body>	

<div class="container my-4 px-0">
	<div>
		<h1 class="text-center">ChatTTS WebUI & API<span class="fs-6">(v{{version}})</span></h1>
	</div>
	<hr>
    <div class="row justify-content-center">
<div class="col-12  my-2">
    <textarea id="text-input" class="form-control d-block" rows="3" placeholder="Enter the text to be converted here, synthesize by line..."></textarea>
    <span class="text-secondary fs-6">Besides the textbox being required, all others are optional. If you do not understand, no need to fill out.</span>
</div>
<div class="col-12 my-2 ">
    <div class="row align-items-center gx-1">
        <div class="col align-items-center input-group">
            <span class="input-group-text">Select Voice</span>
            <select id="voice" class="form-control">
                {% for speaker in speakers %}
							<option value="{{speaker}}">{{speaker}}</option>
						{% endfor %}
            </select>
        </div>
        <div class="col align-items-center input-group">
            <span class="input-group-text" id="">Voice Value</span>
            <input id="custom_voice" data-toggle="tooltip" title="If filled in, the voice selection on the left will be ignored, and the voice will be obtained with this filled-in value, e.g., 2000, 8000, etc." class="form-control" placeholder="Custom voice seed value, greater than 1, such as 3000, 9000, etc." type="number" min="0" />
        </div>
        <div class="col align-items-center input-group">
            <span class="input-group-text  rounded-0 px-1" id="">text seed</span>
            <input id="text_seed" class="form-control  rounded-0 " value="42" type="number" min="0" >
        </div>
        <div class="col align-items-center input-group"> 
            <span class="input-group-text" id="">Prompt</span>
            <input id="prompt" class="form-control" value="[break_6]" data-toggle="tooltip" title="Fill in the prompt, such as [oral_2][laugh_0][break_6]" placeholder="For example [oral_2][laugh_0][break_6]" />
        </div>
        
        <div class="col-2 align-items-center">
          <div class="form-check" title="If control characters have been added to the text or the effect is poor, you can try selecting this option" data-toggle="tooltip">
            <input type="checkbox" checked class="form-check-input" id="skip_refine">
            <label class="form-check-label" for="skip_refine">Skip Refine Text</label>
          </div>
        </div>
    </div>
</div>
		<div class="col-12 my-2 d-flex align-items-center justify-content-between" id="temper_wrap">
    <div class="row gx-1">
    <div class="align-items-center col d-flex">
            <span class="input-group-text  rounded-0 px-1" id="">infer token</span>
            <input id="infer_max_new_token" data-toggle="tooltip" class="form-control rounded-0 " value="2048" type="number" min="1024"  title="Maximum inference token, default 2048">
    </div>
    <div class="align-items-center col d-flex">
            <span class="input-group-text  rounded-0 px-1" id="">refine token</span>
            <input id="refine_max_new_token" data-toggle="tooltip" class="form-control  rounded-0 " value="384" type="number" min="1" title="Maximum refine text token, default 384, effective when not skipping refine text">
    </div>
    <div class="form-group d-flex col-auto align-items-center">
        <label for="speed">Speed</label>
        <input type="range" class="form-control-range" id="speed" min="1" max="9" step="1" value="5">
        <span class="w-50px text-secondary font12">5</span>
    </div>
    
    <div class="form-group d-flex col align-items-center">
        <label for="temperature">temperature</label>
        <input type="range" class="form-control-range" id="temperature" min="0.00001" max="1.0" step="0.00001" value="0.1">
        <span class="w-50px text-secondary font12">0.1</span>
    </div>
    
    <div class="form-group d-flex col align-items-center">
        <label for="top_p">top_p</label>
        <input type="range" class="form-control-range" id="top_p" min="0.001" max="0.9" step="0.05" value="0.7">
        <span class="w-50px text-secondary font12">0.05</span>

    </div>
    
    <div class="form-group d-flex col align-items-center">
        <label for="top_k">top_k</label>
        <input type="range" class="form-control-range" id="top_k" min="1" max="20" step="1" value="20">
        <span class="w-50px text-secondary font12">20</span>
        
    </div>			
    </div>
</div>
<div class="col-12  my-4 text-center">
    <button id="submit-btn" class="btn btn-primary">Synthesize Voice Now</button>
    <button id="upload-btn" class="btn btn-secondary">Import txt
        <input type="file" id="file-input" accept=".txt"  >
    </button>
    <button id="clear-btn" class="btn btn-warning text-light" data-toggle="tooltip" title="Delete all generated wav files">Clear all wav files</button>
</div>
<div class="col-12  mt-4" >
    <div class="row" id="audio-container"></div>
    <div class="m-2 bg-black text-white d-none" id="code"></div>
</div>
    </div>
	
	<div class="text-center my-4">
		<a class="btn btn-link text-secondary" href="https://github.com/jianchang512/chatTTS-ui" target="_blank">GitHub ChatTTS-UI</a>
		<a class="btn btn-link text-secondary" href="https://github.com/2noise/ChatTTS" target="_blank">GitHub ChatTTS</a>
	</div>
</div>

<script src="/static/js/jquery.min.js"></script>
<script src="/static/js/layer/layer.js"></script>
<script src="/static/js/bootstrap.bundle.min.js"></script>
<script>
$(document).ready(function() {
  $('[data-toggle="tooltip"]').tooltip();

    let audioGenerated = false;

  $('#temper_wrap input[type="range"]').on('input',function(){
	$(this).next().text(($(this).val()));
  });
    $('#submit-btn').click(function() {
        var text = $('#text-input').val().trim();
        if (text === '') {
            layer.alert('Must enter text',{title:false});
        } else {
			let index=layer.load();
			let custom_voice=$('#custom_voice').val();
			/*
			text_list=text.split("\n").map(it=>{
				it=it.trim()
				if(it.length>150 && /。/.test(it)){
					return it.replace(/。/g,"。\n")
				}
				return it    
			});
			text=text_list.join("")
			*/
			let data={
				text: text,
				prompt:$('#prompt').val(),
				voice:$('#voice').val(),
				speed:parseInt($('#speed').val()),
				temperature:parseFloat($('#temperature').val()),
				top_p:parseFloat($('#top_p').val()),
				top_k:parseFloat($('#top_k').val()),
				refine_max_new_token:parseInt($('#refine_max_new_token').val()),
				infer_max_new_token:parseInt($('#infer_max_new_token').val()),
				text_seed:parseInt($(text_seed).val()),
				skip_refine:$('#skip_refine').prop('checked')?1:0,
				custom_voice:custom_voice?parseInt(custom_voice):0
			};
      $.ajax({
        url: '/tts',
        type: 'POST',
        data: data,
        timeout: 3600000,
        success: function(response) {
          if (response.code === 0) {
            console.log(response);
            if (response.audio_files) {
              response.audio_files.forEach(function(audio, index) {
                let pos = audio.filename.lastIndexOf('/') + 1;
                let filename = audio.filename.substr(pos);
                let jsCode = `# API Call Code

import requests

res = requests.post('http://${location.host}/tts', data=${JSON.stringify(data, null, 2)})
print(res.json())

#ok
{code:0, msg:'ok', audio_files:[{filename: ${audio.filename}, url: ${audio.url}}]}

#error
{code:1, msg:"error"}
`;
				let n=$('#audio-container > div').length+1;
                $('#audio-container').prepend(`
                  <div class="col-12 mb-2 pb-2 border-bottom">
                    <div>						
						[${n}] ${filename} 
					</div>
					<div class="d-flex align-items-center my-1">
						<a title="Remove display wav files" href="javascripts:;" onclick="$(this).parent().parent().remove()" class="btn btn-close font12 me-2"></a>
						<audio controls autoplay src="${audio.url}"></audio>
					</div>
                    <div class="d-flex align-items-center text-secondary fs-6">
						<button class="btn btn-info text-light me-2 show-js-btn" data-js-code="${encodeURIComponent(jsCode)}">Show API Calls</button>
						<span>
						inference time: ${audio.inference_time}s
						</span>
					</div>
                    <div class="m-2 bg-black text-white d-none code-container p-1"></div>
                  </div>
                `);
              });

              audioGenerated = true;
            } else {
              layer.alert('Audio file generation failure', {title: false});
            }
          } else {
            layer.alert(response.msg, {title: false});
          }
        },
        error: function(xhr, status, error) {
          layer.alert('error occurs: ' + error, {title: false});
        },
        complete: function() {
          layer.close(index);
        }
      });
    }
  });

  $(document).on('click', '.show-js-btn', function() {
    let codeContainer = $(this).parent().next('.code-container');
    codeContainer.toggleClass('d-none');
    if (!codeContainer.hasClass('d-none')) {
      codeContainer.html(`<pre><code>${decodeURIComponent($(this).data('js-code'))}</code></pre>`);
    }
  });


	$('#upload-btn').click(function() {
        $('#file-input').click(); // Trigger file input when upload button is clicked
    });
    
    $('#file-input').change(function(e) {
        var file = e.target.files[0];
        if(file) {
            var reader = new FileReader();
            reader.onload = function(e) {
                $('#text-input').val(e.target.result);
            };
            reader.readAsText(file, 'UTF-8');
        }
    });

    $('#clear-btn').click(function() {
    layer.confirm('Whether to clear all wav files', {
      btn: ['Yes', 'No'],
	  title:false
    }, function() {
	  layer.msg('in the process of liquidation...')	 
      $.ajax({
        url: '/clear_wavs',
        type: 'POST',
        success: function(response) {
          if (response.code === 0) {
		    $('#audio-container').html('')
            layer.alert('Clearance successful.', {title: false});
          } else {
            layer.alert('Clearance error.: ' + response.msg, {title: false});
          }
        },
        error: function(xhr, status, error) {
          layer.alert('error occurs: ' + error, {title: false});
        }
      });
    });
  });


});
</script>


</body></html>

================================================
FILE: test.py
================================================
import os
import re
import sys
if sys.platform == "darwin":
    os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
import io
import json
import torchaudio
import wave
from pathlib import Path
print('Starting...')
import shutil
import time


import torch
import torch._dynamo
torch._dynamo.config.suppress_errors = True
torch._dynamo.config.cache_size_limit = 64
torch._dynamo.config.suppress_errors = True
torch.set_float32_matmul_precision('high')
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
import subprocess
import soundfile as sf
import ChatTTS
import datetime
from dotenv import load_dotenv
load_dotenv()

import logging
from logging.handlers import RotatingFileHandler

from random import random
from modelscope import snapshot_download
import numpy as np
import threading
from uilib.cfg import WEB_ADDRESS, SPEAKER_DIR, LOGS_DIR, WAVS_DIR, MODEL_DIR, ROOT_DIR
from uilib import utils,VERSION
from ChatTTS.utils.gpu_utils import select_device
from uilib.utils import is_chinese_os,modelscope_status
merge_size=int(os.getenv('merge_size',10))
env_lang=os.getenv('lang','')
if env_lang=='zh':
    is_cn= True
elif env_lang=='en':
    is_cn=False
else:
    is_cn=is_chinese_os()
    
CHATTTS_DIR= MODEL_DIR+'/pzc163/chatTTS'


chat = ChatTTS.Chat()
device=os.getenv('device','default')
chat.load(source="custom",custom_path=CHATTTS_DIR, device=None if device=='default' else device,compile=True if os.getenv('compile','true').lower()!='false' else False)

for it in os.listdir('./speaker'):
    if it.startswith('seed_') and not it.endswith('_emb-covert.pt'):
        

        rand_spk=torch.load(f'./speaker/{it}', map_location=select_device(4096) if device=='default' else torch.device(device))

        torch.save( chat._encode_spk_emb(rand_spk) ,f"{SPEAKER_DIR}/{it.replace('.pt','-covert.pt')}")

================================================
FILE: tools/__init__.py
================================================


================================================
FILE: tools/audio/__init__.py
================================================
from .np import unsafe_float_to_int16


================================================
FILE: tools/audio/np.py
================================================
import numpy as np
from numba import jit


@jit
def unsafe_float_to_int16(audio: np.ndarray) -> np.ndarray:
    """
    This function will destroy audio, use only once.
    """
    am = np.abs(audio).max() * 32768
    am = 32767 * 32768 / am
    np.multiply(audio, am, audio)
    audio16 = audio.astype(np.int16)
    return audio16


================================================
FILE: tools/checksum/main.go
================================================
package main

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
	"os"
)

func main() {
	var buf [32]byte
	h := sha256.New()
	lst := make([]any, 0, 64)
	for _, fname := range files {
		f, err := os.Open(fname)
		if err != nil {
			panic(err)
		}
		_, err = io.Copy(h, f)
		if err != nil {
			panic(err)
		}
		s := hex.EncodeToString(h.Sum(buf[:0]))
		fmt.Println("sha256 of", fname, "=", s)
		lst = append(lst, s)
		h.Reset()
		f.Close()
	}
	f, err := os.Create("ChatTTS/res/sha256_map.json")
	if err != nil {
		panic(err)
	}
	_, err = fmt.Fprintf(f, jsontmpl, lst...)
	if err != nil {
		panic(err)
	}
}


================================================
FILE: tools/checksum/tmpl.go
================================================
package main

var files = [...]string{
	"asset/Decoder.pt",
	"asset/DVAE.pt",
	"asset/GPT.pt",
	"asset/spk_stat.pt",
	"asset/tokenizer.pt",
	"asset/Vocos.pt",

	"config/decoder.yaml",
	"config/dvae.yaml",
	"config/gpt.yaml",
	"config/path.yaml",
	"config/vocos.yaml",
}

const jsontmpl = `{
	"sha256_asset_Decoder_pt"   : "%s",
	"sha256_asset_DVAE_pt"      : "%s",
	"sha256_asset_GPT_pt"       : "%s",
	"sha256_asset_spk_stat_pt"  : "%s",
	"sha256_asset_tokenizer_pt" : "%s",
	"sha256_asset_Vocos_pt"     : "%s",

	"sha256_config_decoder_yaml": "%s",
	"sha256_config_dvae_yaml"   : "%s",
	"sha256_config_gpt_yaml"    : "%s",
	"sha256_config_path_yaml"   : "%s",
	"sha256_config_vocos_yaml"  : "%s"
}
`


================================================
FILE: tools/llm/__init__.py
================================================
from .llm import ChatOpenAI


================================================
FILE: tools/llm/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 ChatOpenAI:
    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: tools/logger/__init__.py
================================================
from .log import get_logger


================================================
FILE: tools/logger/log.py
================================================
import platform
import logging
from datetime import datetime, timezone

logging.getLogger("numba").setLevel(logging.WARNING)
logging.getLogger("httpx").setLevel(logging.WARNING)
logging.getLogger("wetext-zh_normalizer").setLevel(logging.WARNING)
logging.getLogger("NeMo-text-processing").setLevel(logging.WARNING)

# from https://github.com/FloatTech/ZeroBot-Plugin/blob/c70766a989698452e60e5e48fb2f802a2444330d/console/console_windows.go#L89-L96
colorCodePanic = "\x1b[1;31m"
colorCodeFatal = "\x1b[1;31m"
colorCodeError = "\x1b[31m"
colorCodeWarn = "\x1b[33m"
colorCodeInfo = "\x1b[37m"
colorCodeDebug = "\x1b[32m"
colorCodeTrace = "\x1b[36m"
colorReset = "\x1b[0m"

log_level_color_code = {
    logging.DEBUG: colorCodeDebug,
    logging.INFO: colorCodeInfo,
    logging.WARN: colorCodeWarn,
    logging.ERROR: colorCodeError,
    logging.FATAL: colorCodeFatal,
}

log_level_msg_str = {
    logging.DEBUG: "DEBU",
    logging.INFO: "INFO",
    logging.WARN: "WARN",
    logging.ERROR: "ERRO",
    logging.FATAL: "FATL",
}


class Formatter(logging.Formatter):
    def __init__(self, color=platform.system().lower() != "windows"):
        # https://stackoverflow.com/questions/2720319/python-figure-out-local-timezone
        self.tz = datetime.now(timezone.utc).astimezone().tzinfo
        self.color = color

    def format(self, record: logging.LogRecord):
        logstr = "[" + datetime.now(self.tz).strftime("%z %Y%m%d %H:%M:%S") + "] ["
        if self.color:
            logstr += log_level_color_code.get(record.levelno, colorCodeInfo)
        logstr += log_level_msg_str.get(record.levelno, record.levelname)
        if self.color:
            logstr += colorReset
        fn = record.filename.removesuffix(".py")
        logstr += f"] {str(record.name)} | {fn} | {str(record.msg)%record.args}"
        return logstr


def get_logger(name: str, lv=logging.INFO, remove_exist=False, format_root=False):
    logger = logging.getLogger(name)
    logger.setLevel(lv)
    if remove_exist and logger.hasHandlers():
        logger.handlers.clear()
    if not logger.hasHandlers():
        syslog = logging.StreamHandler()
        syslog.setFormatter(Formatter())
        logger.addHandler(syslog)
    else:
        for h in logger.handlers:
            h.setFormatter(Formatter())
    if format_root:
        for h in logger.root.handlers:
            h.setFormatter(Formatter())
    return logger


================================================
FILE: tools/normalizer/__init__.py
================================================
from .en import normalizer_en_nemo_text
from .zh import normalizer_zh_tn


================================================
FILE: tools/normalizer/en.py
================================================
from typing import Callable
from functools import partial


def normalizer_en_nemo_text() -> Callable[[str], str]:
    from nemo_text_processing.text_normalization.normalize import Normalizer

    return partial(
        Normalizer(input_case="cased", lang="en").normalize,
        verbose=False,
        punct_post_process=True,
    )


================================================
FILE: tools/normalizer/zh.py
================================================
from typing import Callable


def normalizer_zh_tn() -> Callable[[str], str]:
    from tn.chinese.normalizer import Normalizer

    return Normalizer().normalize


================================================
FILE: tools/seeder/__init__.py
================================================
from .ctx import TorchSeedContext


================================================
FILE: tools/seeder/ctx.py
================================================
import torch


class TorchSeedContext:
    def __init__(self, seed):
        self.seed = seed
        self.state = None

    def __enter__(self):
        self.state = torch.random.get_rng_state()
        torch.manual_seed(self.seed)

    def __exit__(self, type, value, traceback):
        torch.random.set_rng_state(self.state)


================================================
FILE: uilib/__init__.py
================================================
VERSION='1.0'

================================================
FILE: uilib/cfg.py
================================================
from pathlib import Path
import sys
import os

def get_executable_path():
    # 这个函数会返回可执行文件所在的目录
    if getattr(sys, 'frozen', False):
        # 如果程序是被“冻结”打包的，使用这个路径
        return Path(sys.executable).parent.as_posix()
    else:
        return Path.cwd().as_posix()

ROOT_DIR=get_executable_path()

MODEL_DIR_PATH=Path(ROOT_DIR+"/asset")
MODEL_DIR_PATH.mkdir(parents=True, exist_ok=True)
MODEL_DIR=MODEL_DIR_PATH.as_posix()

WAVS_DIR_PATH=Path(ROOT_DIR+"/static/wavs")
WAVS_DIR_PATH.mkdir(parents=True, exist_ok=True)
WAVS_DIR=WAVS_DIR_PATH.as_posix()

LOGS_DIR_PATH=Path(ROOT_DIR+"/logs")
LOGS_DIR_PATH.mkdir(parents=True, exist_ok=True)
LOGS_DIR=LOGS_DIR_PATH.as_posix()

SPEAKER_DIR_PATH=Path(ROOT_DIR+"/speaker")
SPEAKER_DIR_PATH.mkdir(parents=True, exist_ok=True)
SPEAKER_DIR=SPEAKER_DIR_PATH.as_posix()

# ffmpeg
if sys.platform == 'win32':
    os.environ['PATH'] = ROOT_DIR + f';{ROOT_DIR}/ffmpeg;' + os.environ['PATH']

else:
    os.environ['PATH'] = ROOT_DIR + f':{ROOT_DIR}/ffmpeg:' + os.environ['PATH']


# 读取 .env 变量
WEB_ADDRESS = os.getenv('WEB_ADDRESS', '127.0.0.1:9966')



================================================
FILE: uilib/utils.py
================================================
import os,sys
import requests
import time
import re
import webbrowser
from pathlib import Path
import pandas as pd
# ref: https://github.com/PaddlePaddle/PaddleSpeech/tree/develop/paddlespeech/t2s/frontend/zh_normalization
from .zh_normalization import TextNormalizer
from .cfg import SPEAKER_DIR
from functools import partial

def openweb(url):
    time.sleep(3)
    try:
        webbrowser.open(url)
    except Exception:
        pass

def get_parameter(request, param, default, cast_type):
    #  先request.args 后request.form 然后转换cast_type=int|float类型。
    for method in [request.args.get, request.form.get]:
        value = method(param, "").strip()
        if value:
            try:
                return cast_type(value)
            except ValueError:
                break  # args转换失败，退出尝试form
    return default  # 失败，返回默认值。


# 数字转为英文读法
def num_to_english(num):

    num_str = str(num)
    # English representations for numbers 0-9
    english_digits = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
    units = ["", "ten", "hundred", "thousand"]
    big_units = ["", "thousand", "million", "billion", "trillion"]
    result = ""
    need_and = False  # Indicates whether 'and' needs to be added
    part = []  # Stores each group of 4 digits
    is_first_part = True  # Indicates if it is the first part for not adding 'and' at the beginning

    # Split the number into 3-digit groups
    while num_str:
        part.append(num_str[-3:])
        num_str = num_str[:-3]

    part.reverse()

    for i, p in enumerate(part):
        p_str = ""
        digit_len = len(p)
        if int(p) == 0 and i < len(part) - 1:
            continue

        hundreds_digit = int(p) // 100 if digit_len == 3 else None
        tens_digit = int(p) % 100 if digit_len >= 2 else int(p[0] if digit_len == 1 else p[1])

        # Process hundreds
        if hundreds_digit is not None and hundreds_digit != 0:
            p_str += english_digits[hundreds_digit] + " hundred"
            if tens_digit != 0:
                p_str += " and "

        # Process tens and ones
        if 10 < tens_digit < 20:  # Teens exception
            teen_map = {
                11: "eleven", 12: "twelve", 13: "thirteen", 14: "fourteen", 15: "fifteen",
                16: "sixteen", 17: "seventeen", 18: "eighteen", 19: "nineteen"
            }
            p_str += teen_map[tens_digit]
        else:
            tens_map = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
            tens_val = tens_digit // 10
            ones_val = tens_digit % 10
            if tens_val >= 2:
                p_str += tens_map[tens_val] + (" " + english_digits[ones_val] if ones_val != 0 else "")
            elif tens_digit != 0 and tens_val < 2:  # When tens_digit is in [1, 9]
                p_str += english_digits[tens_digit]

        if p_str and not is_first_part and need_and:
            result += " and "
        result += p_str
        if i < len(part) - 1 and int(p) != 0:
            result += " " + big_units[len(part) - i - 1] + ", "

        is_first_part = False
        if int(p) != 0:
            need_and = True

    return result.capitalize()


def get_lang(text):
    # 定义中文标点符号的模式
    chinese_punctuation = "[。？！，、；：‘’“”（）《》【】…—\u3000]"
    # 使用正则表达式替换所有中文标点为""
    cleaned_text = re.sub(chinese_punctuation, "", text)
    # 使用正则表达式来匹配中文字符范围
    return "zh" if re.search('[\u4e00-\u9fff]', cleaned_text) is not None else "en"

def fraction_to_words(match):
    numerator, denominator = match.groups()
    # 这里只是把数字直接拼接成了英文分数的形式, 实际上应该使用某种方式将数字转换为英文单词
    # 例如: "1/2" -> "one half", 这里仅为展示目的而直接返回了 "numerator/denominator"
    return numerator + " over " + denominator



# 数字转为英文读法
def num2text(text):
    numtext=[' zero ',' one ',' two ',' three ',' four ',' five ',' six ',' seven ',' eight ',' nine ']
    point=' point '
    text = re.sub(r'(\d)\,(\d)', r'\1\2', text)
    text = re.sub(r'(\d+)\s*\+', r'\1 plus ', text)
    text = re.sub(r'(\d+)\s*\-', r'\1 minus ', text)
    text = re.sub(r'(\d+)\s*[\*x]', r'\1 times ', text)
    text = re.sub(r'((?:\d+\.)?\d+)\s*/\s*(\d+)', fraction_to_words, text)

    # 取出数字 number_list= [('1000200030004000.123', '1000200030004000', '123'), ('23425', '23425', '')]
    number_list=re.findall(r'((\d+)(?:\.(\d+))?%?)', text)
    if len(number_list)>0:
        #dc= ('1000200030004000.123', '1000200030004000', '123','')
        for m,dc in enumerate(number_list):
            if len(dc[1])>16:
                continue
            int_text= num_to_english(dc[1])
            if len(dc)>2 and dc[2]:
                int_text+=point+"".join([numtext[int(i)] for i in dc[2]])
            if dc[0][-1]=='%':
                int_text=f' the pronunciation of  {int_text}'
            text=text.replace(dc[0],int_text)


    return text.replace('1',' one ').replace('2',' two ').replace('3',' three ').replace('4',' four ').replace('5',' five ').replace('6',' six ').replace('7','seven').replace('8',' eight ').replace('9',' nine ').replace('0',' zero ').replace('=',' equals ')



def remove_brackets(text):
    # 正则表达式
    text=re.sub(r'\[(uv_break|laugh|lbreak|break)\]',r' \1 ',text,re.I|re.S|re.M)

    # 使用 re.sub 替换掉 [ ] 对
    newt=re.sub(r'\[|\]|！|：|｛|｝', '', text)
    return    re.sub(r'\s(uv_break|laugh|lbreak|break)(?=\s|$)', r' [\1] ', newt)


# 中英文数字转换为文字，特殊符号处理
def split_text(text_list):
    
    tx = TextNormalizer()
    haserror=False
    result=[]
    for i,text in enumerate(text_list):
        text=remove_brackets(text)
        if get_lang(text)=='zh':
            tmp="".join(tx.normalize(text))
        elif haserror:
            tmp=num2text(text)
        else:
            try:
                # 先尝试使用 nemo_text_processing 处理英文
                from nemo_text_processing.text_normalization.normalize import Normalizer
                fun = partial(Normalizer(input_case='cased', lang="en").normalize, verbose=False, punct_post_process=True)
                tmp=fun(text)
                print(f'使用nemo处理英文ok')
            except Exception as e:
                print(f"nemo处理英文失败，改用自定义预处理")
                print(e)
                haserror=True
                tmp=num2text(text)

        if len(tmp)>200:
            tmp_res=split_text_by_punctuation(tmp)
            result=result+tmp_res
        else:
            result.append(tmp)
    return result

# 切分长行 200 150
def split_text_by_punctuation(text):
    # 定义长度限制
    min_length = 150
    punctuation_marks = "。？！，、；：”’》」』）】…—"
    english_punctuation = ".?!,:;)}…"

    # 结果列表
    result = []
    # 起始位置
    pos = 0

    # 遍历文本中的每个字符
    text_length=len(text)
    for i, char in enumerate(text):
        if char in punctuation_marks or char in english_punctuation:
            if  char=='.' and i< text_length-1 and re.match(r'\d',text[i+1]):
                continue
            # 当遇到标点时，判断当前分段长度是否超过120
            if i - pos > min_length:
                # 如果长度超过120，将当前分段添加到结果列表中
                result.append(text[pos:i+1])
                # 更新起始位置到当前标点的下一个字符
                pos = i+1
    #print(f'{pos=},{len(text)=}')

    # 如果剩余文本长度超过120或没有更多标点符号可以进行分割，将剩余的文本作为一个分段添加到结果列表
    if pos < len(text):
        result.append(text[pos:])

    return result


# 获取../static/wavs目录中的所有文件和目录并清理wav
def ClearWav(directory):
    files = [f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))]

    if not files:
        return False, "wavs目录内无wav文件"

    for filename in os.listdir(directory):
        file_path = os.path.join(directory, filename)
        try:
            if os.path.isfile(file_path) or os.path.islink(file_path):
                os.unlink(file_path)
                print(f"已删除文件: {file_path}")
            elif os.path.isdir(file_path):
                print(f"跳过文件夹: {file_path}")
        except Exception as e:
            print(f"文件删除错误 {file_path}, 报错信息: {e}")
            return False, str(e)
    return True, "所有wav文件已被删除."



# 加载音色
# 参考 https://github.com/craii/ChatTTS_WebUI/blob/main/utils.py
def load_speaker(name):
    speaker_path = f"{SPEAKER_DIR}/{name}.csv" if not name.endswith('.csv') else f"{SPEAKER_DIR}/{name}"
    if not os.path.exists(speaker_path):
        return None
    try:
        import torch
        d_s = pd.read_csv(speaker_path, header=None).iloc[:, 0]
        tensor = torch.tensor(d_s.values)
    except Exception as e:
        print(e)
        return None
    return tensor


# 获取 speaker_dir下的所有csv pt文件
def get_speakers():
    result=[]
    for it in os.listdir(SPEAKER_DIR):
        if it.endswith('.pt'):
            result.append(it)
    return result

# 判断是否可以连接外网
def is_network():
    try:
        import requests
        requests.head('https://baidu.com')
    except Exception:
        return False
    else:
        return True
    return False



def is_chinese_os():
    import subprocess
    try:
        import locale
        # Windows系统
        if sys.platform.startswith('win'):
            lang = locale.getdefaultlocale()[0]
            return lang.startswith('zh_CN') or lang.startswith('zh_TW') or lang.startswith('zh_HK')
        # macOS系统
        elif sys.platform == 'darwin':
            process = subprocess.Popen(['defaults', 'read', '-g', 'AppleLocale'], stdout=subprocess.PIPE)
            output, error = process.communicate()
            if error:
                # 若默认方法出错，则尝试环境变量
                return os.getenv('LANG', '').startswith('zh_')
            locale = output.decode().strip()
            return locale.startswith('zh_')
        # 类Unix系统
        elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
            return os.getenv('LANG', '').startswith('zh_')
        # 其他系统
        else:
            return False

    except Exception as e:
        # 输出异常到控制台，实际应用中应该使用日志记录异常
        print(e)
        return False



def modelscope_status():
    #return False
    try:
        res=requests.head("https://www.modelscope.cn/")
        print(res)
        if res.status_code!=200:
            return False
    except Exception as e:
        return False
    return True


================================================
FILE: uilib/zh_normalization/README.md
================================================
## Supported NSW (Non-Standard-Word) Normalization

|NSW type|raw|normalized|
|:--|:-|:-|
|serial number|电影中梁朝伟扮演的陈永仁的编号27149|电影中梁朝伟扮演的陈永仁的编号二七一四九|
|cardinal|这块黄金重达324.75克<br>我们班的最高总分为583分|这块黄金重达三百二十四点七五克<br>我们班的最高总分为五百八十三分|
|numeric range |12\~23<br>-1.5\~2|十二到二十三<br>负一点五到二|
|date|她出生于86年8月18日，她弟弟出生于1995年3月1日|她出生于八六年八月十八日， 她弟弟出生于一九九五年三月一日|
|time|等会请在12:05请通知我|等会请在十二点零五分请通知我
|temperature|今天的最低气温达到-10°C|今天的最低气温达到零下十度
|fraction|现场有7/12的观众投出了赞成票|现场有十二分之七的观众投出了赞成票|
|percentage|明天有62％的概率降雨|明天有百分之六十二的概率降雨|
|money|随便来几个价格12块5，34.5元，20.1万|随便来几个价格十二块五，三十四点五元，二十点一万|
|telephone|这是固话0421-33441122<br>这是手机+86 18544139121|这是固话零四二一三三四四一一二二<br>这是手机八六一八五四四一三九一二一|
## References
[Pull requests #658 of DeepSpeech](https://github.com/PaddlePaddle/DeepSpeech/pull/658/files)


================================================
FILE: uilib/zh_normalization/__init__.py
================================================
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from .text_normlization import *


================================================
FILE: uilib/zh_normalization/char_convert.py
================================================
# coding=utf-8
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Traditional and simplified Chinese conversion, a simplified character may correspond to multiple traditional characters.
"""
simplified_charcters = '制咖片型超声盘鉴定仔点他命书歌粉巾字帐恤手指记忆棒形转弯沟光○〇㐄㐅㐆㐌㐖毒㐜㐡㐤㐰㐺㑇㑳㒳㒸㔾㗂㗎㝵㞎㞙㞞以㢲㢴㤅㥁㥯㨗㫺㬎㮎㮚㮸㲋㲱㲾㳮涧㵪㶸㷖㷭㹢㹴犬㺢狓㺵碗㽮㿝䍃䔢䖟䖸䗈䗥䗪䝓射䥯䦉䯝鲃鱼䲔䳗鹅䵹鼄䶑一对应映射丁不识下儿子做二休世丘之貉并中台原则串为甚谓干净了百事无成八变五十些人得道鸡升天代如并来去个国政策劲幽灵在欧洲游荡接样萝卜坑侧化传价元论醇共再准刀两断切分耕耘收获钱货物向看旧就绪险刻千金动劳永逸匙零夜半卡通回复返影踪反常态口咬气句话同吐快吹周味呼诺呜品红锅哄而散起唱和问三知生熟团漆黑火糟堆场空块面塌糊涂尘染壁厢夔已足多情露水大早到晚夫妻当关万莫开失古恨套所料既往孔见提师要家主审寸阴难买斗牛小撮部阵局展身层巴掌帆风顺席地带过年计于春头载四季期被蛇怕井绳度愿式份弹顷深前律径心意念差愁孤行俱全房厅交遮打技长把抓死拿眼泪鼻涕钥锁折段抿拍即合扫排掬挥拨拥上入击洞掷揽改故辙败文值名斑方面旁族日秋餐隔雅里终父旦时晌会霎间晃暴寒曝更月望垠际朝夕本正经利杯羹东西板枝独秀根筋杆进条龙服务概模次函数又性程总付步脚印趋登毛拔呵氧氮碳决雌雄波未平派谎言流清楚白准溜烟潭有获闻是处降琴鹤甲病发可拾沙目然了直以相眨穿睹瞥瞬矢的解石鸟神教秉虔诚秘种窝蜂穷窍笑置笔苟勾销抹杀煞等奖箍节吃箭仇双雕诗筹箩筐系列纸级士官统丝毫挂维网尽线微吭响股脑胎脉承腔臂力致效资源址器举功投般说讲规贸易叶障着慎满皆输号木电池衣倾钟高低视仁觉醒览遗角银币触溃九鼎蔽抄出驷马追重语破贫洗贯走路安蹴至几蹶振跃役胆汗较辈轮辞赞退六连遍递边针血锤音错门思闪真倒项栽雾类保护川先惊乍体哄鳞爪鸣滴泡邻域党专鼓作齐炒丑烯亥克内酯冬加奴卯肝炎基尺梁街裤镐客宠庭巳汝昌烷玲磊糖肇酉醛啷青县韪良香骨鲷丂七集河市弦喜嘴张舌堵区工业姊妹星架构巧彩扭歪拼凑余热曜武州爷浮屠美乡老阶树荤素碎落能魄鳃鳗珠丄丅丆万俟丈尚摸母娘量管群亚虎必我堂令申件装伏位博侠义界表女墟台戏臭皮匠胜诸葛亮赛顶倍催请运算包立叉戟离疫苗土史志演围揭瓦晒夷姑婆帝村宝烂尖杉碱屉桌山岔岛由纪峡坝库镇废从德后拗汤治旬食明昧曹朋友框栏极权幂曲归依猫民氟硼氯磷铁江侗自旅法司洋浦梅园温暖湾焦班幸用田略番叠皇炮捶硝苯酸腺苷棱草镜穗跳远索锦纲聚氰胺联店胚膲爱色堇紫罗兰芝茶饭菱云虫藏藩乱叛苏亲债凳学座恐恋柱测肌腹衩锥系貂企乌跪叩军车农题迭都甘油屯奏键短阿姨陪姐只顾茅庐槽驾魂鲜鹿页其菜单乘任供势午齿汉组织吊调泻唇坡城报坟外夸将尉建筑岸岗公床扬新剑升杭林栗校楼标款汽社浣海商馆剧院钢华港机械广媒环球融第医科证券综财乐育游涨犹岭疏瘾睑确兵领导缴肢膛船艾瑟尔苍蔡虞效衫覆访诉课谕议轨述野钩限敌鞋颌颔颚饶首龈站例修凡划垂届属崽颏厨拜挫摆放旋削棋榻槛礼沉注滑营狱画确仪聘花葬诏员跌辖周达酒锚闸陷陆雨雪飞威丌于丹久乏予理评产亢卑亦乎舞己悲矩圆词害志但住佞佳便俗信票案幅翁倦伦假偏倚斜亏鬼敲停备伤脾胃仅此像俭匮免宜穴焉戴兼容许冻伯仲负彼昼皂轩轾实刊划颠卫战哥比省非好黄饰别拘束掩奶睬选择摇扰烦苦枚写协厌及格受欢迎约只估侵犯割状告或缺抗拒挽撤救药喻磨灭端倪少逆逾越避靠适吉誉吝玉含延咎歹听啻渊善谋均匀堪忍够太惹妙妥妨孕症孝术室完纳推冠积宣疑辩栗碴称屈挠屑干涉衡待很忙恶忿怎么怠急耻恭息悦惑惜惟想愉愧怍慌愤启懂懈怀材才紧招认扣抵拉舍也罢插揣冒搭撞南墙扩核支攻敢雷攀敬里吗需景智暇曾罪遇朽枉止况竞争辱求愈渝溶济左右袒困补爽特寂寞示弱找谢畏强疾徐痛痒冤符眠睦瞅董何厚云措活疲羞者轻玻璃祥兆禁移稂莠稳佛换答简结果盟绝缕途给谈否羁翼耐肖胫毋宁兴舒若菲莱痕迹窠臼虚衰脸兔撒鹰棺范该详讳抬泰让须眉象众赀账费灰赖奇虑训辍辨菽麦辛近送透逞徒速续逮捕遂遑违逊斧钺艰醉锈随观弃显饱脂肪使丏丐帮丒且慢末丕替桃宗王尊凉爵各图屋脊粮署录坛吾禄职胄袭君厦丗北壑桐疹损逢陵鹬丙寅戌氨腈唑纶辰酮脱氢酶醚丞丢现掉纱帽弄扯炮碗丠両丣坐存激肩臻蒂莲悖序驱丨丩丫挺杈髻鬟细介俄伊犁京尼布订普渡央委监察检查剂圈设警队斯督剩震境航舶革防托播促质版蝾螈锋研艺历残消频谱精密制造陲邮候埔坚压坜凹汇执府究邦俘摄寮彬狼岳肺肿庸英讯诊埋粒胞括控码韩暑枪枢砥澳哇牟寿甸钻探篇签缀缝继耳肯照妇埃悬璧轴柜台辣搁浅邪跑纤阮阳私囊魔丮丰姿采丱烧丳丵丶丷丸参寨朗桂瑞砂衷霞貌凤仆舰因嫌宰峰干络牌持旨祭祷簿编罚宾办丼丿乀乂乃乄仰慕盛旷留考验阔乆乇么丑麽乊湖燃乑乒乓乕乖僻忤戾离谬迕乗危肥劫除隙浪婿乙炔肠酰吡咯盐乚乛乜嘢卿玄宫尾狐龟塔嶷兄弟泉章霄钉耙乞扎哀怜恕讨乢乣乤乥乧乨乩童乪乫乭乳晕汁液瑶浆牙癌突窦罩腐胶猪酪蛋糕菌瘤乴乵乶乷乸乹乺乼乾俸冰嘉哕嚎坤妈尸垒旱枯涸俐渴潮涩煸豆燥爹瘦瘪癣瞪袋脆姜贝隆馏乿亀亁叫咕攘扔搞男砸窜蓬麻亃亄亅却亇迟典今临繁累卵奉婚聪躬巨与迁添裂副宿岁怪恶尕仑愣杆硅硫钛铀锰芑杂异钠砷胂磺琥珀舱棍簧胡茬盗浩盆贩郎腿亍洪亐互欠助勉惠操斥诿系户译亓墓碑刑铃卅渠缤纷斗米旗宪钒灯徽瘟祖拳福谷丰脏腑绑肉腌苓蕴桥铺霸颜闹判喷冈底蛙陉矿亖亘亜罕们娜桑那努哈喀弗烈曼松森杜氏杯奥琛敦戊穆圣裔汇薛孙亟亡佚虏羊牢奋释卷卸契媾感额睫缠谊趾塞挤纽阻还配驰庄亨洛祚亪享津沪畿郊慈菴枇杷膏亭阁锃丽亳亶亹诛初责翻疯偶杰丛稠妖拖寰居吸授慧蜗吞壮魅狗矛盾益渣患忧稀描猿梦暂涯畜祸缘沸搜引擎臣横纭谁混援蒸兽狮税剖亻亼亽亡什献刹邡么仂仃仄仆富怨仈仉毕昔晨壳绍仍仏仒仕宦仗欺恃腰叹叹炬梓讫施仙后琼逝仚仝仞仟悔仡佬偿填泊拓扑簇羔购顿钦佩发棻阃驭养亿儆尤借帧赈凌叙帖李柔刚沃眦睚戒讹取飨读仨仫仮著泳卧躺韶夏裁仳仵唯贤凭钓诞仿似宋佛讽伀硕盼鹅伄儅伈伉俪柯始娃迈戈坦堡帕茨萨庙玛莉莎藤霍姆伋伍奢胥廷芳豪伎俩侍汛勒希羲雏伐憩整谟闲闲伕伙伴颐伜伝伢叔恒兹恩翰伱伲侣伶俜悧鼬伸懒缩喇叭伹伺伻伽倻辐伾似佃伫布乔妮墨佉卢佌贷劣廉昂档浓矮伞洼缓耗胸谷迷挡率龋宅沫舍疗佐贰佑占优据铧尝呢须鲁晓佗佘余坪寺瓜铳僧蒙芒陀龛哼呕坊奸孽弊揖祟茧缚誓贼佝偻瞀佟你夺赶佡佢佣佤佧贾佪佫佯佰佱洁绩酿肴佴卷佶佷佸佹佺佻佼佽佾具唤窘坏娱怒慨硬习惯聋膨胀蔓骇贵痹侀侁侂侃侄侅鸿燕侇侈糜靡侉侌妾侏儒仓鼠侐侑侔仑侘侚链侜偎傍钴循柳葫芦附価侮骂蔑侯岩截蚀局贴壶嬛宴捷携桶笺酌俣狭膝狄俅俉俊俏俎俑俓俔谚俚俛黎健呈固墒增守康箱湿祐镖镳杠盒靖膜龄俞豹猎噪孚封札筒托衍鸽剪撰稿炼厂禊练缮葺俯瞰撑冲效俳俴俵俶俷俺备俾伥倂倅储卒惶敷猝逃颉蓄崇隐倌倏忽刺蜡烛噍嚼坍扁抽毙葱楣灌灶粪背薮卖赔闭霉腾倓倔幸倘倜傥倝借箸挹浇阅倡狂倢倣値倥偬倨傲倩匡嗣冲柝珍倬倭寇猩倮倶倷倹勤赞偁偃充伪吏嗓寐惺扮拱芫茜藉虢钞偈伟晶偌宕距析滤殿疼瘫注颇偓偕鸭歇滞偝偟偢忘怡旺偨偩逼偫偭偯偰偱偲侦缉蹄偷减惰漏窥窃偸偺迹傀儡傅傈僳骂篱傎奎琳迪叟芭傒傔傕伧悉荒傜傞傢傣芽逼佣婢傮睨寄檄诵谣颂伛担辜弓惨蒿悼疤傺傻屄臆巢泄箧羡盖轧颓傿㑩僄僇佥僊働僎侨僔僖僚僝伪僣僤侥僦猴偾僩僬僭僮僯僰雇僵殖签静僾僿征陇儁侬儃儇侩朴薄儊儋儌儍傧儓俦侪拟尽儜儞儤儦儩汰哉寡渥裕酷儭儱罐儳儵儹傩俨儽兀臬臲鹫允勋勋宙宵帅憝彝谐嫂阋畅沛溢盈饥赫凶悍狠猛顽愚妣斩秦遣鞭耀敏荣槃泽爆碟磁秃缆辉霁卤朵娄孜烽酱勃汀箕裘钳耶蒙蕾彻兑软遭黜兎児韵媳爸兕觥兖兙兛兜售鍪肚兝兞兟兡兢兣樽殓涅睡禀籍赘泌啡肽奸幕涵涝熵疚眷稃衬讧赴焕椒歼植跏没试误猜栖窗肋袖颊兪卦撇胡岐廓轿疸枫茴珑厕秩募勺吨寓斤历亩迫筷厘最淫螺韬兮宽匪筛襄赢轭复兲诈刃堰戎痞蚁饷它冀铸冂冃円冇冉册嫁厉砺竭醮冏牧冑冓冔冕冖冗冘冞冢窄抑诬冥冫烘菇蛰冷凝坨橇淇淋炭饼砖碛窖醋雕雹霜冱冶炉艳嘲峻滩淡漠煖飕饮冼冽凃凄怆梗凅凇净凊凋敝蒙凔凛遵汞脢凞几凢処凰凯凵凶焰凸折刷纹预丧喽奔巡榜殡芙蓉租笼辑鞘萃凼锯镬刁蛮刂娩崩批拆摊掰蘖骤歧颗秒袂赃勿嘱忌磋琢肤刈羽刎讼戮舂桨艇刓刖霹雳刜创犊刡恙墅帜筵致劫劫刨昏默攸尿欲熏润薰圭删刮痧铲刱刲刳刴刵踏磅戳柏槐绣芹苋猬舟铭鹄鹜劫剁剃辫刭锉履铅克剌姻咽哨廊掠桅沿召瞻翅赵卜渺茫郭剒剔剕沥剚愎毅讷才剜剥啄采剞剟剡剣剤䌽剐肾驶黏剰袍剀紊铲剸剺剽剿劁劂札劈啪柴扳啦刘奭姥夼昫涓熙禅禹锡翔雁鹗刽刿弩柄蜻蛉劒劓劖劘劙澜篑赏矶釜晋甜薪逐劦熔纣虐赤囚劬劭労劵效劻劼劾峭艮勅勇励勍勐腊脖庞漫饲荡粥辄勖勗勘骄馁碌泮雇捐竹骑殊阱绩朴恳谨剿勧勩勯勰劢勋勷劝惩慰诫谏勹芡践阑匁庇拯粟扎袱裹饺匆遽匈匉匊匋匍匐茎匏匕妆痰脓蛹斋苑烤蹈塘羌熊阀螳螂疆碚竿纬荷茵邙魏匚匜匝匟扶稷匣匦拢匸匹耦匽匾匿卂叮疮禧轸堤棚迢钧炼卄卆遐卉瓷盲瓶当胱腱裸卋卌卍卐怯污贱鄙龌龊陋卓溪唐梯渔陈枣泥漳浔涧梨芬谯赡辕迦郑単驴弈洽鳌卛占筮卝卞卟吩啉屎翠厄卣卨卪卬卮榫袄玺绶钮蚤惧殆笃耸卲帘帙绕恤卼卽厂厎厓厔厖厗奚厘厍厜厝谅厕厤厥厪腻孢厮厰厳厣厹厺粕垢芜菁厼厾叁悟茸薯叄吵笄悌哺讥坫垄弧芯杠潜婴刍袁诘贪谍煽馈驳収岳缔灾贿骗叚叡吻拦蘑蜜诀燧玩砚筝椎蔺铜逗骊另觅叨唠谒杵姓喊嚷嚣咚咛塑寻恼憎擦只泣渗蝠叱吒咄咤喝籀黛舵舷叵叶铎懿昭穰苴辽叻叼吁堑嫖赌瞧爬众抒吅吆夥卺橡涤抱纵摩郡唁坠扇篮膀袜颈吋忾谘酬哭妓媛暗表缰迩妃羿絮蕃浑拐葵暮隅吔吖啶嗪戚吜啬噬咽吟哦咏吠吧唧嗒咐吪隽咀征燐苞茹钙哧吮吰吱嘎吲哚吴栋娇窟孟箫忠晗淞阖闾趼宇呐睛嘘拂捧疵熄竽笛糠吼吽呀吕韦蒙呃呆笨呇贡呉罄呋喃呎呏呔呠呡痴呣呤呦呧瑛眩扒晬淑姬瑜璇鹃呪呫哔嚅嗫呬呯呰呱呲咧噌钝呴呶呷呸呺呻哱咻啸噜吁坎坷逻呿咁咂咆哮咇咈咋蟹煦珅蔼咍咑咒诅咔哒嚓咾哝哩喱咗咠咡咢咣咥咦咨嗟询咩咪咫啮啮咭咮咱咲咳呛嗽咴啕咸咹咺呙喉咿婉恸悯赋矜绿茗蓝哂抢瞒哆嗦啰噻啾滨彗哋哌哎唷哟哏哐哞哢哤哪里哫啼喘哰哲萎蚌哳咩哽哿呗唅唆唈唉唎唏哗尧棣殇璜睿肃唔睇唕吣唞唣喳唪唬唰喏唲唳唵嘛唶唸唹唻唼唾唿啁啃鹦鹉啅埠栈榷祺铺鞅飙啊啍啎啐啓啕啖啗啜哑祈啢衔啤啥啫啱啲啵啺饥啽噶昆沁喁喂喆裙喈咙喋喌喎喑喒喓喔粗喙幛庆滋鹊喟喣喤喥喦喧骚喨喩梆吃葡萄喭驼挑吓碰枞瓣纯疱藻趟铬喵営喹喺喼喿嗀嗃嗄嗅嗈嗉嗊嗍嗐嗑嗔诟嗕嗖嗙嗛嗜痂癖嗝嗡嗤嗥嗨唢嗬嗯嗰嗲嗵叽嗷嗹嗾嗿嘀嘁嘂嘅惋嘈峪禾荫啀嘌嘏嘐嘒啯啧嘚唛嘞嘟囔嘣嘥嘦嘧嘬嘭这谑严敞馋松哓嘶嗥呒虾嘹嘻啴嘿噀噂噅噇噉噎噏噔噗噘噙噚咝噞噢噤蝉皿噩噫噭嗳噱哙噳嚏涌洒欲巫霏噷噼嚃嚄嚆抖哜尝嚔苏嚚嚜嚞嚟呖嚬嚭嚮嚯亸喾饬按竣苛嚵嘤啭冁呓膪谦囍囒囓囗囘萧酚飘溅谛囝溯眸纥銮鹘囟殉囡団囤囥囧囨囱囫囵囬囮囯囲図囶囷囸囹圄圉拟囻囿圀圂圃圊粹蠹赦圌垦圏滚鲱凿枘圕圛圜圞坯埂壤骸炕祠窑豚绅魠鲮鳖圧握圩圪垯圬圮圯炸岬幔毯祇窨菩溉圳圴圻圾坂坆沾坋坌舛壈昆垫墩椅坒坓坩埚坭坰坱坳坴坵坻坼杨挣涎帘垃垈垌垍垓垔垕垗垚垛垝垣垞垟垤垧垮垵垺垾垿埀畔埄埆埇埈埌殃隍埏埒埕埗埜垭埤埦埧埭埯埰埲埳埴埵埶绋埸培怖桩础辅埼埽堀诃侄庑堃堄摧磐贞韧砌堈堉垩堋堌堍堎垴堙堞堠礁堧堨舆堭堮蜓摘堲堳堽堿塁塄塈煤茔棵塍垲埘塓绸塕鸦沽虱塙冢塝缪塡坞埙塥塩塬塱场螨塼塽塾塿墀墁墈墉墐夯増毁墝墠墦渍钵墫墬堕墰墺墙橱壅壆壊壌壎壒榨蒜壔壕壖圹垆壜壝垅壡壬壭壱売壴壹壻壸寝壿夂夅夆変夊夌漱邑夓腕泄甥御骼夗夘夙衮瑙妊娠醣枭珊莺鹭戗幻魇夤蹀秘擂鸫姚宛闺屿庾挞拇賛蛤裨菠氅漓捞湄蚊霆鲨箐篆篷荆肆舅荔鲆巷惭骰辟邱镕镰阪漂烩鲵鲽鳄鸨胪鹏妒峨谭枰晏玑癸祝秤竺牡籁恢罡蝼蝎赐绒御梭夬夭砣榆怙枕夶夹馅奄崛葩谲奈贺祀赠奌奂奓奕䜣詝奘奜奠奡奣陶奨奁魁奫奬奰娲孩贬隶酥宄狡猾她姹嫣妁毡荼皋膻蝇嫔妄妍嫉媚娆妗趣妚妞妤碍妬娅妯娌妲妳妵妺姁姅姉姗姒姘姙姜姝姞姣姤姧姫姮娥姱姸姺姽婀娀诱慑胁娉婷娑娓娟娣娭娯娵娶娸娼婊婐婕婞婤婥溪孺婧婪婬婹婺婼婽媁媄媊媕媞媟媠媢媬媮妫媲媵媸媺媻媪眯媿嫄嫈袅嫏嫕妪嫘嫚嫜嫠嫡嫦嫩嫪毐嫫嫬嫰妩嫺娴嫽嫿妫嬃嬅嬉耍婵痴艳嬔嬖嬗嫱袅嫒嬢嬷嬦嬬嬭幼嬲嬴婶嬹嬾嬿孀娘孅娈孏曰癫屏孑孓雀孖斟篓谜摺孛矻鸠崮轲祜鸾孥邈毓棠膑孬孭孰孱孳孵泛罔衔孻孪宀宁冗拙株薇掣抚琪瓿榴谧弥宊濂祁瑕宍宏碁宓邸谳実潢町宥宧宨宬徵崎骏掖阙臊煮禽蚕宸豫寀寁寥寃檐庶寎暄碜寔寖寘寙寛寠苫寤肘洱滥蒗陕核寪弘绰螽宝擅疙瘩晷対檐専尃尅赎绌缭畴衅尌峙醌襟痲碧屁昊槌淘恵瀑牝畑莓缸羚觑蔻脏躁尔尓锐尗尙尜尟尢尥尨尪尬尭尰擒尲尶尴尸尹潽蠖蛾尻扣梢蚴鳍脬蹲屇屌蚵屐屃挪屖屘屙屛屝屡屣峦嶂岩舄屧屦屩屪屃屮戍驻钾崖嵛巅旮旯楂榄榉芋茱萸靛麓屴屹屺屼岀岊岌岍阜岑彭巩岒岝岢岚岣岧岨岫岱岵岷峁峇峋峒峓峞峠嵋峨峰峱岘峹峿崀崁崆祯崋崌崃岖昆崒崔嵬巍萤颢崚崞崟崠峥巆崤崦崧殂岽崱崳崴崶崿嵂嵇嵊泗嵌嵎嵒嵓岁嵙嵞嵡嵩嵫嵯嵴嵼嵾嵝崭崭晴嶋嶌嶒嶓嵚崂嶙嶝嶞峤嶡嶢峄嶨嶭嶮嶰嶲岙嵘巂巃巇巉岿巌巓巘巛滇芎巟巠弋回巣巤炊擘蜥蟒蛊觋巰蜀彦淖杏茂甫楞巻巽帼巿帛斐鲫蕊帑帔帗帚琉汶帟帡帣帨裙帯帰帷帹暆帏幄帮幋幌幏帻幙帮幞幠幡幢幦幨幩幪帱幭幯幰遥蹉跎馀庚鉴幵幷稚邃庀庁広庄庈庉笠庋跋庖牺庠庤庥鲸庬庱庳庴庵馨衢庹庿廃厩廆廋廌廎廏廐廑廒荫廖廛厮搏锣廞弛袤廥廧廨廪廱绵踵髓廸迫瓯邺廻廼廾廿躔弁皱弇弌弍弎弐弑吊诡憾荐弝弢弣弤弨弭弮弰弪霖繇焘斌旭溥骞弶弸弼弾彀彄别累纠强彔彖彘彟彟陌彤贻彧绘虹彪炳雕蔚鸥彰瘅彲彳彴仿彷徉徨彸彽踩敛旆徂徇徊渭畲铉裼従筌徘徙徜徕膳苏萌渐徬徭醺徯徳徴潘徻徼忀瘁胖燎怦悸颤扉犀澎湃砰恍惚绞隘忉惮挨饿忐忑忒忖応忝忞耿忡忪忭忮忱忸怩忻悠懑怏遏怔怗怚怛怞怼黍讶怫怭懦怱怲恍怵惕怸怹恁恂恇恉恌恏恒恓恔恘恚恛恝恞恟恠恣恧眄恪恫恬澹恰恿悀悁悃悄悆悊悐悒晦悚悛悜悝悤您悩悪悮悰悱凄恻德悴怅惘闷悻悾惄愫钟蒐惆惇惌惎惏惓惔惙惛耄惝疟浊恿惦德恽惴蠢惸拈愀愃愆愈愊愍愐愑愒愓愔愕恪氓蠢騃昵惬赧悫愬愮愯恺愼慁恿慅慆慇霭慉慊愠慝慥怄怂慬慱悭慴慵慷戚焚憀灼郁憃惫憋憍眺捏轼愦憔憖憙憧憬憨憪憭怃憯憷憸憹憺懃懅懆邀懊懋怿懔懐懞懠懤懥恹懫懮懰懱毖懵遁梁雍忏懽戁戄戆戉戋戕戛戝戛戠戡戢戣戤戥戦戬戭戯轰戱披菊牖戸戹戺戻卯戽锹扂楔扃扆扈扊杖牵绢铐镯赉扐搂搅烊盹瞌跟趸镲靶鼾払扗玫腮扛扞扠扡扢盔押扤扦扱罾揄绥鞍郤窾扻扼扽抃抆抈抉抌抏瞎抔缳缢擞抜拗択抨摔歉蹿牾抶抻搐泵菸拃拄拊髀抛拌脯拎拏拑擢秧沓曳挛迂拚拝拠拡拫拭拮踢拴拶拷攒拽掇芥橐簪摹疔挈瓢骥捺蹻挌挍挎挐拣挓挖掘浚挙揍聩挲挶挟挿捂捃捄捅捆捉捋胳膊揎捌捍捎躯蛛捗捘捙捜捥捩扪捭据捱捻捼捽掀掂抡臀膘掊掎掏掐笙掔掗掞棉芍掤搪阐掫掮掯揉掱掲掽掾揃揅揆搓揌诨揕揗揘揜揝揞揠揥揩揪揫橥遒麈揰揲揵揶揸背揺搆搉搊搋搌搎搔搕撼橹捣搘搠搡搢搣搤搥搦搧搨搬楦裢讪赸掏搰搲搳搴揾搷搽搾搿摀摁摂摃摎掴摒摓跤摙摛掼摞摠摦喉羯摭摮挚摰摲抠摴抟摷掺摽撂撃撅稻撊撋挦锏泼撕撙撚㧑挢撢掸撦撅撩撬撱朔揿蚍蜉挝捡擀掳闯擉缶觚擐擕擖擗擡擣擤澡腚擧擨擩擫擭摈拧撷擸撸擽擿攃摅撵攉攥攐攓撄搀撺每攩攫辔澄攮攰攲攴轶攷砭讦攽碘敁敃敇敉叙敎筏敔敕敖闰诲敜煌敧敪敳敹敺敻敿斁衽斄牒绉诌斉斎斓鹑谰驳鳢斒筲斛斝斞斠斡斢斨斫斮晾沂潟颖绛邵斲斸釳於琅斾斿旀旗旃旄涡旌旎旐旒旓旖旛旝旟旡旣浴旰獭魃旴时旻旼旽昀昃昄昇昉晰躲澈熹皎皓矾昑昕昜昝昞昡昤晖笋昦昨是昱昳昴昶昺昻晁蹇隧蔬髦晄晅晒晛晜晞晟晡晢晤晥曦晩萘莹顗晿暁暋暌暍暐暔暕煅旸暝暠暡曚暦暨暪朦胧昵暲殄冯暵暸暹暻暾曀晔昙曈曌曏曐暧曘曙曛叠昽曩骆曱甴肱曷牍禺锟曽沧耽朁朅朆杪栓夸竟粘绦朊膺朏朐朓朕朘朙瞄觐溘饔飧朠朢朣栅椆淀虱朩朮朰朱炆璋钰炽鹮朳槿朵朾朿杅杇杌陧欣钊湛漼楷瀍煜玟缨翱肇舜贽适逵杓杕杗杙荀蘅杝杞脩珓筊杰榔狍閦颦缅莞杲杳眇杴杶杸杻杼枋枌枒枓衾葄翘纾逋枙狸桠枟槁枲枳枴枵枷枸橼枹枻柁柂柃柅柈柊柎某柑橘柒柘柙柚柜柞栎柟柢柣柤柩柬柮柰柲橙柶柷柸柺査柿栃栄栒栔栘栝栟柏栩栫栭栱栲栳栴檀栵栻桀骜桁镁桄桉桋桎梏椹葚桓桔桕桜桟桫椤桭杯桯桲桴桷桹湘溟梃梊梍梐潼栀枧梜梠梡梣梧梩梱梲梳梴梵梹棁棃樱棐棑棕榈簑绷蓑枨棘棜棨棩棪棫棬棯棰棱棳棸棹椁棼碗椄苕椈椊椋椌椐椑椓椗検椤椪椰椳椴椵椷椸椽椿楀匾楅篪楋楍楎楗楘楙楛楝楟楠楢楥桢楩楪楫楬楮楯楰梅楸楹楻楽榀榃榊榎槺榕榖榘榛狉莽搒笞榠榡榤榥榦榧杩榭榰榱梿霰榼榾桤槊闩槎槑槔槖様槜槢槥椠槪槭椮槱槲槻槼槾樆樊樏樑樕樗樘樛樟樠樧樨権樲樴樵猢狲桦樻罍樾樿橁橄橆桡笥龠橕橚橛辆椭橤橧竖膈跨橾橿檩檃檇柽檍檎檑檖檗桧槚檠樯檨檫檬梼槟檴檵柠棹櫆櫌栉櫜椟櫡槠栌枥榇栊櫹棂茄櫽欀欂欃欐欑栾欙棂溴欨欬欱欵欶欷歔欸欹欻欼欿歁歃歆艎歈歊莳蝶歓歕歘歙歛歜欤歠蹦诠镶蹒跚升陟歩歮歯歰歳歴璞歺瞑歾殁夭殈殍殑殗殜殙殛殒殢殣殥殪殚僵殰殳荃殷殸殹蛟殻肴谤殴毈毉喂毎毑蕈毗毘毚茛邓毧毬毳毷毹毽毾毵牦氄氆靴氉氊氇氍氐聊氕氖気氘氙氚氛氜氝氡汹焊痉氤氲氥氦铝锌氪烃氩铵痤汪浒漉痘盂碾菖蒲蕹蛭螅氵冰氹氺氽烫氾氿渚汆汊汋汍汎汏汐汔汕褟汙汚汜蓠沼秽蔑汧汨汩汭汲汳汴堤汾沄沅沆瀣沇沈葆浸沦湎溺痼疴沌沍沏沐沔沕沘浜畹砾沚沢沬沭沮沰沱灢沴沷籽沺烹濡洄泂肛泅泆涌肓泐泑泒泓泔泖泙泚泜泝泠漩馍涛粼泞藓鳅泩泫泭泯铢泱泲洇洊泾琵琶荽蓟箔洌洎洏洑潄濯洙洚洟洢洣洧洨洩痢滔洫洮洳洴洵洸洹洺洼洿淌蜚浄浉浙赣渫浠浡浤浥淼瀚浬浭翩萍浯浰蜃淀苔蛞蝓蜇螵蛸煲鲤浃浼浽溦涂涊涐涑涒涔滂莅涘涙涪涫涬涮涴涶涷涿淄淅淆淊凄黯淓淙涟淜淝淟淠淢淤渌淦淩猥藿亵淬淮淯淰淳诣涞纺淸淹炖癯绮渇済渉渋渓渕涣渟渢滓渤澥渧渨渮渰渲渶渼湅湉湋湍湑湓湔黔湜湝浈湟湢湣湩湫湮麟湱湲湴涅満沩溍溎溏溛舐漭溠溤溧驯溮溱溲溳溵溷溻溼溽溾滁滃滉滊荥滏稽滕滘汇滝滫滮羼耷卤滹浐煎漈漊漎绎漕漖漘漙沤漜漪漾漥漦漯漰溆漶漷濞潀颍潎潏潕潗潚潝潞潠潦祉疡潲潵滗潸潺潾涠澁澂澃澉澌澍澐澒澔澙渑澣澦澧澨澫澬浍澰澴澶澼熏郁濆濇濈濉濊貊濔疣濜濠濩觞浚濮盥潍濲泺瀁滢渎渖瀌浏瀒瀔濒泸瀛潇潆瀡潴泷濑瀬弥潋瀳瀵瀹瀺瀼沣滠灉灋灒漓灖灏灞灠滦灥灨滟灪蜴灮烬獴灴灸灺炁炅鱿炗炘炙炤炫疽烙钎炯炰炱炲炴炷毁炻烀烋瘴鲳烓烔焙烜烝烳饪烺焃焄耆焌焐焓焗焜焞焠焢焮焯焱焼煁煃煆煇煊熠煍熬煐炜煕暖熏硷霾煚煝煟煠茕矸煨琐炀萁煳煺煻熀熅熇熉罴荧穹炝熘熛熜稔谙烁熤熨熯熰眶蚂颎熳熸熿燀烨燂燄盏燊燋燏燔隼燖焖燠燡灿燨燮燹燻燽燿爇爊爓爚爝爟爨蟾爯爰为爻丬爿牀牁牂牄牋窗牏牓窗釉牚腩蒡虻牠虽蛎牣牤牮牯牲牳牴牷牸牼绊牿靬犂犄犆犇犉犍犎犒荦犗犛犟犠犨犩犪犮犰狳犴犵犺狁甩狃狆狎狒獾狘狙黠狨狩狫狴狷狺狻豕狈蜘猁猇猈猊猋猓猖獗猗猘狰狞犸猞猟獕猭猱猲猳猷猸猹猺玃獀獃獉獍獏獐獒毙獙獚獜獝獞獠獢獣獧鼇蹊狯猃獬豸狝獯鬻獳犷猕猡玁菟玅玆玈珉糁禛郅玍玎玓瓅玔玕玖玗玘玞玠玡玢玤玥玦珏瑰玭玳瑁玶玷玹玼珂珇珈瑚珌馐馔珔珖珙珛珞珡珣珥珧珩珪佩珶珷珺珽琀琁陨玡琇琖琚琠琤琦琨琫琬琭琮琯琰琱琲琅琴珐珲瑀瑂瑄瑉玮瑑瑔瑗瑢瑭瑱瑲瑳瑽瑾瑿璀璨璁璅璆璈琏璊璐璘璚璝璟璠璡璥瑷璩璪璫璯璲玙璸璺璿瓀璎瓖瓘瓒瓛脐瓞瓠瓤瓧瓩瓮瓰瓱瓴瓸瓻瓼甀甁甃甄甇甋甍甎甏甑甒甓甔瓮甖甗饴蔗甙诧钜粱盎锈团甡褥産甪甬甭甮宁铠甹甽甾甿畀畁畇畈畊畋畎畓畚畛畟鄂畤畦畧荻畯畳畵畷畸畽畾疃叠疋疍疎箪疐疒疕疘疝疢疥疧疳疶疿痁痄痊痌痍痏痐痒痔痗瘢痚痠痡痣痦痩痭痯痱痳痵痻痿瘀痖瘃瘈瘉瘊瘌瘏瘐痪瘕瘖瘙瘚瘛疭瘜瘝瘗瘠瘥瘨瘭瘆瘯瘰疬瘳疠瘵瘸瘺瘘瘼癃痨痫癈癎癐癔癙癜癠疖症癞蟆癪瘿痈発踔绀蔫酵皙砬砒翎翳蔹钨镴皑鹎驹暨粤褶皀皁荚皃镈皈皌皋皒朱皕皖皘皜皝皞皤皦皨皪皫皭糙绽皴皲皻皽盅盋碗盍盚盝踞盦盩秋千盬盭眦睁瞤盯盱眙裰盵盻睐眂眅眈眊県眑眕眚眛眞眢眣眭眳眴眵眹瞓眽郛睃睅睆睊睍睎困睒睖睙睟睠睢睥睪睾睯睽睾眯瞈瞋瞍逛瞏瞕瞖眍䁖瞟瞠瞢瞫瞭瞳瞵瞷瞹瞽阇瞿眬矉矍铄矔矗矙瞩矞矟矠矣矧矬矫矰矱硪碇磙罅舫阡、矼矽礓砃砅砆砉砍砑砕砝砟砠砢砦砧砩砫砮砳艏砵砹砼硇硌硍硎硏硐硒硜硖砗磲茚钡硭硻硾碃碉碏碣碓碔碞碡碪碫碬砀碯碲砜碻礴磈磉磎硙磔磕磖磛磟磠磡磤磥蹭磪磬磴磵磹磻硗礀硚礅礌礐礚礜礞礤礧礮砻礲礵礽礿祂祄祅祆禳祊祍祏祓祔祕祗祘祛祧祫祲祻祼饵脔锢禂禇禋祦禔祎隋禖禘禚禜禝禠祃禢禤禥禨禫祢禴禸秆秈秊闱飒秋秏秕笈蘵赁秠秣秪秫秬秭秷秸稊稌稍稑稗稙稛稞稬秸稲稹稼颡稿穂穄穇穈穉穋稣贮穏穜穟秾穑穣穤穧穨穭穮穵穸窿阒窀窂窅窆窈窕窊窋窌窒窗窔窞窣窬黩蹙窑窳窴窵窭窸窗竁竃竈竑竜并竦竖篦篾笆鲛竾笉笊笎笏笐靥笓笤箓笪笫笭笮笰笱笲笳笵笸笻筀筅筇筈筎筑筘筠筤筥筦笕筒筭箸筰筱筳筴宴筸箂个箊箎箑箒箘箙箛箜篌箝箠箬镞箯箴箾篁筼筜篘篙篚篛篜篝篟篠篡篢篥篧篨篭篰篲筚篴篶篹篼箦簁簃簆簉簋簌簏簜簟簠簥簦簨簬簰簸簻籊藤籒籓籔签籚篯箨籣籥籧笾簖籫籯芾麴籵籸籹籼粁秕粋粑粔粝粛粞粢粧粨粲粳稗粻粽辟粿糅糆糈糌糍糒糔萼糗蛆蹋糢糨糬粽糯糱籴粜糸糺紃蹼鲣霉纡纨绔纫闽襻紑纰纮锭鸢鹞纴紞紟扎紩紬绂绁纻紽紾绐絁絃絅経絍绗絏缡褵絓絖絘絜绚絣螯絪絫聒絰絵绝絺絻絿綀绡綅绠绨绣綌綍綎捆綖綘継続缎绻綦綪线綮綯绾罟蝽綷縩绺绫緁绲緅緆缁绯緌緎総緑绱緖缃缄缂绵缗緤褓缌纂緪緰缑缈缏缇縁縃縄萦缙缒縏缣縕缞縚缜缟缛縠縡縢縦绦縯縰骋缧縳纤缦絷缥縻衙縿繄缫繈繊繋繐缯繖繘繙繠缋繣繨缰缲繸繻缱纁纆纇缬缵纩纑纕缵纙纚纛缾罃罆坛罋罂罎罏罖罘罛罝罠罣罥罦罨罫罭锾罳罶罹罻罽罿羂羃羇芈蕉５１鸵羑羖羌羜羝羢羣羟羧羭羮羰羱羵羶羸藜鲐翀翃翅翊翌翏翕翛翟翡翣翥翦跹翪翫翚翮翯翱翽翾翿板饕鸹锨耋耇耎耏专耒耜耔耞耡耤耨耩耪耧耰鬓耵聍聃聆聎聝聡聦聱聴聂聼阈聿肄肏肐肕腋肙肜肟肧胛肫肬肭肰肴肵肸肼胊胍胏胑胔胗胙胝胠铨胤胦胩胬胭胯胰胲胴胹胻胼胾脇脘脝脞脡脣脤脥脧脰脲脳腆腊腌臜腍腒腓胨腜腠脶腥腧腬腯踝蹬镣腴腶蠕诽膂腽嗉膇膋膔腘膗膙膟黐膣膦膫膰膴膵膷脍臃臄臇臈臌臐臑臓膘臖臙臛臝臞臧蓐诩臽臾臿舀舁鳑鲏舋舎舔舗馆舝舠舡舢舨舭舲舳舴舸舺艁艄艅艉艋艑艕艖艗艘艚艜艟艣舣艨艩舻艬艭荏艴艳艸艹艻艿芃芄芊萰陂藭芏芔芘芚蕙芟芣芤茉芧芨芩芪芮芰鲢芴芷芸荛豢芼芿苄苒苘苙苜蓿苠苡苣荬苤苎苪镑苶苹苺苻苾茀茁范蠡萣茆茇茈茌茍茖茞茠茢茥茦菰茭茯茳藨茷藘茼荁荄荅荇荈菅蜢鸮荍荑荘豆荵荸荠莆莒莔莕莘莙莚莛莜莝莦莨菪莩莪莭莰莿菀菆菉菎菏菐菑菓菔芲菘菝菡菢菣菥蓂菧菫毂蓥菶菷菹醢菺菻菼菾萅萆苌萋萏萐萑萜萩萱萴莴扁萻葇葍葎葑荭葖葙葠葥苇葧葭药葳葴葶葸葹葽蒄蒎莼茏薹莅蒟蒻蒢蒦蒨蒭藁蒯蒱鉾蒴蒹蒺蒽荪蓁蓆蓇蓊蓌蓍蓏蓓蓖蓧蓪蓫荜跣藕苁蓰蓱莼蓷蓺蓼蔀蔂蔃蔆蔇蔉蔊蔋蔌蔎蔕蔘蔙蒌蔟锷蒋雯茑蔯蔳麻蔵蔸蔾荨蒇蕋蕍荞蕐蕑芸莸蕖蕗蕝蕞蕠蕡蒉蕣蕤蕨蕳蓣蕸蕺蕻薀薁薃薅薆荟薉芗薏薐蔷薖薘剃谔钗薜薠薢薤薧薨薫薬薳薶薷薸薽薾薿藄藇藋荩藐藙藚藟藦藳藴苈藷藾蘀蘁蕲苹蘗蘘蘝蘤蘧蘩蘸蘼虀虆虍蟠虒虓虖虡虣虥虩虬虰蛵蛇虷鳟虺虼蚆蚈蚋蚓蚔蚖蚘蚜蚡蚣蚧蚨蚩蚪蚯蚰蜒蚱蚳蚶蚹蚺蚻蚿蛀蛁蛄蛅蝮蛌蛍蛐蟮蛑蛓蛔蛘蛚蛜蛡蛣蜊蛩蛱蜕螫蜅蚬蜈蝣蜋蜍蜎蜑蠊蜛饯蜞蜣蜨蜩蜮蜱蜷蜺蜾蜿蝀蝃蝋蝌蝍蝎蝏蝗蝘蝙蝝鲼蝡蝤蝥猿蝰虻蝲蝴蝻螃蠏蛳螉螋螒螓螗螘螙螚蟥螟螣螥螬螭䗖螾螀蟀蟅蝈蟊蟋蟑蟓蟛蟜蟟蟢虮蟨蟪蟭蛲蟳蛏蟷蟺蟿蠁蠂蠃虿蠋蛴蠓蚝蠗蠙蠚蠛蠜蠧蟏蠩蜂蠮蠰蠲蠵蠸蠼蠽衁衄衄衇衈衉衋衎衒同衖胡衞裳钩衭衲衵衹衺衿袈裟袗袚袟袢袪袮袲袴袷袺袼褙袽裀裉袅裋夹裍裎裒裛裯裱裲裴裾褀褂褉褊裈褎褐褒褓褔褕袆褚褡褢褦褧褪褫袅褯褰褱裆褛褽褾襁褒襆裥襉襋襌襏襚襛襜裣襞襡襢褴襦襫襬襭襮襕襶襼襽襾覂覃覅霸覉覊覌覗觇覚覜觍觎覧覩觊觏覰観觌觔觕觖觜觽觝觡酲觩觫觭觱觳觯觷觼觾觿言赅讣訇訏訑訒诂讬訧訬訳訹证訾詀詅诋毁詈詊讵詑诒诐詗诎察詨诜詶詸詹詻诙诖誂誃诔锄诓誋诳诶悖誙诮诰誧説読誯谇訚谄谆諆諌诤诹诼諕谂谀諝谝諟喧谥諴諵谌谖誊謆謇歌謍謏謑谡谥謡謦謪谪讴謷謼谩哗譅譆譈譊讹譒撰谮鑫譞噪譩谵譬譱譲谴譸譹谫讅讆詟䜩雠讐谗谶讙谠讟谽豁豉豇岂豊豋豌豏豔豞豖豗豜豝豣豦豨豭豱豳豵豶豷豺豻貅貆狸猊貔貘䝙貜貤餍贳餸贶贲赂賏赊赇赒賝赓赕賨赍斗賮賵賸赚赙赜赟贉赆赑贕赝赬赭赱赳迄趁趂趄趐趑趒趔趡趦趫趮趯趱趴趵趷趹趺趿跁跂跅跆踬跄跐跕跖跗跙跛跦跧跩跫跬跮跱跲跴跺跼跽踅踆踈踉踊踒踖踘踜踟躇蹰踠踡踣踤踥踦踧跷踫踮逾踱踊踶踹踺踼踽躞蹁蹂躏蹎蹐蹓蹔跸蹚蹜蹝迹蹠蹡蹢跶蹧蹩蹪蹯鞠蹽躃躄躅踌跻躐踯跞躘躙躗躝躠蹑躜躧躩躭躰躬躶軃軆辊軏轫軘軜軝腭転軥軨軭軱轱辘軷轵轺軽軿輀輂辇辂辁輈挽輗辄辎辋輠輤輬輭輮辏輴輵輶輹輼辗辒轇轏轑轒辚轕轖轗轘轙轝轞轹轳罪辣辞辵辶辺込辿迅迋迍麿迓迣迤逦迥迨迮迸迺迻迿逄逅逌逍逑逓迳逖逡逭逯逴逶逹遄遅侦遘遛遝遢遨遫遯遰遴绕遹遻邂邅邉邋邎邕邗邘邛邠邢邧邨邯郸邰邲邳邴邶邷邽邾邿郃郄郇郈郔郕郗郙郚郜郝郞郏郠郢郪郫郯郰郲郳郴郷郹郾郿鄀鄄郓鄇鄈鄋鄍鄎鄏鄐鄑邹邬鄕郧鄗鄘鄚鄜鄞鄠鄢鄣鄤鄦鄩鄫鄬鄮鄯鄱郐鄷鄹邝鄻鄾鄿酃酅酆酇郦酊酋酎酏酐酣酔酕醄酖酗酞酡酢酤酩酴酹酺醁醅醆醊醍醐醑醓醖醝酝醡醤醨醪醭醯醰酦醲醴醵醸醹醼醽醾釂酾酽釆釈鲈镏阊钆钇钌钯钋鼢鼹钐钏釪釬釭釱钍釸钕钫鈃钭鈆鈇钚鈊鈌钤钣鈒鈤钬钪鈬铌铈钶铛钹铍钸钿鉄鉆铊铇鉌铋鉏铂钷铆钵鉥钲鉨钼钽鉱鉲鉶铰铒鉼铪銍銎铣銕镂铫铦铑铷銤铱铟銧铥铕铯銭銰焊銶锑锉汞鋂锒鋆鋈鋊铤鋍铗鋐鋑鋕鋘鋙锊锓锔锇铓鋭铖锆锂铽鋳鋹鋺鉴镚钎錀锞锖锫锩錍铔锕錔锱铮锛錞锬锜錤錩錬録铼錼锝钔锴鍉镀鍏鍐铡鍚锻锽锸锲锘鍫鍭鍱鍴锶鍹锗针锺锿镅鎉鎋鎌鎍鎏鎒鎓鎗镉鎚鎞镃鎤铩锼鎭鎯镒镍鎴镓鎸鎹镎镟鏊镆镠镝鏖铿锵鏚镗镘镛鏠鏦錾镤鏸镪鏻鏽鏾铙鐄鐇鐏铹镦镡鐗馗镫镢镨鐡锎镄鐩镌鐬鐱镭鐶鐻鐽镱鑀鑅镔鑐鑕鑚鑛鑢鑤镥鑪镧鑯鑱鑴鑵镊镢钃镻闫闬闶闳閒闵閗閟阂関合閤哄阆閲阉閺阎阏阍阌暗闉阕阗闑闒闿闘闚阚闟闠闤闼阞阢阤阨阬阯阹阼阽陁陑陔陛陜陡陥陬骘陴険陼陾阴隃隈隒隗隞隠隣隤隩隮隰颧隳隷隹雂雈雉雊雎雑雒雗雘雚雝雟雩雰雱驿霂霅霈霊沾霒霓霙霝霢霣霤霨霩霪霫霮靁叇叆靑靓靣腼靪靮靰靳靷靸靺靼靿鞀鞃鞄鞍鞗鞙鞚鞝鞞鞡鞣鞨鞫鞬鞮鞶鞹鞾鞑韅鞯驮韍韎韔韖韘韝韫韡韣韭韭韱韹韺頀刮頄顸顼頍颀颃颁頖頞頠頫頬颅頯頲颕頼悴顋顑颙颛颜顕顚顜颟顣颥颞飐飑台飓颸飏飖颽颾颿飀飂飚飌翻飡飣饲飥饨饫飮飧飶餀餂饸饹餇餈饽哺馂餖餗餚馄馃餟餠餤餧餩餪餫糊餮糇餲饧馎糕饩馈馊馌馒饇馑馓膳饎饐饘饟馕馘馥馝馡馣骝骡馵馹駃駄駅駆駉駋驽駓驵駗骀驸駜骂骈駪駬骃駴骎駹駽駾騂騄骓騆騉騋骒骐麟騑騒験騕骛騠騢騣騤騧骧騵驺骟騺蓦骖骠骢驆驈骅驌骁驎骣驒驔驖驙驦驩驫骺鲠骫骭肮骱骴骶骷髅骾髁髂髄髆膀髇髑髌髋髙髝髞髟髡髣髧髪髫髭髯髲髳髹髺髽髾鬁鬃鬅鬈鬋鬎鬏鬐鬑鬒鬖鬗鬘鬙鬠鬣斗鬫鬬阄鬯鬰鬲鬵鬷魆魈魊魋魍魉魑魖鳔魛魟魣魦魨魬鲂魵魸鮀鲅鮆鲧鲇鲍鲋鮓鲒鲕鮟鱇鮠鮦鮨鲔鲑鮶鮸鮿鲧鯄鯆鲩鯈鲻鯕鲭鲞鯙鯠鲲鯥鲰鲶鳀鯸鳊鲗䲠鹣鳇鰋鳄鳆鰕鰛鰜鲥鰤鳏鰦鳎鳐鳁鳓鰶鲦鲡鰼鰽鱀鱄鳙鱆鳕鱎鱐鳝鳝鳜鲟鲎鱠鳣鱨鲚鱮鱲鱵鱻鲅鳦凫鳯鳲鳷鳻鴂鴃鴄鸩鴈鴎鸰鴔鴗鸳鸯鸲鹆鸱鴠鴢鸪鴥鸸鹋鴳鸻鴷鴽鵀鵁鸺鹁鵖鵙鹈鹕鹅鵟鵩鹌鵫鵵鵷鵻鹍鶂鶊鶏鶒鹙鶗鶡鶤鶦鶬鶱鹟鶵鶸鶹鹡鶿鹚鷁鷃鷄鷇䴘䴘鷊鷏鹧鷕鹥鸷鷞鷟鸶鹪鹩鷩鷫鷭鹇鹇鸴鷾䴙鸂鸇䴙鸏鸑鸒鸓鸬鹳鸜鹂鹸咸鹾麀麂麃麄麇麋麌麐麑麒麚麛麝麤麸面麫麮麯麰麺麾黁黈黉黢黒黓黕黙黝黟黥黦黧黮黰黱黪黶黹黻黼黾鼋鼂鼃鼅鼈鼍鼏鼐鼒冬鼖鼙鼚鼛鼡鼩鼱鼪鼫鼯鼷鼽齁齆齇齈齉齌赍齑龀齕齗龅齚龇齞龃龉龆齢出齧齩齮齯齰齱齵齾厐龑龒龚龖龘龝龡龢龤'

traditional_characters = '制咖片型超聲盤鑒定仔點他命書歌粉巾字帳恤手指記憶棒形轉彎溝光○〇㐄㐅㐆㐌㐖毒㐜㐡㐤㐰㐺㑇㑳㒳㒸㔾㗂㗎㝵㞎㞙㞞㠯㢲㢴㤅㥁㥯㨗㫺㬎㮎㮚㮸㲋㲱㲾㳮㵎㵪㶸㷖㷭㹢㹴犬㺢狓㺵㼝㽮㿝䍃䔢䖟䖸䗈䗥䗪䝓䠶䥯䦉䯝䰾魚䲔䳗䳘䵹鼄䶑一對應映射丁不識下兒子做二休世丘之貉並中台原則串為甚謂乾淨了百事無成八變五十些人得道雞升天代如併來去個國政策勁幽靈在歐洲遊蕩接樣蘿蔔坑側化傳價元論醇共再准刀兩斷切分耕耘收穫錢貨物向看舊就緒險刻千金動勞永逸匙零夜半卡通回復返影蹤反常態口咬氣句話同吐快吹周味呼諾嗚品紅鍋哄而散起唱和問三知生熟團漆黑火糟堆場空塊麵塌糊塗塵染壁廂夔已足多情露水大早到晚夫妻當關萬莫開失古恨套所料既往孔見提師要家主審寸陰難買鬥牛小撮部陣局展身層巴掌帆風順席地帶過年計於春頭載四季期被蛇怕井繩度願式份彈頃深前律徑心意念差愁孤行俱全房廳交遮打技長把抓死拿眼淚鼻涕鑰鎖折段抿拍即合掃排掬揮撥擁上入擊洞擲攬改故轍敗文值名斑方面旁族日秋餐隔雅里終父旦時晌會霎間晃暴寒曝更月望垠際朝夕本正經利杯羹東西板枝獨秀根筋桿進條龍服務概模次函數又性程總付步腳印趨登毛拔呵氧氮碳決雌雄波未平派謊言流清楚白準溜煙潭有獲聞是處降琴鶴甲病發可拾沙目然瞭直以相眨穿睹瞥瞬矢的解石鳥神教秉虔誠秘種窩蜂窮竅笑置筆苟勾銷抹殺煞等獎箍節吃箭仇雙鵰詩籌籮筐系列紙級士官統絲毫掛維網盡線微吭響股腦胎脈承腔臂力致效資源址器舉功投般說講規貿易葉障著慎滿皆輸號木電池衣傾鐘高低視仁覺醒覽遺角銀幣觸潰九鼎蔽抄出駟馬追重語破貧洗貫走路安蹴至幾蹶振躍役膽汗較輩輪辭贊退六連遍遞邊針血錘音錯門思閃真倒項栽霧類保護川先驚乍體鬨鱗爪鳴滴泡鄰域黨專鼓作齊炒丑烯亥克內酯冬加奴卯肝炎基尺梁街褲鎬客寵庭巳汝昌烷玲磊糖肇酉醛啷青縣韙良香骨鯛丂七集河市弦喜嘴張舌堵區工業姊妹星架構巧彩扭歪拼湊餘熱曜武州爺浮屠美鄉老階樹葷素碎落能魄鰓鰻珠丄丅丆万俟丈尚摸母娘量管群亞虎必我堂令申件裝伏位博俠義界表女墟臺戲臭皮匠勝諸葛亮賽頂倍催請運算包立叉戟離疫苗土史志演圍揭瓦曬夷姑婆帝村寶爛尖杉鹼屜桌山岔島由紀峽壩庫鎮廢從德後拗湯治旬食明昧曹朋友框欄極權冪曲歸依貓民氟硼氯磷鐵江侗自旅法司洋浦梅園溫暖灣焦班幸用田略番疊皇炮捶硝苯酸腺苷稜草鏡穗跳遠索錦綱聚氰胺聯店胚膲愛色堇紫羅蘭芝茶飯菱雲蟲藏藩亂叛蘇親債凳學座恐戀柱測肌腹衩錐係貂企烏跪叩軍車農題迭都甘油屯奏鍵短阿姨陪姐隻顧茅廬槽駕魂鮮鹿頁其菜單乘任供勢午齒漢組織吊調瀉唇坡城報墳外夸將尉建築岸崗公床揚新劍昇杭林栗校樓標款汽社浣海商館劇院鋼華港機械廣媒環球融第醫科證券綜財樂育游漲猶嶺疏癮瞼確兵領導繳肢膛船艾瑟爾蒼蔡虞傚衫覆訪訴課諭議軌述野鉤限敵鞋頜頷顎饒首齦站例修凡劃垂屆屬崽頦廚拜挫擺放旋削棋榻檻禮沉注滑營獄畫确儀聘花葬詔員跌轄週達酒錨閘陷陸雨雪飛威丌于丹久乏予理評產亢卑亦乎舞己悲矩圓詞害誌但住佞佳便俗信票案幅翁倦倫假偏倚斜虧鬼敲停備傷脾胃僅此像儉匱免宜穴焉戴兼容許凍伯仲負彼晝皂軒輊實刊划顛衛戰哥比省非好黃飾別拘束掩奶睬選擇搖擾煩苦枚寫協厭及格受歡迎約只估侵犯割狀告或缺抗拒挽撤救藥喻磨滅端倪少逆逾越避靠適吉譽吝玉含延咎歹聽啻淵善謀均勻堪忍夠太惹妙妥妨孕症孝術室完納推冠積宣疑辯慄碴稱屈撓屑干涉衡待很忙惡忿怎麼怠急恥恭息悅惑惜惟想愉愧怍慌憤啟懂懈懷材才緊招認扣抵拉捨也罷插揣冒搭撞南牆擴核支攻敢雷攀敬裡嗎需景智暇曾罪遇朽枉止況競爭辱求癒渝溶濟左右袒困補爽特寂寞示弱找謝畏強疾徐痛癢冤符眠睦瞅董何厚云措活疲羞者輕玻璃祥兆禁移稂莠穩佛換答簡結果盟絕縷途給談否羈翼耐肖脛毋寧興舒若菲萊痕跡窠臼虛衰臉兔撒鷹棺範該詳諱抬泰讓鬚眉象眾貲賬費灰賴奇慮訓輟辨菽麥辛近送透逞徒速續逮捕遂遑違遜斧鉞艱醉鏽隨觀棄顯飽脂肪使丏丐幫丒且慢末丕替桃宗王尊涼爵各圖屋脊糧署錄壇吾祿職胄襲君廈丗北壑桐疹損逢陵鷸丙寅戌氨腈唑綸辰酮脫氫酶醚丞丟現掉紗帽弄扯砲碗丠両丣坐存激肩臻蒂蓮悖序驅丨丩丫挺杈髻鬟細介俄伊犁京尼布訂普渡央委監察檢查劑圈設警隊斯督剩震境航舶革防托播促質版蠑螈鋒研藝歷殘消頻譜精密製造陲郵候埔堅壓壢凹匯執府究邦俘攝寮彬狼嶽肺腫庸英訊診埋粒胞括控碼韓暑槍樞砥澳哇牟壽甸鑽探篇簽綴縫繼耳肯照婦埃懸璧軸櫃檯辣擱淺邪跑纖阮陽私囊魔丮丰姿采丱燒丳丵丶丷丸參寨朗桂瑞砂衷霞貌鳳僕艦因嫌宰峰幹絡牌持旨祭禱簿編罰賓辦丼丿乀乂乃乄仰慕盛曠留考驗闊乆乇么醜麼乊湖燃乑乒乓乕乖僻忤戾离謬迕乗危肥劫除隙浪婿乙炔腸酰吡咯鹽乚乛乜嘢卿玄宮尾狐龜塔嶷兄弟泉章霄釘耙乞扎哀憐恕討乢乣乤乥乧乨乩童乪乫乭乳暈汁液瑤漿牙癌突竇罩腐膠豬酪蛋糕菌瘤乴乵乶乷乸乹乺乼乾俸冰嘉噦嚎坤媽屍壘旱枯涸俐渴潮澀煸豆燥爹瘦癟癬瞪袋脆薑貝隆餾乿亀亁叫咕攘扔搞男砸竄蓬麻亃亄亅卻亇遲典今臨繁累卵奉婚聰躬巨與遷添裂副宿歲怪噁尕崙愣杆硅硫鈦鈾錳芑雜異鈉砷胂磺琥珀艙棍簧胡茬盜浩盆販郎腿亍洪亐互欠助勉惠操斥諉繫戶譯亓墓碑刑鈴卅渠繽紛斗米旗憲釩燈徽瘟祖拳福穀豐臟腑綁肉醃苓蘊橋鋪霸顏鬧判噴岡底蛙陘礦亖亙亜罕們娜桑那努哈喀弗烈曼松森杜氏盃奧琛敦戊穆聖裔彙薛孫亟亡佚虜羊牢奮釋卷卸契媾感額睫纏誼趾塞擠紐阻還配馳莊亨洛祚亪享津滬畿郊慈菴枇杷膏亭閣鋥麗亳亶亹誅初責翻瘋偶傑叢稠妖拖寰居吸授慧蝸吞壯魅狗矛盾益渣患憂稀描猿夢暫涯畜禍緣沸搜引擎臣橫紜誰混援蒸獸獅稅剖亻亼亽亾什獻剎邡麽仂仃仄仆富怨仈仉畢昔晨殼紹仍仏仒仕宦仗欺恃腰嘆歎炬梓訖施仙后瓊逝仚仝仞仟悔仡佬償填泊拓撲簇羔購頓欽佩髮棻閫馭養億儆尤藉幀賑凌敘帖李柔剛沃眥睚戒訛取饗讀仨仫仮著泳臥躺韶夏裁仳仵唯賢憑釣誕仿似宋彿諷伀碩盼鵝伄儅伈伉儷柯始娃邁戈坦堡帕茨薩廟瑪莉莎藤霍姆伋伍奢胥廷芳豪伎倆侍汛勒希羲雛伐憩整謨閑閒伕伙伴頤伜伝伢叔恆茲恩翰伱伲侶伶俜悧鼬伸懶縮喇叭伹伺伻伽倻輻伾佀佃佇佈喬妮墨佉盧佌貸劣廉昂檔濃矮傘窪緩耗胸谷迷擋率齲宅沫舍療佐貳佑佔優據鏵嘗呢須魯曉佗佘余坪寺瓜銃僧蒙芒陀龕哼嘔坊姦孽弊揖祟繭縛誓賊佝僂瞀佟你奪趕佡佢佣佤佧賈佪佫佯佰佱潔績釀餚佴捲佶佷佸佹佺佻佼佽佾具喚窘壞娛怒慨硬習慣聾膨脹蔓駭貴痺侀侁侂侃侄侅鴻燕侇侈糜靡侉侌妾侏儒倉鼠侐侑侔侖侘侚鏈侜偎傍鈷循柳葫蘆附価侮罵蔑侯岩截蝕侷貼壺嬛宴捷攜桶箋酌俁狹膝狄俅俉俊俏俎俑俓俔諺俚俛黎健呈固墒增守康箱濕祐鏢鑣槓盒靖膜齡俞豹獵噪孚封札筒託衍鴿剪撰稿煉廠禊練繕葺俯瞰撐衝俲俳俴俵俶俷俺俻俾倀倂倅儲卒惶敷猝逃頡蓄崇隱倌倏忽刺蠟燭噍嚼坍扁抽斃蔥楣灌灶糞背藪賣賠閉霉騰倓倔倖倘倜儻倝借箸挹澆閱倡狂倢倣値倥傯倨傲倩匡嗣沖柝珍倬倭寇猩倮倶倷倹勤讚偁偃充偽吏嗓寐惺扮拱芫茜藉虢鈔偈偉晶偌宕距析濾殿疼癱註頗偓偕鴨歇滯偝偟偢忘怡旺偨偩偪偫偭偯偰偱偲偵緝蹄偷減惰漏窺竊偸偺迹傀儡傅傈僳傌籬傎奎琳迪叟芭傒傔傕傖悉荒傜傞傢傣芽逼傭婢傮睨寄檄誦謠頌傴擔辜弓慘蒿悼疤傺傻屄臆巢洩篋羨蓋軋頹傿儸僄僇僉僊働僎僑僔僖僚僝僞僣僤僥僦猴僨僩僬僭僮僯僰僱僵殖籤靜僾僿征隴儁儂儃儇儈朴薄儊儋儌儍儐儓儔儕儗儘儜儞儤儦儩汰哉寡渥裕酷儭儱罐儳儵儹儺儼儽兀臬臲鷲允勛勳宙宵帥憝彞諧嫂鬩暢沛溢盈飢赫兇悍狠猛頑愚妣斬秦遣鞭耀敏榮槃澤爆碟磁禿纜輝霽鹵朵婁孜烽醬勃汀箕裘鉗耶懞蕾徹兌軟遭黜兎児韻媳爸兕觥兗兙兛兜售鍪肚兝兞兟兡兢兣樽殮涅睡稟籍贅泌啡肽奸幕涵澇熵疚眷稃襯訌赴煥椒殲植跏沒試誤猜棲窗肋袖頰兪卦撇鬍岐廓轎疸楓茴瓏廁秩募勺噸寓斤曆畝迫筷釐最淫螺韜兮寬匪篩襄贏軛複兲詐刃堰戎痞蟻餉它冀鑄冂冃円冇冉冊嫁厲礪竭醮冏牧冑冓冔冕冖冗冘冞冢窄抑誣冥冫烘菇蟄冷凝坨橇淇淋炭餅磚磧窖醋雕雹霜冱冶爐艷嘲峻灘淡漠煖颼飲冼冽凃凄愴梗凅凇凈凊凋敝濛凔凜遵汞脢凞几凢処凰凱凵凶焰凸摺刷紋預喪嘍奔巡榜殯芙蓉租籠輯鞘萃凼鋸鑊刁蠻刂娩崩批拆攤掰櫱驟歧顆秒袂贓勿囑忌磋琢膚刈羽刎訟戮舂槳艇刓刖霹靂刜創犢刡恙墅幟筵緻刦刧刨昏默攸尿慾薰潤薰圭刪刮痧鏟刱刲刳刴刵踏磅戳柏槐繡芹莧蝟舟銘鵠鶩刼剁剃辮剄剉履鉛剋剌姻咽哨廊掠桅沿召瞻翅趙卜渺茫郭剒剔剕瀝剚愎毅訥纔剜剝啄採剞剟剡剣剤綵剮腎駛黏剰袍剴紊剷剸剺剽剿劁劂劄劈啪柴扳啦劉奭姥夼昫涓熙禪禹錫翔雁鶚劊劌弩柄蜻蛉劒劓劖劘劙瀾簣賞磯釜晉甜薪逐劦熔紂虐赤囚劬劭労劵効劻劼劾峭艮勅勇勵勍勐臘脖龐漫飼盪粥輒勖勗勘驕餒碌泮雇捐竹騎殊阱勣樸懇謹勦勧勩勯勰勱勲勷勸懲慰誡諫勹芡踐闌匁庇拯粟紮袱裹餃匆遽匈匉匊匋匍匐莖匏匕妝痰膿蛹齋苑烤蹈塘羌熊閥螳螂疆碚竿緯荷茵邙魏匚匜匝匟扶稷匣匭攏匸匹耦匽匾匿卂叮瘡禧軫堤棚迢鈞鍊卄卆遐卉瓷盲瓶噹胱腱裸卋卌卍卐怯污賤鄙齷齪陋卓溪唐梯漁陳棗泥漳潯澗梨芬譙贍轅迦鄭単驢弈洽鰲卛占筮卝卞卟吩啉屎翠厄卣卨卪卬卮榫襖璽綬鈕蚤懼殆篤聳卲帘帙繞卹卼卽厂厎厓厔厖厗奚厘厙厜厝諒厠厤厥厪膩孢厮厰厳厴厹厺粕垢蕪菁厼厾叁悟茸薯叄吵笄悌哺譏坫壟弧芯杠潛嬰芻袁詰貪諜煽饋駁収岳締災賄騙叚叡吻攔蘑蜜訣燧玩硯箏椎藺銅逗驪另覓叨嘮謁杵姓喊嚷囂咚嚀塑尋惱憎擦祇泣滲蝠叱吒咄咤喝籀黛舵舷叵叶鐸懿昭穰苴遼叻叼吁塹嫖賭瞧爬衆抒吅吆夥巹橡滌抱縱摩郡唁墜扇籃膀襪頸吋愾諮酬哭妓媛暗錶韁邇妃羿絮蕃渾拐葵暮隅吔吖啶嗪戚吜嗇噬嚥吟哦詠吠吧唧嗒咐吪雋咀徵燐苞茹鈣哧吮吰吱嘎吲哚吳棟嬌窟孟簫忠晗淞闔閭趼宇吶睛噓拂捧疵熄竽笛糠吼吽呀呂韋矇呃呆笨呇貢呉罄呋喃呎呏呔呠呡癡呣呤呦呧瑛眩扒晬淑姬瑜璇鵑呪呫嗶嚅囁呬呯呰呱呲咧噌鈍呴呶呷呸呺呻哱咻嘯嚕籲坎坷邏呿咁咂咆哮咇咈咋蟹煦珅藹咍咑咒詛咔噠嚓咾噥哩喱咗咠咡咢咣咥咦咨嗟詢咩咪咫嚙齧咭咮咱咲咳嗆嗽咴咷咸咹咺咼喉咿婉慟憫賦矜綠茗藍哂搶瞞哆嗦囉噻啾濱彗哋哌哎唷喲哏哐哞哢哤哪裏哫啼喘哰哲萎蚌哳哶哽哿唄唅唆唈唉唎唏嘩堯棣殤璜睿肅唔睇唕唚唞唣喳唪唬唰喏唲唳唵嘛唶唸唹唻唼唾唿啁啃鸚鵡啅埠棧榷祺舖鞅飆啊啍啎啐啓啕啖啗啜啞祈啢啣啤啥啫啱啲啵啺饑啽噶崑沁喁喂喆裙喈嚨喋喌喎喑喒喓喔粗喙幛慶滋鵲喟喣喤喥喦喧騷喨喩梆喫葡萄喭駝挑嚇碰樅瓣純皰藻趟鉻喵営喹喺喼喿嗀嗃嗄嗅嗈嗉嗊嗍嗐嗑嗔詬嗕嗖嗙嗛嗜痂癖嗝嗡嗤嗥嗨嗩嗬嗯嗰嗲嗵嘰嗷嗹嗾嗿嘀嘁嘂嘅惋嘈峪禾蔭嘊嘌嘏嘐嘒嘓嘖嘚嘜嘞嘟囔嘣嘥嘦嘧嘬嘭這謔嚴敞饞鬆嘵嘶嘷嘸蝦嘹嘻嘽嘿噀噂噅噇噉噎噏噔噗噘噙噚噝噞噢噤蟬皿噩噫噭噯噱噲噳嚏涌灑欲巫霏噷噼嚃嚄嚆抖嚌嚐嚔囌嚚嚜嚞嚟嚦嚬嚭嚮嚯嚲嚳飭按竣苛嚵嚶囀囅囈膪謙囍囒囓囗囘蕭酚飄濺諦囝溯眸紇鑾鶻囟殉囡団囤囥囧囨囪囫圇囬囮囯囲図囶囷囸囹圄圉擬囻囿圀圂圃圊粹蠹赦圌墾圏滾鯡鑿枘圕圛圜圞坯埂壤骸炕祠窯豚紳魠鯪鱉圧握圩圪垯圬圮圯炸岬幔毯祇窨菩溉圳圴圻圾坂坆沾坋坌舛壈昆墊墩椅坒坓坩堝坭坰坱坳坴坵坻坼楊掙涎簾垃垈垌垍垓垔垕垗垚垛垝垣垞垟垤垧垮垵垺垾垿埀畔埄埆埇埈埌殃隍埏埒埕埗埜埡埤埦埧埭埯埰埲埳埴埵埶紼埸培怖樁礎輔埼埽堀訶姪廡堃堄摧磐貞韌砌堈堉堊堋堌堍堎堖堙堞堠礁堧堨輿堭堮蜓摘堲堳堽堿塁塄塈煤塋棵塍塏塒塓綢塕鴉沽虱塙塚塝繆塡塢塤塥塩塬塱塲蟎塼塽塾塿墀墁墈墉墐夯増毀墝墠墦漬缽墫墬墮墰墺墻櫥壅壆壊壌壎壒榨蒜壔壕壖壙壚壜壝壠壡壬壭壱売壴壹壻壼寢壿夂夅夆変夊夌漱邑夓腕泄甥禦骼夗夘夙袞瑙妊娠醣梟珊鶯鷺戧幻魘夤蹀祕擂鶇姚宛閨嶼庾撻拇賛蛤裨菠氅漓撈湄蚊霆鯊箐篆篷荊肆舅荔鮃巷慚骰辟邱鎔鐮阪漂燴鯢鰈鱷鴇臚鵬妒峨譚枰晏璣癸祝秤竺牡籟恢罡螻蠍賜絨御梭夬夭砣榆怙枕夶夾餡奄崛葩譎奈賀祀贈奌奐奓奕訢詝奘奜奠奡奣陶奨奩魁奫奬奰媧孩貶隸酥宄狡猾她奼嫣妁氈荼皋膻蠅嬪妄妍嫉媚嬈妗趣妚妞妤礙妬婭妯娌妲妳妵妺姁姅姉姍姒姘姙姜姝姞姣姤姧姫姮娥姱姸姺姽婀娀誘懾脅娉婷娑娓娟娣娭娯娵娶娸娼婊婐婕婞婤婥谿孺婧婪婬婹婺婼婽媁媄媊媕媞媟媠媢媬媮媯媲媵媸媺媻媼眯媿嫄嫈嫋嫏嫕嫗嫘嫚嫜嫠嫡嫦嫩嫪毐嫫嫬嫰嫵嫺嫻嫽嫿嬀嬃嬅嬉耍嬋痴豔嬔嬖嬗嬙嬝嬡嬢嬤嬦嬬嬭幼嬲嬴嬸嬹嬾嬿孀孃孅孌孏曰癲屏孑孓雀孖斟簍謎摺孛矻鳩崮軻祜鸞孥邈毓棠臏孬孭孰孱孳孵泛罔銜孻孿宀宁宂拙株薇掣撫琪瓿榴謐彌宊濂祁瑕宍宏碁宓邸讞実潢町宥宧宨宬徵崎駿掖闕臊煮禽蠶宸豫寀寁寥寃簷庶寎暄磣寔寖寘寙寛寠苫寤肘洱濫蒗陝覈寪弘綽螽寳擅疙瘩晷対檐専尃尅贖絀繚疇釁尌峙醌襟痲碧屁昊槌淘恵瀑牝畑莓缸羚覷蔻髒躁尒尓銳尗尙尜尟尢尥尨尪尬尭尰擒尲尶尷尸尹潽蠖蛾尻釦梢蚴鰭脬蹲屇屌蚵屐屓挪屖屘屙屛屝屢屣巒嶂巖舄屧屨屩屪屭屮戍駐鉀崖嵛巔旮旯楂欖櫸芋茱萸靛麓屴屹屺屼岀岊岌岍阜岑彭鞏岒岝岢嵐岣岧岨岫岱岵岷峁峇峋峒峓峞峠嵋峩峯峱峴峹峿崀崁崆禎崋崌崍嶇崐崒崔嵬巍螢顥崚崞崟崠崢巆崤崦崧殂崬崱崳崴崶崿嵂嵇嵊泗嵌嵎嵒嵓嵗嵙嵞嵡嵩嵫嵯嵴嵼嵾嶁嶃嶄晴嶋嶌嶒嶓嶔嶗嶙嶝嶞嶠嶡嶢嶧嶨嶭嶮嶰嶲嶴嶸巂巃巇巉巋巌巓巘巛滇芎巟巠弋迴巣巤炊擘蜥蟒蠱覡巰蜀彥淖杏茂甫楞巻巽幗巿帛斐鯽蕊帑帔帗帚琉汶帟帡帣帨帬帯帰帷帹暆幃幄幇幋幌幏幘幙幚幞幠幡幢幦幨幩幪幬幭幯幰遙蹉跎餘庚鑑幵幷稚邃庀庁広庄庈庉笠庋跋庖犧庠庤庥鯨庬庱庳庴庵馨衢庹庿廃廄廆廋廌廎廏廐廑廒廕廖廛廝搏鑼廞弛袤廥廧廨廩廱綿踵髓廸廹甌鄴廻廼廾廿躔弁皺弇弌弍弎弐弒弔詭憾薦弝弢弣弤弨弭弮弰弳霖繇燾斌旭溥騫弶弸弼弾彀彄彆纍糾彊彔彖彘彟彠陌彤貽彧繪虹彪炳彫蔚鷗彰癉彲彳彴彷彷徉徨彸彽踩斂旆徂徇徊渭畬鉉裼従筌徘徙徜徠膳甦萌漸徬徭醺徯徳徴潘徻徼忀瘁胖燎怦悸顫扉犀澎湃砰恍惚絞隘忉憚挨餓忐忑忒忖応忝忞耿忡忪忭忮忱忸怩忻悠懣怏遏怔怗怚怛怞懟黍訝怫怭懦怱怲怳怵惕怸怹恁恂恇恉恌恏恒恓恔恘恚恛恝恞恟恠恣恧眄恪恫恬澹恰恿悀悁悃悄悆悊悐悒晦悚悛悜悝悤您悩悪悮悰悱悽惻悳悴悵惘悶悻悾惄愫鍾蒐惆惇惌惎惏惓惔惙惛耄惝瘧濁惥惦惪惲惴惷惸拈愀愃愆愈愊愍愐愑愒愓愔愕愙氓蠢騃昵愜赧愨愬愮愯愷愼慁慂慅慆慇靄慉慊慍慝慥慪慫慬慱慳慴慵慷慼焚憀灼鬱憃憊憋憍眺捏軾憒憔憖憙憧憬憨憪憭憮憯憷憸憹憺懃懅懆邀懊懋懌懍懐懞懠懤懥懨懫懮懰懱毖懵遁樑雍懺懽戁戄戇戉戔戕戛戝戞戠戡戢戣戤戥戦戩戭戯轟戱披菊牖戸戹戺戻戼戽鍬扂楔扃扆扈扊杖牽絹銬鐲賚扐摟攪烊盹瞌跟躉鑔靶鼾払扗玫腮扛扞扠扡扢盔押扤扦扱罾揄綏鞍郤窾扻扼扽抃抆抈抉抌抏瞎抔繯縊擻抜抝択抨摔歉躥牾抶抻搐泵菸拃拄拊髀拋拌脯拎拏拑擢秧沓曳攣迂拚拝拠拡拫拭拮踢拴拶拷攢拽掇芥橐簪摹疔挈瓢驥捺蹻挌挍挎挐揀挓挖掘浚挙揍聵挲挶挾挿捂捃捄捅捆捉捋胳膊揎捌捍捎軀蛛捗捘捙捜捥捩捫捭据捱捻捼捽掀掂掄臀膘掊掎掏掐笙掔掗掞棉芍掤搪闡掫掮掯揉掱掲掽掾揃揅揆搓揌諢揕揗揘揜揝揞揠揥揩揪揫櫫遒麈揰揲揵揶揸揹揺搆搉搊搋搌搎搔搕撼櫓搗搘搠搡搢搣搤搥搦搧搨搬楦褳訕赸搯搰搲搳搴搵搷搽搾搿摀摁摂摃摎摑摒摓跤摙摛摜摞摠摦睺羯摭摮摯摰摲摳摴摶摷摻摽撂撃撅稻撊撋撏鐧潑撕撙撚撝撟撢撣撦撧撩撬撱朔撳蚍蜉撾撿擀擄闖擉缶觚擐擕擖擗擡擣擤澡腚擧擨擩擫擭擯擰擷擸擼擽擿攃攄攆攉攥攐攓攖攙攛每攩攫轡澄攮攰攲攴軼攷砭訐攽碘敁敃敇敉敍敎筏敔敕敖閏誨敜煌敧敪敱敹敺敻敿斁衽斄牒縐謅斉斎斕鶉讕駮鱧斒筲斛斝斞斠斡斢斨斫斮晾沂潟穎絳邵斲斸釳於琅斾斿旀旂旃旄渦旌旎旐旒旓旖旛旝旟旡旣浴旰獺魃旴旹旻旼旽昀昃昄昇昉晰躲澈熹皎皓礬昑昕昜昝昞昡昤暉筍昦昨昰昱昳昴昶昺昻晁蹇隧蔬髦晄晅晒晛晜晞晟晡晢晤晥曦晩萘瑩顗晿暁暋暌暍暐暔暕煅暘暝暠暡曚暦暨暪朦朧暱暲殄馮暵暸暹暻暾曀曄曇曈曌曏曐曖曘曙曛曡曨曩駱曱甴肱曷牘禺錕曽滄耽朁朅朆杪栓誇竟粘絛朊膺朏朐朓朕朘朙瞄覲溘饔飧朠朢朣柵椆澱蝨朩朮朰朱炆璋鈺熾鹮朳槿朶朾朿杅杇杌隉欣釗湛漼楷瀍煜玟纓翱肈舜贄适逵杓杕杗杙荀蘅杝杞脩珓筊杰榔狍閦顰緬莞杲杳眇杴杶杸杻杼枋枌枒枓衾葄翹紓逋枙狸椏枟槁枲枳枴枵枷枸櫞枹枻柁柂柃柅柈柊柎某柑橘柒柘柙柚柜柞櫟柟柢柣柤柩柬柮柰柲橙柶柷柸柺査柿栃栄栒栔栘栝栟栢栩栫栭栱栲栳栴檀栵栻桀驁桁鎂桄桉桋桎梏椹葚桓桔桕桜桟桫欏桭桮桯桲桴桷桹湘溟梃梊梍梐潼梔梘梜梠梡梣梧梩梱梲梳梴梵梹棁棃櫻棐棑棕櫚簑繃蓑棖棘棜棨棩棪棫棬棯棰棱棳棸棹槨棼椀椄苕椈椊椋椌椐椑椓椗検椤椪椰椳椴椵椷椸椽椿楀楄楅篪楋楍楎楗楘楙楛楝楟楠楢楥楨楩楪楫楬楮楯楰楳楸楹楻楽榀榃榊榎槺榕榖榘榛狉莽榜笞榠榡榤榥榦榧榪榭榰榱槤霰榼榾榿槊閂槎槑槔槖様槜槢槥槧槪槭槮槱槲槻槼槾樆樊樏樑樕樗樘樛樟樠樧樨権樲樴樵猢猻樺樻罍樾樿橁橄橆橈笥龠橕橚橛輛橢橤橧豎膈跨橾橿檁檃檇檉檍檎檑檖檗檜檟檠檣檨檫檬檮檳檴檵檸櫂櫆櫌櫛櫜櫝櫡櫧櫨櫪櫬櫳櫹櫺茄櫽欀欂欃欐欑欒欙欞溴欨欬欱欵欶欷歔欸欹欻欼欿歁歃歆艎歈歊蒔蝶歓歕歘歙歛歜歟歠蹦詮鑲蹣跚陞陟歩歮歯歰歳歴璞歺瞑歾歿殀殈殍殑殗殜殙殛殞殢殣殥殪殫殭殰殳荃殷殸殹蛟殻殽謗毆毈毉餵毎毑蕈毗毘毚茛鄧毧毬毳毷毹毽毾毿氂氄氆靴氉氊氌氍氐聊氕氖気氘氙氚氛氜氝氡洶焊痙氤氳氥氦鋁鋅氪烴氬銨痤汪滸漉痘盂碾菖蒲蕹蛭螅氵氷氹氺氽燙氾氿渚汆汊汋汍汎汏汐汔汕褟汙汚汜蘺沼穢衊汧汨汩汭汲汳汴隄汾沄沅沆瀣沇沈葆浸淪湎溺痼痾沌沍沏沐沔沕沘浜畹礫沚沢沬沭沮沰沱灢沴沷籽沺烹濡洄泂肛泅泆湧肓泐泑泒泓泔泖泙泚泜泝泠漩饃濤粼濘蘚鰍泩泫泭泯銖泱泲洇洊涇琵琶荽薊箔洌洎洏洑潄濯洙洚洟洢洣洧洨洩痢滔洫洮洳洴洵洸洹洺洼洿淌蜚浄浉浙贛渫浠浡浤浥淼瀚浬浭翩萍浯浰蜃淀苔蛞蝓蜇螵蛸煲鯉浹浼浽溦涂涊涐涑涒涔滂涖涘涙涪涫涬涮涴涶涷涿淄淅淆淊淒黯淓淙漣淜淝淟淠淢淤淥淦淩猥藿褻淬淮淯淰淳詣淶紡淸淹燉癯綺渇済渉渋渓渕渙渟渢滓渤澥渧渨渮渰渲渶渼湅湉湋湍湑湓湔黔湜湝湞湟湢湣湩湫湮麟湱湲湴湼満溈溍溎溏溛舐漭溠溤溧馴溮溱溲溳溵溷溻溼溽溾滁滃滉滊滎滏稽滕滘滙滝滫滮羼耷滷滹滻煎漈漊漎繹漕漖漘漙漚漜漪漾漥漦漯漰漵漶漷濞潀潁潎潏潕潗潚潝潞潠潦祉瘍潲潵潷潸潺潾潿澁澂澃澉澌澍澐澒澔澙澠澣澦澧澨澫澬澮澰澴澶澼熏郁濆濇濈濉濊貊濔疣濜濠濩觴濬濮盥濰濲濼瀁瀅瀆瀋瀌瀏瀒瀔瀕瀘瀛瀟瀠瀡瀦瀧瀨瀬瀰瀲瀳瀵瀹瀺瀼灃灄灉灋灒灕灖灝灞灠灤灥灨灩灪蜴灮燼獴灴灸灺炁炅魷炗炘炙炤炫疽烙釺炯炰炱炲炴炷燬炻烀烋瘴鯧烓烔焙烜烝烳飪烺焃焄耆焌焐焓焗焜焞焠焢焮焯焱焼煁煃煆煇煊熠煍熬煐煒煕煗燻礆霾煚煝煟煠煢矸煨瑣煬萁煳煺煻熀熅熇熉羆熒穹熗熘熛熜稔諳爍熤熨熯熰眶螞熲熳熸熿燀燁燂燄盞燊燋燏燔隼燖燜燠燡燦燨燮燹燻燽燿爇爊爓爚爝爟爨蟾爯爰爲爻爿爿牀牁牂牄牋牎牏牓牕釉牚腩蒡虻牠雖蠣牣牤牮牯牲牳牴牷牸牼絆牿靬犂犄犆犇犉犍犎犒犖犗犛犟犠犨犩犪犮犰狳犴犵犺狁甩狃狆狎狒獾狘狙黠狨狩狫狴狷狺狻豕狽蜘猁猇猈猊猋猓猖獗猗猘猙獰獁猞猟獕猭猱猲猳猷猸猹猺玃獀獃獉獍獏獐獒獘獙獚獜獝獞獠獢獣獧鼇蹊獪獫獬豸獮獯鬻獳獷獼玀玁菟玅玆玈珉糝禛郅玍玎玓瓅玔玕玖玗玘玞玠玡玢玤玥玦玨瑰玭玳瑁玶玷玹玼珂珇珈瑚珌饈饌珔珖珙珛珞珡珣珥珧珩珪珮珶珷珺珽琀琁隕琊琇琖琚琠琤琦琨琫琬琭琮琯琰琱琲瑯琹琺琿瑀瑂瑄瑉瑋瑑瑔瑗瑢瑭瑱瑲瑳瑽瑾瑿璀璨璁璅璆璈璉璊璐璘璚璝璟璠璡璥璦璩璪璫璯璲璵璸璺璿瓀瓔瓖瓘瓚瓛臍瓞瓠瓤瓧瓩瓮瓰瓱瓴瓸瓻瓼甀甁甃甄甇甋甍甎甏甑甒甓甔甕甖甗飴蔗甙詫鉅粱盎銹糰甡褥産甪甬甭甮甯鎧甹甽甾甿畀畁畇畈畊畋畎畓畚畛畟鄂畤畦畧荻畯畳畵畷畸畽畾疃疉疋疍疎簞疐疒疕疘疝疢疥疧疳疶疿痁痄痊痌痍痏痐痒痔痗瘢痚痠痡痣痦痩痭痯痱痳痵痻痿瘀瘂瘃瘈瘉瘊瘌瘏瘐瘓瘕瘖瘙瘚瘛瘲瘜瘝瘞瘠瘥瘨瘭瘮瘯瘰癧瘳癘瘵瘸瘺瘻瘼癃癆癇癈癎癐癔癙癜癠癤癥癩蟆癪癭癰発踔紺蔫酵皙砬砒翎翳蘞鎢鑞皚鵯駒鱀粵褶皀皁莢皃鎛皈皌皐皒硃皕皖皘皜皝皞皤皦皨皪皫皭糙綻皴皸皻皽盅盋盌盍盚盝踞盦盩鞦韆盬盭眦睜瞤盯盱眙裰盵盻睞眂眅眈眊県眑眕眚眛眞眢眣眭眳眴眵眹瞓眽郛睃睅睆睊睍睎睏睒睖睙睟睠睢睥睪睪睯睽睾瞇瞈瞋瞍逛瞏瞕瞖瞘瞜瞟瞠瞢瞫瞭瞳瞵瞷瞹瞽闍瞿矓矉矍鑠矔矗矙矚矞矟矠矣矧矬矯矰矱硪碇磙罅舫阡、矼矽礓砃砅砆砉砍砑砕砝砟砠砢砦砧砩砫砮砳艏砵砹砼硇硌硍硎硏硐硒硜硤硨磲茚鋇硭硻硾碃碉碏碣碓碔碞碡碪碫碬碭碯碲碸碻礡磈磉磎磑磔磕磖磛磟磠磡磤磥蹭磪磬磴磵磹磻磽礀礄礅礌礐礚礜礞礤礧礮礱礲礵礽礿祂祄祅祆禳祊祍祏祓祔祕祗祘祛祧祫祲祻祼餌臠錮禂禇禋禑禔禕隋禖禘禚禜禝禠禡禢禤禥禨禫禰禴禸稈秈秊闈颯秌秏秕笈蘵賃秠秣秪秫秬秭秷秸稊稌稍稑稗稙稛稞稬稭稲稹稼顙稾穂穄穇穈穉穋穌貯穏穜穟穠穡穣穤穧穨穭穮穵穸窿闃窀窂窅窆窈窕窊窋窌窒窓窔窞窣窬黷蹙窰窳窴窵窶窸窻竁竃竈竑竜竝竦竪篦篾笆鮫竾笉笊笎笏笐靨笓笤籙笪笫笭笮笰笱笲笳笵笸笻筀筅筇筈筎筑筘筠筤筥筦筧筩筭筯筰筱筳筴讌筸箂箇箊箎箑箒箘箙箛箜篌箝箠箬鏃箯箴箾篁篔簹篘篙篚篛篜篝篟篠篡篢篥篧篨篭篰篲篳篴篶篹篼簀簁簃簆簉簋簌簏簜簟簠簥簦簨簬簰簸簻籊籐籒籓籔籖籚籛籜籣籥籧籩籪籫籯芾麴籵籸籹籼粁粃粋粑粔糲粛粞粢粧粨粲粳粺粻粽闢粿糅糆糈糌糍糒糔萼糗蛆蹋糢糨糬糭糯糱糴糶糸糺紃蹼鰹黴紆紈絝紉閩襻紑紕紘錠鳶鷂紝紞紟紥紩紬紱紲紵紽紾紿絁絃絅経絍絎絏縭褵絓絖絘絜絢絣螯絪絫聒絰絵絶絺絻絿綀綃綅綆綈綉綌綍綎綑綖綘継続緞綣綦綪綫綮綯綰罟蝽綷縩綹綾緁緄緅緆緇緋緌緎総緑緔緖緗緘緙緜緡緤緥緦纂緪緰緱緲緶緹縁縃縄縈縉縋縏縑縕縗縚縝縞縟縠縡縢縦縧縯縰騁縲縳縴縵縶縹縻衙縿繄繅繈繊繋繐繒繖繘繙繠繢繣繨繮繰繸繻繾纁纆纇纈纉纊纑纕纘纙纚纛缾罃罆罈罋罌罎罏罖罘罛罝罠罣罥罦罨罫罭鍰罳罶罹罻罽罿羂羃羇羋蕉５１鴕羑羖羗羜羝羢羣羥羧羭羮羰羱羵羶羸藜鮐翀翃翄翊翌翏翕翛翟翡翣翥翦躚翪翫翬翮翯翺翽翾翿闆饕鴰鍁耋耇耎耏耑耒耜耔耞耡耤耨耩耪耬耰鬢耵聹聃聆聎聝聡聦聱聴聶聼閾聿肄肏肐肕腋肙肜肟肧胛肫肬肭肰肴肵肸肼胊胍胏胑胔胗胙胝胠銓胤胦胩胬胭胯胰胲胴胹胻胼胾脇脘脝脞脡脣脤脥脧脰脲脳腆腊腌臢腍腒腓腖腜腠腡腥腧腬腯踝蹬鐐腴腶蠕誹膂膃膆膇膋膔膕膗膙膟黐膣膦膫膰膴膵膷膾臃臄臇臈臌臐臑臓臕臖臙臛臝臞臧蓐詡臽臾臿舀舁鰟鮍舋舎舔舗舘舝舠舡舢舨舭舲舳舴舸舺艁艄艅艉艋艑艕艖艗艘艚艜艟艣艤艨艩艫艬艭荏艴艶艸艹艻艿芃芄芊萰陂藭芏芔芘芚蕙芟芣芤茉芧芨芩芪芮芰鰱芴芷芸蕘豢芼芿苄苒苘苙苜蓿苠苡苣蕒苤苧苪鎊苶苹苺苻苾茀茁范蠡萣茆茇茈茌茍茖茞茠茢茥茦菰茭茯茳藨茷藘茼荁荄荅荇荈菅蜢鴞荍荑荘荳荵荸薺莆莒莔莕莘莙莚莛莜莝莦莨菪莩莪莭莰莿菀菆菉菎菏菐菑菓菔菕菘菝菡菢菣菥蓂菧菫轂鎣菶菷菹醢菺菻菼菾萅萆萇萋萏萐萑萜萩萱萴萵萹萻葇葍葎葑葒葖葙葠葥葦葧葭葯葳葴葶葸葹葽蒄蒎蒓蘢薹蒞蒟蒻蒢蒦蒨蒭藁蒯蒱鉾蒴蒹蒺蒽蓀蓁蓆蓇蓊蓌蓍蓏蓓蓖蓧蓪蓫蓽跣藕蓯蓰蓱蓴蓷蓺蓼蔀蔂蔃蔆蔇蔉蔊蔋蔌蔎蔕蔘蔙蔞蔟鍔蔣雯蔦蔯蔳蔴蔵蔸蔾蕁蕆蕋蕍蕎蕐蕑蕓蕕蕖蕗蕝蕞蕠蕡蕢蕣蕤蕨蕳蕷蕸蕺蕻薀薁薃薅薆薈薉薌薏薐薔薖薘薙諤釵薜薠薢薤薧薨薫薬薳薶薷薸薽薾薿藄藇藋藎藐藙藚藟藦藳藴藶藷藾蘀蘁蘄蘋蘗蘘蘝蘤蘧蘩蘸蘼虀虆虍蟠虒虓虖虡虣虥虩虯虰蛵虵虷鱒虺虼蚆蚈蚋蚓蚔蚖蚘蚜蚡蚣蚧蚨蚩蚪蚯蚰蜒蚱蚳蚶蚹蚺蚻蚿蛀蛁蛄蛅蝮蛌蛍蛐蟮蛑蛓蛔蛘蛚蛜蛡蛣蜊蛩蛺蛻螫蜅蜆蜈蝣蜋蜍蜎蜑蠊蜛餞蜞蜣蜨蜩蜮蜱蜷蜺蜾蜿蝀蝃蝋蝌蝍蝎蝏蝗蝘蝙蝝鱝蝡蝤蝥蝯蝰蝱蝲蝴蝻螃蠏螄螉螋螒螓螗螘螙螚蟥螟螣螥螬螭螮螾螿蟀蟅蟈蟊蟋蟑蟓蟛蟜蟟蟢蟣蟨蟪蟭蟯蟳蟶蟷蟺蟿蠁蠂蠃蠆蠋蠐蠓蠔蠗蠙蠚蠛蠜蠧蠨蠩蠭蠮蠰蠲蠵蠸蠼蠽衁衂衄衇衈衉衋衎衒衕衖衚衞裳鈎衭衲衵衹衺衿袈裟袗袚袟袢袪袮袲袴袷袺袼褙袽裀裉裊裋裌裍裎裒裛裯裱裲裴裾褀褂褉褊褌褎褐褒褓褔褕褘褚褡褢褦褧褪褫褭褯褰褱襠褸褽褾襁襃襆襇襉襋襌襏襚襛襜襝襞襡襢襤襦襫襬襭襮襴襶襼襽襾覂覃覅覇覉覊覌覗覘覚覜覥覦覧覩覬覯覰観覿觔觕觖觜觽觝觡酲觩觫觭觱觳觶觷觼觾觿言賅訃訇訏訑訒詁託訧訬訳訹証訾詀詅詆譭詈詊詎詑詒詖詗詘詧詨詵詶詸詹詻詼詿誂誃誄鋤誆誋誑誒誖誙誚誥誧説読誯誶誾諂諄諆諌諍諏諑諕諗諛諝諞諟諠諡諴諵諶諼謄謆謇謌謍謏謑謖謚謡謦謪謫謳謷謼謾譁譅譆譈譊譌譒譔譖鑫譞譟譩譫譬譱譲譴譸譹譾讅讆讋讌讎讐讒讖讙讜讟谽豁豉豇豈豊豋豌豏豔豞豖豗豜豝豣豦豨豭豱豳豵豶豷豺豻貅貆貍貎貔貘貙貜貤饜貰餸貺賁賂賏賒賕賙賝賡賧賨賫鬭賮賵賸賺賻賾贇贉贐贔贕贗赬赭赱赳迄趁趂趄趐趑趒趔趡趦趫趮趯趲趴趵趷趹趺趿跁跂跅跆躓蹌跐跕跖跗跙跛跦跧跩跫跬跮跱跲跴跺跼跽踅踆踈踉踊踒踖踘踜踟躇躕踠踡踣踤踥踦踧蹺踫踮踰踱踴踶踹踺踼踽躞蹁蹂躪蹎蹐蹓蹔蹕蹚蹜蹝蹟蹠蹡蹢躂蹧蹩蹪蹯鞠蹽躃躄躅躊躋躐躑躒躘躙躛躝躠躡躦躧躩躭躰躳躶軃軆輥軏軔軘軜軝齶転軥軨軭軱軲轆軷軹軺軽軿輀輂輦輅輇輈輓輗輙輜輞輠輤輬輭輮輳輴輵輶輹輼輾轀轇轏轑轒轔轕轖轗轘轙轝轞轢轤辠辢辤辵辶辺込辿迅迋迍麿迓迣迤邐迥迨迮迸迺迻迿逄逅逌逍逑逓逕逖逡逭逯逴逶逹遄遅遉遘遛遝遢遨遫遯遰遴遶遹遻邂邅邉邋邎邕邗邘邛邠邢邧邨邯鄲邰邲邳邴邶邷邽邾邿郃郄郇郈郔郕郗郙郚郜郝郞郟郠郢郪郫郯郰郲郳郴郷郹郾郿鄀鄄鄆鄇鄈鄋鄍鄎鄏鄐鄑鄒鄔鄕鄖鄗鄘鄚鄜鄞鄠鄢鄣鄤鄦鄩鄫鄬鄮鄯鄱鄶鄷鄹鄺鄻鄾鄿酃酅酆酇酈酊酋酎酏酐酣酔酕醄酖酗酞酡酢酤酩酴酹酺醁醅醆醊醍醐醑醓醖醝醞醡醤醨醪醭醯醰醱醲醴醵醸醹醼醽醾釂釃釅釆釈鱸鎦閶釓釔釕鈀釙鼢鼴釤釧釪釬釭釱釷釸釹鈁鈃鈄鈆鈇鈈鈊鈌鈐鈑鈒鈤鈥鈧鈬鈮鈰鈳鐺鈸鈹鈽鈿鉄鉆鉈鉋鉌鉍鉏鉑鉕鉚鉢鉥鉦鉨鉬鉭鉱鉲鉶鉸鉺鉼鉿銍銎銑銕鏤銚銛銠銣銤銥銦銧銩銪銫銭銰銲銶銻銼銾鋂鋃鋆鋈鋊鋌鋍鋏鋐鋑鋕鋘鋙鋝鋟鋦鋨鋩鋭鋮鋯鋰鋱鋳鋹鋺鋻鏰鐱錀錁錆錇錈錍錏錒錔錙錚錛錞錟錡錤錩錬録錸錼鍀鍆鍇鍉鍍鍏鍐鍘鍚鍛鍠鍤鍥鍩鍫鍭鍱鍴鍶鍹鍺鍼鍾鎄鎇鎉鎋鎌鎍鎏鎒鎓鎗鎘鎚鎞鎡鎤鎩鎪鎭鎯鎰鎳鎴鎵鎸鎹鎿鏇鏊鏌鏐鏑鏖鏗鏘鏚鏜鏝鏞鏠鏦鏨鏷鏸鏹鏻鏽鏾鐃鐄鐇鐏鐒鐓鐔鐗馗鐙鐝鐠鐡鐦鐨鐩鐫鐬鐱鐳鐶鐻鐽鐿鑀鑅鑌鑐鑕鑚鑛鑢鑤鑥鑪鑭鑯鑱鑴鑵鑷钁钃镻閆閈閌閎閒閔閗閟閡関閤閤閧閬閲閹閺閻閼閽閿闇闉闋闐闑闒闓闘闚闞闟闠闤闥阞阢阤阨阬阯阹阼阽陁陑陔陛陜陡陥陬騭陴険陼陾隂隃隈隒隗隞隠隣隤隩隮隰顴隳隷隹雂雈雉雊雎雑雒雗雘雚雝雟雩雰雱驛霂霅霈霊霑霒霓霙霝霢霣霤霨霩霪霫霮靁靆靉靑靚靣靦靪靮靰靳靷靸靺靼靿鞀鞃鞄鞌鞗鞙鞚鞝鞞鞡鞣鞨鞫鞬鞮鞶鞹鞾韃韅韉馱韍韎韔韖韘韝韞韡韣韭韮韱韹韺頀颳頄頇頊頍頎頏頒頖頞頠頫頬顱頯頲頴頼顇顋顑顒顓顔顕顚顜顢顣顬顳颭颮颱颶颸颺颻颽颾颿飀飂飈飌飜飡飣飤飥飩飫飮飱飶餀餂餄餎餇餈餑餔餕餖餗餚餛餜餟餠餤餧餩餪餫餬餮餱餲餳餺餻餼餽餿饁饅饇饉饊饍饎饐饘饟饢馘馥馝馡馣騮騾馵馹駃駄駅駆駉駋駑駓駔駗駘駙駜駡駢駪駬駰駴駸駹駽駾騂騄騅騆騉騋騍騏驎騑騒験騕騖騠騢騣騤騧驤騵騶騸騺驀驂驃驄驆驈驊驌驍驎驏驒驔驖驙驦驩驫骺鯁骫骭骯骱骴骶骷髏骾髁髂髄髆髈髐髑髕髖髙髝髞髟髡髣髧髪髫髭髯髲髳髹髺髽髾鬁鬃鬅鬈鬋鬎鬏鬐鬑鬒鬖鬗鬘鬙鬠鬣鬪鬫鬬鬮鬯鬰鬲鬵鬷魆魈魊魋魍魎魑魖鰾魛魟魣魦魨魬魴魵魸鮀鮁鮆鮌鮎鮑鮒鮓鮚鮞鮟鱇鮠鮦鮨鮪鮭鮶鮸鮿鯀鯄鯆鯇鯈鯔鯕鯖鯗鯙鯠鯤鯥鯫鯰鯷鯸鯿鰂鰆鶼鰉鰋鰐鰒鰕鰛鰜鰣鰤鰥鰦鰨鰩鰮鰳鰶鰷鱺鰼鰽鱀鱄鱅鱆鱈鱎鱐鱓鱔鱖鱘鱟鱠鱣鱨鱭鱮鱲鱵鱻鲅鳦鳧鳯鳲鳷鳻鴂鴃鴄鴆鴈鴎鴒鴔鴗鴛鴦鴝鵒鴟鴠鴢鴣鴥鴯鶓鴳鴴鴷鴽鵀鵁鵂鵓鵖鵙鵜鶘鵞鵟鵩鵪鵫鵵鵷鵻鵾鶂鶊鶏鶒鶖鶗鶡鶤鶦鶬鶱鶲鶵鶸鶹鶺鶿鷀鷁鷃鷄鷇鷈鷉鷊鷏鷓鷕鷖鷙鷞鷟鷥鷦鷯鷩鷫鷭鷳鷴鷽鷾鷿鸂鸇鸊鸏鸑鸒鸓鸕鸛鸜鸝鹸鹹鹺麀麂麃麄麇麋麌麐麑麒麚麛麝麤麩麪麫麮麯麰麺麾黁黈黌黢黒黓黕黙黝黟黥黦黧黮黰黱黲黶黹黻黼黽黿鼂鼃鼅鼈鼉鼏鼐鼒鼕鼖鼙鼚鼛鼡鼩鼱鼪鼫鼯鼷鼽齁齆齇齈齉齌齎齏齔齕齗齙齚齜齞齟齬齠齢齣齧齩齮齯齰齱齵齾龎龑龒龔龖龘龝龡龢龤'

assert len(simplified_charcters) == len(simplified_charcters)

s2t_dict = {}
t2s_dict = {}
for i, item in enumerate(simplified_charcters):
    s2t_dict[item] = traditional_characters[i]
    t2s_dict[traditional_characters[i]] = item


def tranditional_to_simplified(text: str) -> str:
    return "".join(
        [t2s_dict[item] if item in t2s_dict else item for item in text])


def simplified_to_traditional(text: str) -> str:
    return "".join(
        [s2t_dict[item] if item in s2t_dict else item for item in text])


if __name__ == "__main__":
    text = "一般是指存取一個應用程式啟動時始終顯示在網站或網頁瀏覽器中的一個或多個初始網頁等畫面存在的站點"
    print(text)
    text_simple = tranditional_to_simplified(text)
    print(text_simple)
    text_traditional = simplified_to_traditional(text_simple)
    print(text_traditional)


================================================
FILE: uilib/zh_normalization/chronology.py
================================================
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re

from .num import DIGITS
from .num import num2str
from .num import verbalize_cardinal
from .num import verbalize_digit


def _time_num2str(num_string: str) -> str:
    """A special case for verbalizing number in time."""
    result = num2str(num_string.lstrip('0'))
    if num_string.startswith('0'):
        result = DIGITS['0'] + result
    return result


# 时刻表达式
RE_TIME = re.compile(r'([0-1]?[0-9]|2[0-3])'
                     r':([0-9][0-9]?)'
                     r'(:([0-9][0-9]?))?')

# 时间范围，如8:30-12:30
RE_TIME_RANGE = re.compile(r'([0-1]?[0-9]|2[0-3])'
                           r':([0-9][0-9]?)'
                           r'(:([0-9][0-9]?))?'
                           r'(~|-)'
                           r'([0-1]?[0-9]|2[0-3])'
                           r':([0-9][0-9]?)'
                           r'(:([0-9][0-9]?))?')


def replace_time(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """

    is_range = len(match.groups()) > 5

    hour = match.group(1)
    minute = match.group(2)
    second = match.group(4)

    if is_range:
        hour_2 = match.group(6)
        minute_2 = match.group(7)
        second_2 = match.group(9)

    result = f"{num2str(hour)}点"
    if minute.lstrip('0'):
        if int(minute) == 30:
            result += "半"
        else:
            result += f"{_time_num2str(minute)}分"
    if second and second.lstrip('0'):
        result += f"{_time_num2str(second)}秒"

    if is_range:
        result += "至"
        result += f"{num2str(hour_2)}点"
        if minute_2.lstrip('0'):
            if int(minute) == 30:
                result += "半"
            else:
                result += f"{_time_num2str(minute_2)}分"
        if second_2 and second_2.lstrip('0'):
            result += f"{_time_num2str(second_2)}秒"

    return result


RE_DATE = re.compile(r'(\d{4}|\d{2})年'
                     r'((0?[1-9]|1[0-2])月)?'
                     r'(((0?[1-9])|((1|2)[0-9])|30|31)([日号]))?')


def replace_date(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    year = match.group(1)
    month = match.group(3)
    day = match.group(5)
    result = ""
    if year:
        result += f"{verbalize_digit(year)}年"
    if month:
        result += f"{verbalize_cardinal(month)}月"
    if day:
        result += f"{verbalize_cardinal(day)}{match.group(9)}"
    return result


# 用 / 或者 - 分隔的 YY/MM/DD 或者 YY-MM-DD 日期
RE_DATE2 = re.compile(
    r'(\d{4})([- /.])(0?[1-9]|1[012])\2(0?[1-9]|[12][0-9]|3[01])')


def replace_date2(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    year = match.group(1)
    month = match.group(3)
    day = match.group(4)
    result = ""
    if year:
        result += f"{verbalize_digit(year)}年"
    if month:
        result += f"{verbalize_cardinal(month)}月"
    if day:
        result += f"{verbalize_cardinal(day)}日"
    return result


================================================
FILE: uilib/zh_normalization/constants.py
================================================
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
import string

#from pypinyin.constants import SUPPORT_UCS4

# 全角半角转换
# 英文字符全角 -> 半角映射表 (num: 52)
F2H_ASCII_LETTERS = {
    ord(char) + 65248: ord(char)
    for char in string.ascii_letters
}

# 英文字符半角 -> 全角映射表
H2F_ASCII_LETTERS = {value: key for key, value in F2H_ASCII_LETTERS.items()}

# 数字字符全角 -> 半角映射表 (num: 10)
F2H_DIGITS = {ord(char) + 65248: ord(char) for char in string.digits}
# 数字字符半角 -> 全角映射表
H2F_DIGITS = {value: key for key, value in F2H_DIGITS.items()}

# 标点符号全角 -> 半角映射表 (num: 32)
F2H_PUNCTUATIONS = {ord(char) + 65248: ord(char) for char in string.punctuation}
# 标点符号半角 -> 全角映射表
H2F_PUNCTUATIONS = {value: key for key, value in F2H_PUNCTUATIONS.items()}

# 空格 (num: 1)
F2H_SPACE = {'\u3000': ' '}
H2F_SPACE = {' ': '\u3000'}

# 非"有拼音的汉字"的字符串，可用于NSW提取
'''
if SUPPORT_UCS4:
    RE_NSW = re.compile(r'(?:[^'
                        r'\u3007'  # 〇
                        r'\u3400-\u4dbf'  # CJK扩展A:[3400-4DBF]
                        r'\u4e00-\u9fff'  # CJK基本:[4E00-9FFF]
                        r'\uf900-\ufaff'  # CJK兼容:[F900-FAFF]
                        r'\U00020000-\U0002A6DF'  # CJK扩展B:[20000-2A6DF]
                        r'\U0002A703-\U0002B73F'  # CJK扩展C:[2A700-2B73F]
                        r'\U0002B740-\U0002B81D'  # CJK扩展D:[2B740-2B81D]
                        r'\U0002F80A-\U0002FA1F'  # CJK兼容扩展:[2F800-2FA1F]
                        r'])+')
else:
'''
RE_NSW = re.compile(  # pragma: no cover
    r'(?:[^'
    r'\u3007'  # 〇
    r'\u3400-\u4dbf'  # CJK扩展A:[3400-4DBF]
    r'\u4e00-\u9fff'  # CJK基本:[4E00-9FFF]
    r'\uf900-\ufaff'  # CJK兼容:[F900-FAFF]
    r'])+')


================================================
FILE: uilib/zh_normalization/num.py
================================================
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Rules to verbalize numbers into Chinese characters.
https://zh.wikipedia.org/wiki/中文数字#現代中文
"""
import re
from collections import OrderedDict
from typing import List

DIGITS = {str(i): tran for i, tran in enumerate('零一二三四五六七八九')}
UNITS = OrderedDict({
    1: '十',
    2: '百',
    3: '千',
    4: '万',
    8: '亿',
})

COM_QUANTIFIERS = '(封|艘|把|目|套|段|人|所|朵|匹|张|座|回|场|尾|条|个|首|阙|阵|网|炮|顶|丘|棵|只|支|袭|辆|挑|担|颗|壳|窠|曲|墙|群|腔|砣|座|客|贯|扎|捆|刀|令|打|手|罗|坡|山|岭|江|溪|钟|队|单|双|对|出|口|头|脚|板|跳|枝|件|贴|针|线|管|名|位|身|堂|课|本|页|家|户|层|丝|毫|厘|分|钱|两|斤|担|铢|石|钧|锱|忽|(千|毫|微)克|毫|厘|(公)分|分|寸|尺|丈|里|寻|常|铺|程|(千|分|厘|毫|微)米|米|撮|勺|合|升|斗|石|盘|碗|碟|叠|桶|笼|盆|盒|杯|钟|斛|锅|簋|篮|盘|桶|罐|瓶|壶|卮|盏|箩|箱|煲|啖|袋|钵|年|月|日|季|刻|时|周|天|秒|分|小时|旬|纪|岁|世|更|夜|春|夏|秋|冬|代|伏|辈|丸|泡|粒|颗|幢|堆|条|根|支|道|面|片|张|颗|块|元|(亿|千万|百万|万|千|百)|(亿|千万|百万|万|千|百|美|)元|(亿|千万|百万|万|千|百|十|)吨|(亿|千万|百万|万|千|百|)块|角|毛|分)'

# 分数表达式
RE_FRAC = re.compile(r'(-?)(\d+)/(\d+)')


def replace_frac(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    sign = match.group(1)
    nominator = match.group(2)
    denominator = match.group(3)
    sign: str = "负" if sign else ""
    nominator: str = num2str(nominator)
    denominator: str = num2str(denominator)
    result = f"{sign}{denominator}分之{nominator}"
    return result


# 百分数表达式
RE_PERCENTAGE = re.compile(r'(-?)(\d+(\.\d+)?)%')


def replace_percentage(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    sign = match.group(1)
    percent = match.group(2)
    sign: str = "负" if sign else ""
    percent: str = num2str(percent)
    result = f"{sign}百分之{percent}"
    return result


# 整数表达式
# 带负号的整数 -10
RE_INTEGER = re.compile(r'(-)' r'(\d+)')


def replace_negative_num(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    sign = match.group(1)
    number = match.group(2)
    sign: str = "负" if sign else ""
    number: str = num2str(number)
    result = f"{sign}{number}"
    return result


# 编号-无符号整形
# 00078
RE_DEFAULT_NUM = re.compile(r'\d{3}\d*')


def replace_default_num(match):
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    number = match.group(0)
    return verbalize_digit(number, alt_one=False)


# 数字表达式
# 纯小数
RE_DECIMAL_NUM = re.compile(r'(-?)((\d+)(\.\d+))' r'|(\.(\d+))')
# 正整数 + 量词
RE_POSITIVE_QUANTIFIERS = re.compile(r"(\d+)([多余几\+])?" + COM_QUANTIFIERS)
RE_NUMBER = re.compile(r'(-?)((\d+)(\.\d+)?)' r'|(\.(\d+))')


def replace_positive_quantifier(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    number = match.group(1)
    match_2 = match.group(2)
    if match_2 == "+":
        match_2 = "多"
    match_2: str = match_2 if match_2 else ""
    quantifiers: str = match.group(3)
    number: str = num2str(number)
    result = f"{number}{match_2}{quantifiers}"
    return result


def replace_number(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    sign = match.group(1)
    number = match.group(2)
    pure_decimal = match.group(5)
    if pure_decimal:
        result = num2str(pure_decimal)
    else:
        sign: str = "负" if sign else ""
        number: str = num2str(number)
        result = f"{sign}{number}"
    return result


# 范围表达式
# match.group(1) and match.group(8) are copy from RE_NUMBER

RE_RANGE = re.compile(
    r'((-?)((\d+)(\.\d+)?)|(\.(\d+)))[-~]((-?)((\d+)(\.\d+)?)|(\.(\d+)))')


def replace_range(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    first, second = match.group(1), match.group(8)
    first = RE_NUMBER.sub(replace_number, first)
    second = RE_NUMBER.sub(replace_number, second)
    result = f"{first}到{second}"
    return result


def _get_value(value_string: str, use_zero: bool=True) -> List[str]:
    stripped = value_string.lstrip('0')
    if len(stripped) == 0:
        return []
    elif len(stripped) == 1:
        if use_zero and len(stripped) < len(value_string):
            return [DIGITS['0'], DIGITS[stripped]]
        else:
            return [DIGITS[stripped]]
    else:
        largest_unit = next(
            power for power in reversed(UNITS.keys()) if power < len(stripped))
        first_part = value_string[:-largest_unit]
        second_part = value_string[-largest_unit:]
        return _get_value(first_part) + [UNITS[largest_unit]] + _get_value(
            second_part)


def verbalize_cardinal(value_string: str) -> str:
    if not value_string:
        return ''

    # 000 -> '零' , 0 -> '零'
    value_string = value_string.lstrip('0')
    if len(value_string) == 0:
        return DIGITS['0']

    result_symbols = _get_value(value_string)
    # verbalized number starting with '一十*' is abbreviated as `十*`
    if len(result_symbols) >= 2 and result_symbols[0] == DIGITS[
            '1'] and result_symbols[1] == UNITS[1]:
        result_symbols = result_symbols[1:]
    return ''.join(result_symbols)


def verbalize_digit(value_string: str, alt_one=False) -> str:
    result_symbols = [DIGITS[digit] for digit in value_string]
    result = ''.join(result_symbols)
    if alt_one:
        result = result.replace("一", "幺")
    return result


def num2str(value_string: str) -> str:
    integer_decimal = value_string.split('.')
    if len(integer_decimal) == 1:
        integer = integer_decimal[0]
        decimal = ''
    elif len(integer_decimal) == 2:
        integer, decimal = integer_decimal
    else:
        raise ValueError(
            f"The value string: '${value_string}' has more than one point in it."
        )

    result = verbalize_cardinal(integer)

    decimal = decimal.rstrip('0')
    if decimal:
        # '.22' is verbalized as '零点二二'
        # '3.20' is verbalized as '三点二
        result = result if result else "零"
        result += '点' + verbalize_digit(decimal)
    return result


================================================
FILE: uilib/zh_normalization/phonecode.py
================================================
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re

from .num import verbalize_digit

# 规范化固话/手机号码
# 手机
# http://www.jihaoba.com/news/show/13680
# 移动：139、138、137、136、135、134、159、158、157、150、151、152、188、187、182、183、184、178、198
# 联通：130、131、132、156、155、186、185、176
# 电信：133、153、189、180、181、177
RE_MOBILE_PHONE = re.compile(
    r"(?<!\d)((\+?86 ?)?1([38]\d|5[0-35-9]|7[678]|9[89])\d{8})(?!\d)")
RE_TELEPHONE = re.compile(
    r"(?<!\d)((0(10|2[1-3]|[3-9]\d{2})-?)?[1-9]\d{7,8})(?!\d)")

# 全国统一的号码400开头
RE_NATIONAL_UNIFORM_NUMBER = re.compile(r"(400)(-)?\d{3}(-)?\d{4}")


def phone2str(phone_string: str, mobile=True) -> str:
    if mobile:
        sp_parts = phone_string.strip('+').split()
        result = '，'.join(
            [verbalize_digit(part, alt_one=True) for part in sp_parts])
        return result
    else:
        sil_parts = phone_string.split('-')
        result = '，'.join(
            [verbalize_digit(part, alt_one=True) for part in sil_parts])
        return result


def replace_phone(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    return phone2str(match.group(0), mobile=False)


def replace_mobile(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    return phone2str(match.group(0))


================================================
FILE: uilib/zh_normalization/quantifier.py
================================================
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re

from .num import num2str

# 温度表达式，温度会影响负号的读法
# -3°C 零下三度
RE_TEMPERATURE = re.compile(r'(-?)(\d+(\.\d+)?)(°C|℃|度|摄氏度)')
measure_dict = {
    "cm2": "平方厘米",
    "cm²": "平方厘米",
    "cm3": "立方厘米",
    "cm³": "立方厘米",
    "cm": "厘米",
    "db": "分贝",
    "ds": "毫秒",
    "kg": "千克",
    "km": "千米",
    "m2": "平方米",
    "m²": "平方米",
    "m³": "立方米",
    "m3": "立方米",
    "ml": "毫升",
    "m": "米",
    "mm": "毫米",
    "s": "秒"
}


def replace_temperature(match) -> str:
    """
    Args:
        match (re.Match)
    Returns:
        str
    """
    sign = match.group(1)
    temperature = match.group(2)
    unit = match.group(3)
    sign: str = "零下" if sign else ""
    temperature: str = num2str(temperature)
    unit: str = "摄氏度" if unit == "摄氏度" else "度"
    result = f"{sign}{temperature}{unit}"
    return result


def replace_measure(sentence) -> str:
    for q_notation in measure_dict:
        if q_notation in sentence and re.search(r'\d{q_notation}', sentence):
            sentence = sentence.replace(q_notation, measure_dict[q_notation])
    return sentence


================================================
FILE: uilib/zh_normalization/text_normlization.py
================================================
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from typing import List

from .char_convert import tranditional_to_simplified
from .chronology import RE_DATE
from .chronology import RE_DATE2
from .chronology import RE_TIME
from .chronology import RE_TIME_RANGE
from .chronology import replace_date
from .chronology import replace_date2
from .chronology import replace_time
from .constants import F2H_ASCII_LETTERS
from .constants import F2H_DIGITS
from .constants import F2H_SPACE
from .num import RE_DECIMAL_NUM
from .num import RE_DEFAULT_NUM
from .num import RE_FRAC
from .num import RE_INTEGER
from .num import RE_NUMBER
from .num import RE_PERCENTAGE
from .num import RE_POSITIVE_QUANTIFIERS
from .num import RE_RANGE
from .num import replace_default_num
from .num import replace_frac
from .num import replace_negative_num
from .num import replace_number
from .num import replace_percentage
from .num import replace_positive_quantifier
from .num import replace_range
from .phonecode import RE_MOBILE_PHONE
from .phonecode import RE_NATIONAL_UNIFORM_NUMBER
from .phonecode import RE_TELEPHONE
from .phonecode import replace_mobile
from .phonecode import replace_phone
from .quantifier import RE_TEMPERATURE
from .quantifier import replace_measure
from .quantifier import replace_temperature


class TextNormalizer():
    def __init__(self):
        self.SENTENCE_SPLITOR = re.compile(r'([：、，；。？！,;?!][”’]?)')

    def _split(self, text: str, lang="zh") -> List[str]:
        """Split long text into sentences with sentence-splitting punctuations.
        Args:
            text (str): The input text.
        Returns:
            List[str]: Sentences.

            character_map = {
    "：": "，",
    "；": "，",
    "！": "。",
    "（": "，",
    "）": "，",
    "【": "，",
    "】": "，",
    "『": "，",
    "』": "，",
    "「": "，",
    "」": "，",
    "《": "，",
    "》": "，",
    "－": "，",
    "‘": " ",
    "“": " ",
    "’": " ",
    "”": " ",
    '"': " ",
    "'": " ",
    ":": ",",
    ";": ",",
    "!": ".",
    "(": ",",
    ")": ",",
    "[": ",",
    "]": ",",
    ">": ",",
    "<": ",",
    "-": ",",
}
        """
        # Only for pure Chinese here
        if lang == "zh":
            #text = text.replace(" ", "")
            # 过滤掉特殊字符
            text = re.sub(r'[——《》【】<>{}()（）#&@“”^|…\\]', '', text)
        text = self.SENTENCE_SPLITOR.sub(r'\1\n', text)
        text = text.strip()
        sentences = [sentence.strip() for sentence in re.split(r'\n+', text)]
        return sentences

    def _post_replace(self, sentence: str) -> str:


        #sentence = sentence.replace('/', '每')
        sentence = sentence.replace('~', '至')
        sentence = sentence.replace('～', '至')
        sentence = sentence.replace('①', '一')
        sentence = sentence.replace('②', '二')
        sentence = sentence.replace('③', '三')
        sentence = sentence.replace('④', '四')
        sentence = sentence.replace('⑤', '五')
        sentence = sentence.replace('⑥', '六')
        sentence = sentence.replace('⑦', '七')
        sentence = sentence.replace('⑧', '八')
        sentence = sentence.replace('⑨', '九')
        sentence = sentence.replace('⑩', '十')
        sentence = sentence.replace('α', '阿尔法')
        sentence = sentence.replace('β', '贝塔')
        sentence = sentence.replace('γ', '伽玛').replace('Γ', '伽玛')
        sentence = sentence.replace('δ', '德尔塔').replace('Δ', '德尔塔')
        sentence = sentence.replace('ε', '艾普西龙')
        sentence = sentence.replace('ζ', '捷塔')
        sentence = sentence.replace('η', '依塔')
        sentence = sentence.replace('θ', '西塔').replace('Θ', '西塔')
        sentence = sentence.replace('ι', '艾欧塔')
        sentence = sentence.replace('κ', '喀帕')
        sentence = sentence.replace('λ', '拉姆达').replace('Λ', '拉姆达')
        sentence = sentence.replace('μ', '缪')
        sentence = sentence.replace('ν', '拗')
        sentence = sentence.replace('ξ', '克西').replace('Ξ', '克西')
        sentence = sentence.replace('ο', '欧米克伦')
        sentence = sentence.replace('π', '派').replace('Π', '派')
        sentence = sentence.replace('ρ', '肉')
        sentence = sentence.replace('ς', '西格玛').replace('Σ', '西格玛').replace(
            'σ', '西格玛')
        sentence = sentence.replace('τ', '套')
        sentence = sentence.replace('υ', '宇普西龙')
        sentence = sentence.replace('φ', '服艾').replace('Φ', '服艾')
        sentence = sentence.replace('χ', '器')
        sentence = sentence.replace('ψ', '普赛').replace('Ψ', '普赛')
        sentence = sentence.replace('ω', '欧米伽').replace('Ω', '欧米伽')
        sentence = sentence.replace('+', '加')


        # re filter special characters, have one more character "-" than line 68
        sentence = re.sub(r'[-——《》【】<=>{}()（）#&@“”^|…\\]', '', sentence)
        return sentence

    # 数字转为中文读法
    def num_to_chinese(self,num):
        num_str = str(num)
        chinese_digits = "零一二三四五六七八九"
        units = ["", "十", "百", "千"]
        big_units = ["", "万", "亿", "兆"]
        result = ""
        zero_flag = False  # 标记是否需要加'零'
        part = []  # 存储每4位的数字

        # 将数字按每4位分组
        while num_str:
            part.append(num_str[-4:])
            num_str = num_str[:-4]

        for i in range(len(part)):
            part_str = ""
            part_zero_flag = False
            for j in range(len(part[i])):
                digit = int(part[i][j])
                if digit == 0:
                    part_zero_flag = True
                else:
                    if part_zero_flag or (zero_flag and i > 0 and not result.startswith(chinese_digits[0])):
                        part_str += chinese_digits[0]
                        zero_flag = False
                        part_zero_flag = False
                    part_str += chinese_digits[digit] + units[len(part[i]) - j - 1]
            if part_str.endswith("零"):
                part_str = part_str[:-1]  # 去除尾部的'零'
            if part_str:
                zero_flag = True

            if i > 0 and not set(part[i]) <= {'0'}:  # 如果当前部分不全是0，则加上相应的大单位
                result = part_str + big_units[i] + result
            else:
                result = part_str + result

        # 处理输入为0的情况或者去掉开头的零
        result = result.lstrip(chinese_digits[0])
        if not result:
            return chinese_digits[0]

        return result

    def normalize_sentence(self, sentence: str) -> str:

        # basic character conversions
        # add
        sentence = re.sub(r'(\d+)\s*[\*xX]\s*(\d+)', r'\1 乘 \2', sentence,re.I)
        # 区号 电话 分机
        sentence = re.sub(r'(0\d+)\-(\d{3,})\-(\d{3,})', r'\1杠\2杠\3', sentence,re.I)
        sentence = re.sub(r'(0\d+)\-(\d{3,})', r'\1杠\2', sentence,re.I)
        sentence = sentence.replace('=', '等于')
        sentence = sentence.replace('÷','除以')

        #sentence = re.sub(r'(\d+)\s*\-', r'\1 减', sentence)
        sentence = re.sub(r'((?:\d+\.)?\d+)\s*/\s*(\d+)', r'\2分之\1', sentence)

        # 取出数字 number_list= [('1000200030004000.123', '1000200030004000', '123'), ('23425', '23425', '')]
        number_list=re.findall(r'((\d+)(?:\.(\d+))?%?)', sentence)
        numtext=['零','一','二','三','四','五','六','七','八','九']
        if len(number_list)>0:
            #dc= ('1000200030004000.123', '1000200030004000', '123','')
            for m,dc in enumerate(number_list):
                n_len=len(dc[1])
                #手机号/座机号 超大数 亿内的数 0开头的数，不做处理
                if n_len>16 or n_len<9 or (n_len==11 and str(dc[1])[0]=='1') or str(dc[1])[0]=='0':
                    continue
                int_text=self.num_to_chinese(dc[1])
                if len(dc)>2 and dc[2]:
                    int_text+="点"+"".join([numtext[int(i)] for i in dc[2]])
                if dc[0][-1]=='%':
                    int_text=f'百分之{int_text}'
                sentence=sentence.replace(dc[0],int_text)

        sentence = tranditional_to_simplified(sentence)
        sentence = sentence.translate(F2H_ASCII_LETTERS).translate(
            F2H_DIGITS).translate(F2H_SPACE)

        # number related NSW verbalization
        sentence = RE_DATE.sub(replace_date, sentence)
        sentence = RE_DATE2.sub(replace_date2, sentence)

        # range first
        sentence = RE_TIME_RANGE.sub(replace_time, sentence)
        sentence = RE_TIME.sub(replace_time, sentence)

        sentence = RE_TEMPERATURE.sub(replace_temperature, sentence)
        sentence = replace_measure(sentence)
        sentence = RE_FRAC.sub(replace_frac, sentence)
        sentence = RE_PERCENTAGE.sub(replace_percentage, sentence)
        sentence = RE_MOBILE_PHONE.sub(replace_mobile, sentence)

        sentence = RE_TELEPHONE.sub(replace_phone, sentence)
        sentence = RE_NATIONAL_UNIFORM_NUMBER.sub(replace_phone, sentence)

        sentence = RE_RANGE.sub(replace_range, sentence)
        sentence = RE_INTEGER.sub(replace_negative_num, sentence)
        sentence = RE_DECIMAL_NUM.sub(replace_number, sentence)
        sentence = RE_POSITIVE_QUANTIFIERS.sub(replace_positive_quantifier,
                                               sentence)
        sentence = RE_DEFAULT_NUM.sub(replace_default_num, sentence)
        sentence = RE_NUMBER.sub(replace_number, sentence)
        sentence = self._post_replace(sentence)

        sentence = sentence.replace('[一break]','[1break]')

        return sentence

    def normalize(self, text: str) -> List[str]:
        sentences = self._split(text)
        sentences = [self.normalize_sentence(sent) for sent in sentences]
        return sentences