Upload folder using huggingface_hub

snapshots/anifilebert-dapt512-long/README.md

@@ -0,0 +1,298 @@
+---
+license: apache-2.0
+library_name: transformers
+pipeline_tag: token-classification
+tags:
+  - anime
+  - filename-parsing
+  - bert
+  - token-classification
+  - onnx
+datasets:
+  - ModerRAS/AnimeName
+language:
+  - en
+  - ja
+  - zh
+model-index:
+  - name: AniFileBERT
+    results:
+      - task:
+          type: token-classification
+          name: Anime filename token classification
+        dataset:
+          name: AniFileBERT fixed parser regression cases
+          type: parser-regression
+        metrics:
+          - type: accuracy
+            name: Fixed parser model-only full-match accuracy
+            value: 1.0
+          - type: accuracy
+            name: Fixed parser thin-runtime full-match accuracy
+            value: 1.0
+---
+
+# AniFileBERT
+
+**中文**：AniFileBERT 是一个面向番剧发布文件名的轻量级 BERT token-classification 解析器。它把常见发布名解析为结构化字段：字幕组、标题、季、集数、分辨率、来源和 special tag。
+
+**English**: AniFileBERT is a lightweight BERT token-classification parser for anime release filenames. It extracts structured fields: release group, title, season, episode, resolution, source, and special tags.
+
+This repository is the Hugging Face model repo used by MiruPlay as `tools/anime_parser`.
+
+## Model Details / 模型信息
+
+| Item | Value |
+| --- | --- |
+| Architecture / 架构 | `BertForTokenClassification` |
+| Tokenizer / 分词器 | Custom character tokenizer in `anifilebert/tokenizer.py` |
+| Parameters / 参数量 | 4,783,631 |
+| Hidden size / 隐层维度 | 256 |
+| Layers / 层数 | 4 |
+| Attention heads / 注意力头 | 8 |
+| Max sequence length / 最大长度 | 128 |
+| Labels / 标签 | 37 BIO labels, schema v2: language-aware `TITLE_*`, path-aware `PATH_TITLE_*`/`PATH_SEASON`, plus `EPISODE`, `GROUP`, `RESOLUTION`, `SOURCE`, `SPECIAL`, `TAG` |
+| Default checkpoint / 默认权重 | Repository root files (`config.json`, `model.safetensors`, `vocab.json`, `tokenizer_config.json`) |
+| ONNX export / ONNX 导出 | `exports/anime_filename_parser.onnx` |
+| Training lineage / 训练链路 | `reports/training_lineage.json` |
+
+**中文**：根目录就是发布 checkpoint，不再保留旧的 `model/` 重复副本。默认解析路径是“模型 logits + 约束 BIO + 薄字段规范化”，不再默认启用重结构规则；直接 `from_pretrained()` 只能加载 token-classification 权重。
+
+**English**: The repository root is the published checkpoint. The default parser is model logits + constrained BIO + thin field normalization; heavy structural assist is not enabled by default. `from_pretrained()` only loads token-classification weights.
+
+## Intended Use / 使用场景
+
+**中文**
+
+- 解析番剧/动画发布文件名，用于媒体库刮削、归类、搜索和展示。
+- 覆盖常见结构：`[GROUP] TITLE - EP [META]`、点分隔 `S01E07`、国漫多括号标题、BD 特典 `NCOP/NCED/IV05`、长集数、第二季别名等。
+- 不适合泛化为自然语言 NER；这是结构化文件名解析任务。
+
+**English**
+
+- Parse anime release filenames for media library scraping, classification, search, and display.
+- Covers common layouts: `[GROUP] TITLE - EP [META]`, dotted `S01E07`, Chinese animation bracket layouts, BD extras such as `NCOP/NCED/IV05`, long-running episode numbers, and season aliases.
+- This is not a general natural-language NER model; it is a structured filename parser.
+
+## Install / 安装
+
+```powershell
+uv sync
+```
+
+If the dataset submodule is missing:
+
+```powershell
+git submodule update --init --recursive
+```
+
+## Quick Start / 快速使用
+
+Run the Python parser:
+
+```powershell
+uv run python -m anifilebert.inference --model-dir . "[GM-Team][国漫][神印王座][Throne of Seal][2022][200][AVC][GB][1080P].mp4"
+```
+
+Expected output:
+
+```json
+{"title":"神印王座","season":null,"episode":200,"group":"GM-Team","resolution":"1080P","source":"GB","special":null}
+```
+
+Load the raw Transformers model:
+
+```python
+from transformers import BertForTokenClassification
+
+model = BertForTokenClassification.from_pretrained("ModerRAS/AniFileBERT")
+```
+
+**中文**：如果需要完整字段解析，请 clone 本仓库并使用 `python -m anifilebert.inference`，因为分词器和后处理是自定义的。
+
+**English**: For complete field parsing, clone this repo and use `python -m anifilebert.inference`; the tokenizer and postprocessing are custom.
+
+## ONNX Usage / ONNX 使用
+
+The ONNX graph outputs token logits only. A complete parser still needs:
+
+1. custom character tokenization,
+2. constrained BIO decoding,
+3. field aggregation and thin string/number normalization.
+
+本仓库提供最小可运行示例：
+
+```powershell
+uv run python -m tools.onnx_inference "[YYDM&VCB-Studio] Shinsekai Yori [NCED02][Ma10p_1080p][x265_flac].mkv"
+```
+
+Static graph shapes:
+
+- `input_ids`: `int64[1,128]`
+- `attention_mask`: `int64[1,128]`
+- `logits`: `float32[1,128,37]`
+
+More details: [`docs/onnx.md`](docs/onnx.md) and [`docs/android.md`](docs/android.md).
+
+## Evaluation / 评估
+
+Current published checkpoint:
+
+| Metric / 指标 | Value / 数值 |
+| --- | --- |
+| Fixed regression, model-only / 固定回归，纯模型聚合 | 28/28 full match = `100%` |
+| Fixed regression, default thin runtime / 固定回归，默认薄层运行时 | 28/28 full match = `100%` |
+| Held-out parse, model-only / held-out 解析，纯模型聚合 | 2046/2048 full match = `99.90%` |
+| Held-out parse, default thin runtime / held-out 解析，默认薄层运行时 | 2046/2048 full match = `99.90%` |
+| Token/entity eval / token/entity 评估 | F1 `0.9999`, token accuracy `0.99996` |
+| ONNX parity / ONNX 误差 | max abs diff `4.8637e-05` |
+| CPU thin-runtime latency / CPU 薄层运行时延迟 | ONNX avg `12.18 ms`, P95 `14.45 ms` |
+
+**中文**：当前发布模型是 37 维 schema v2 字符级模型，最终权重来自 repaired hard-focus encoded-cache 训练；细节见 `reports/training_lineage.json`。README 主指标以 `model-only` 和默认薄层 `normalized-only` 为准；旧版结构规则辅助层已移除，不再作为运行时或质量对照。
+
+**English**: The published checkpoint is a 37-label schema v2 character-tokenizer model, finished with a repaired hard-focus encoded-cache training run. See `reports/training_lineage.json` for details. README quality numbers prioritize `model-only` and the default thin `normalized-only` runtime; structural filename assists have been removed from the runtime and quality reports.
+
+Run regression:
+
+```powershell
+uv run python -m tools.evaluate_parser_cases --model-dir . --case-file data/parser_regression_cases.json --output reports/case_metrics.json
+```
+
+## Performance / 性能
+
+Benchmark command:
+
+性能测试命令：
+
+```powershell
+uv run python -m tools.benchmark_inference --model-dir . --onnx exports/anime_filename_parser.onnx --case-file data/parser_regression_cases.json --repeat 20 --warmup 20 --torch-threads 1 --ort-threads 1 --output reports/benchmark_results.json
+```
+
+Recorded local CPU benchmark on the 28-case fixed regression set,
+single-threaded, using the default thin runtime: tokenization, model/session
+forward, constrained BIO decoding, entity aggregation, and light string/number
+normalization:
+
+记录中的本地 CPU 单线程 benchmark 使用 28 条固定回归 case，默认薄层运行时，
+包含 tokenizer、模型/session 前向、约束 BIO 解码、实体聚合和轻量字符串/数字规范化：
+
+| Backend / 后端 | Load ms / 加载 ms | Avg ms / 平均 ms | P50 ms | P95 ms | P99 ms | files/s |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| PyTorch | 44.04 | 13.50 | 13.05 | 17.36 | 21.38 | 74.1 |
+| ONNX Runtime | 45.64 | 12.18 | 11.97 | 14.45 | 15.96 | 82.1 |
+
+**中文**：这是完整薄层 parser 的端到端延迟，不是只测模型 forward。移动端实现应复用 ONNX session，并保持 tokenizer/BIO/薄规范化逻辑一致。
+
+**English**: This is end-to-end thin-parser latency, not model-forward-only timing. Mobile code should keep the ONNX session reusable and keep tokenizer/BIO/thin-normalization behavior aligned.
+
+## Training / 训练
+
+Training uses the dataset submodule at `datasets/AnimeName`.
+
+Current release training uses schema v2 JSONL plus a Rust pre-encoded cache on
+the Windows RTX 5070 Ti worker.
+
+The hard-focus JSONL and encoded-cache paths under `data/` are generated local
+artifacts and are intentionally ignored; regenerate them from the authoritative
+dataset and schema before rerunning this exact training command.
+
+```powershell
+.\.venv\Scripts\python.exe -m anifilebert.train --tokenizer char `
+  --data-file data/schema_v2_hard_focus_char_seed63.jsonl `
+  --vocab-file datasets/AnimeName/vocab.char.json `
+  --encoded-cache-dir data/encoded_cache/schema_v2_hard_focus_char_seed63_split995_repaired_v2 `
+  --save-dir checkpoints/ablation-schema-v2-hardfocus-cache-repaired-from-baseline-seed62-10epoch-rerun `
+  --init-model-dir checkpoints/ablation-schema-v2-baseline8h4l-cache-10epoch-seed62/final `
+  --epochs 10 `
+  --batch-size 512 `
+  --learning-rate 0.00004 `
+  --warmup-steps 120 `
+  --max-seq-length 128 `
+  --train-split 0.995 `
+  --checkpoint-steps 1000 `
+  --save-total-limit 3 `
+  --parse-eval-limit 2048 `
+  --case-eval-file data/parser_regression_cases.json `
+  --bf16 `
+  --no-periodic-eval `
+  --perf-log-steps 100 `
+  --perf-sample-interval 1.0 `
+  --seed 63 `
+  --experiment-name ablation-schema-v2-hardfocus-cache-repaired-from-baseline-seed62-10epoch-rerun
+```
+
+Build or rebuild encoded caches with `tools/encoded_dataset_cache` after changing
+the JSONL, vocab, label schema, max length, split ratio, or seed. See
+[`docs/training.md`](docs/training.md) for the full cache-first flow and
+synthetic augmentation follow-ups.
+
+`python -m anifilebert.train` writes:
+
+- Hugging Face checkpoints under `--save-dir`,
+- `final/run_metadata.json`,
+- `final/trainer_eval_metrics.json`,
+- `final/parse_eval_metrics.json`,
+- `final/case_metrics.json` unless `--no-case-eval` is used,
+- `final/perf_metrics.json` when `--perf-log-steps` is set,
+- TensorBoard logs unless `--no-tensorboard` is used.
+
+Full workflow: [`docs/training.md`](docs/training.md).
+
+## Dataset / 数据集
+
+Authoritative dataset snapshot:
+
+```text
+datasets/AnimeName/dmhy_weak.jsonl
+datasets/AnimeName/dmhy_weak_char.jsonl
+datasets/AnimeName/vocab.json
+datasets/AnimeName/vocab.char.json
+```
+
+Current snapshot:
+
+- rows / 行数: `759738`
+- failed relabel rows / 重标注失败行: `0`
+- strict BIO violations / 严格 BIO 违规: `0`
+- character vocab / 字符词表: `6199`
+- character coverage / 字符覆盖率: `99.9952%` with the published 6199-token char vocab
+
+**中文**：`datasets/AnimeName` 是嵌套数据集仓库。更新数据后需要先提交/推送子仓库，再提交父仓库的 submodule pointer。
+
+**English**: `datasets/AnimeName` is a nested dataset repository. Commit and push the dataset repo first, then commit the updated submodule pointer in this model repo.
+
+## Repository Layout / 仓库结构
+
+```text
+config.json
+model.safetensors
+tokenizer_config.json
+vocab.json
+training_args.bin
+anifilebert/
+tools/
+data/parser_regression_cases.json
+datasets/AnimeName/
+exports/anime_filename_parser.onnx
+docs/
+reports/
+```
+
+## Maintenance / 维护
+
+See [`docs/maintenance.md`](docs/maintenance.md) for release steps, LFS order, dataset submodule updates, and MiruPlay integration notes.
+
+## Limitations / 局限
+
+**中文**
+
+- 发布命名没有统一标准，极端 OCR 噪声、乱码、非动画命名仍可能失败。
+- ONNX 只包含模型 logits，不包含 tokenizer、BIO decode 和薄字段规范化；移动端必须保持 tokenizer/vocab/config 一致。
+- `source` 当前是单值字段，复杂文件名里可能同时存在平台、发布源、编码器和语言标签。
+
+**English**
+
+- Anime release names are not standardized; extreme OCR noise, mojibake, or non-anime names can still fail.
+- ONNX contains logits only. Mobile runtimes must keep tokenizer, vocabulary, config, BIO decode, and thin normalization in sync.
+- `source` is currently a single field, while real filenames may contain platform, release source, codec, and language tags together.
+

snapshots/anifilebert-dapt512-long/anifilebert/__init__.py

@@ -0,0 +1,2 @@
+"""AniFileBERT parser package."""
+

snapshots/anifilebert-dapt512-long/anifilebert/config.py

@@ -0,0 +1,70 @@
+"""
+Configuration parameters for the anime filename parser pipeline.
+All hyperparameters are centralized here for easy tuning.
+"""
+
+
+from dataclasses import dataclass
+
+from .labels import LABEL_SCHEMA_VERSION, make_id2label, make_label2id
+
+
+@dataclass
+class Config:
+    """Central configuration dataclass for all pipeline parameters."""
+
+    # Data
+    synthetic_data_size: int = 100_000
+    train_split: float = 0.9
+    data_file: str = "data/synthetic.jsonl"
+
+    # Model architecture
+    hidden_size: int = 256
+    num_hidden_layers: int = 4
+    num_attention_heads: int = 8
+    intermediate_size: int = 1024
+    max_position_embeddings: int = 128
+    hidden_dropout_prob: float = 0.1
+    attention_probs_dropout_prob: float = 0.1
+
+    # Training hyperparameters
+    batch_size: int = 64
+    learning_rate: float = 1e-3
+    num_epochs: int = 8
+    weight_decay: float = 0.01
+    warmup_steps: int = 500
+
+    # System
+    device: str = "cpu"
+    num_workers: int = 4
+    save_dir: str = "./checkpoints"
+    log_interval: int = 100
+
+    # Sequence
+    max_seq_length: int = 64
+
+    # Vocabulary (set dynamically from tokenizer)
+    vocab_size: int = 8000  # placeholder, overridden after tokenizer vocab is built
+
+    # Special tokens
+    pad_token: str = "[PAD]"
+    unk_token: str = "[UNK]"
+    cls_token: str = "[CLS]"
+    sep_token: str = "[SEP]"
+
+    # BIO label scheme
+    label_schema_version: int = LABEL_SCHEMA_VERSION
+    label2id: dict = None
+    id2label: dict = None
+
+    def __post_init__(self):
+        using_default_labels = self.label2id is None
+        if self.label2id is None:
+            self.label2id = make_label2id()
+        if self.id2label is None:
+            self.id2label = make_id2label() if using_default_labels else {v: k for k, v in self.label2id.items()}
+
+    @property
+    def num_labels(self) -> int:
+        return len(self.label2id)
+

snapshots/anifilebert-dapt512-long/anifilebert/dataset.py

@@ -0,0 +1,466 @@
+"""
+PyTorch Dataset for anime filename token classification.
+
+Loads JSONL data (tokens + BIO labels) and converts to model inputs.
+Handles token-ID conversion, label encoding, padding, and truncation.
+"""
+
+import json
+from collections import Counter
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .config import Config
+from .label_repairs import repair_sequel_season_labels
+from .labels import canonical_bio_label
+from .tokenizer import AnimeTokenizer
+
+
+def encode_token_classification_values(
+    item: Dict,
+    tokenizer: AnimeTokenizer,
+    label2id: Dict[str, int],
+    max_length: int,
+    apply_label_repairs: bool = True,
+    vocab: Optional[Dict[str, int]] = None,
+) -> Tuple[List[int], List[bool], List[int]]:
+    tokens, labels = training_labels_for_tokenizer(item, tokenizer, apply_label_repairs)
+
+    token_vocab = vocab if vocab is not None else tokenizer.get_vocab()
+    unk_id = tokenizer.unk_token_id if tokenizer.unk_token_id is not None else 1
+    input_ids = [token_vocab.get(token, unk_id) for token in tokens]
+    input_ids = [tokenizer.cls_token_id] + input_ids + [tokenizer.sep_token_id]
+
+    label_ids: List[int] = [-100]
+    label_ids.extend(label2id.get(canonical_bio_label(str(label)), 0) for label in labels)
+    label_ids.append(-100)
+
+    attention_mask = [1] * len(input_ids)
+
+    if len(input_ids) > max_length:
+        input_ids = [input_ids[0]] + input_ids[1:max_length - 1] + [input_ids[-1]]
+        label_ids = [label_ids[0]] + label_ids[1:max_length - 1] + [label_ids[-1]]
+        attention_mask = [attention_mask[0]] + attention_mask[1:max_length - 1] + [attention_mask[-1]]
+
+    pad_len = max_length - len(input_ids)
+    if pad_len > 0:
+        input_ids += [tokenizer.pad_token_id] * pad_len
+        label_ids += [-100] * pad_len
+        attention_mask += [0] * pad_len
+
+    return input_ids, [bool(value) for value in attention_mask], label_ids
+
+
+def encode_token_classification_item(
+    item: Dict,
+    tokenizer: AnimeTokenizer,
+    label2id: Dict[str, int],
+    max_length: int,
+    apply_label_repairs: bool = True,
+    vocab: Optional[Dict[str, int]] = None,
+) -> Dict[str, torch.Tensor]:
+    input_ids, attention_mask, label_ids = encode_token_classification_values(
+        item,
+        tokenizer,
+        label2id,
+        max_length,
+        apply_label_repairs,
+        vocab,
+    )
+
+    return {
+        "input_ids": torch.tensor(input_ids, dtype=torch.long),
+        "attention_mask": torch.tensor(attention_mask, dtype=torch.bool),
+        "labels": torch.tensor(label_ids, dtype=torch.long),
+    }
+
+
+class AnimeItemsDataset(Dataset):
+    """Map-style dataset backed by already-loaded JSONL items."""
+
+    def __init__(
+        self,
+        data: Sequence[Dict],
+        tokenizer: AnimeTokenizer,
+        label2id: Dict[str, int],
+        max_length: int = 64,
+        apply_label_repairs: bool = True,
+    ):
+        self.data = data
+        self.tokenizer = tokenizer
+        self.label2id = label2id
+        self.max_length = max_length
+        self.apply_label_repairs = apply_label_repairs
+        self.vocab = tokenizer.get_vocab()
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        return encode_token_classification_item(
+            self.data[idx],
+            self.tokenizer,
+            self.label2id,
+            self.max_length,
+            self.apply_label_repairs,
+            self.vocab,
+        )
+
+
+class EncodedAnimeDataset(Dataset):
+    """Dataset that stores padded tensors so training workers do no token work."""
+
+    def __init__(
+        self,
+        data: Sequence[Dict],
+        tokenizer: AnimeTokenizer,
+        label2id: Dict[str, int],
+        max_length: int = 64,
+        device: Optional[torch.device] = None,
+        apply_label_repairs: bool = True,
+    ):
+        target_device = device or torch.device("cpu")
+        vocab = tokenizer.get_vocab()
+        input_ids = np.full(
+            (len(data), max_length),
+            tokenizer.pad_token_id,
+            dtype=np.int64,
+        )
+        attention_mask = np.zeros((len(data), max_length), dtype=np.bool_)
+        labels = np.full((len(data), max_length), -100, dtype=np.int64)
+
+        for idx, item in enumerate(data):
+            item_input_ids, item_attention_mask, item_labels = encode_token_classification_values(
+                item,
+                tokenizer,
+                label2id,
+                max_length,
+                apply_label_repairs,
+                vocab,
+            )
+            input_ids[idx] = item_input_ids
+            attention_mask[idx] = item_attention_mask
+            labels[idx] = item_labels
+
+        self.input_ids = torch.from_numpy(input_ids).to(target_device)
+        self.attention_mask = torch.from_numpy(attention_mask).to(target_device)
+        self.labels = torch.from_numpy(labels).to(target_device)
+
+    def __len__(self) -> int:
+        return self.input_ids.shape[0]
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        return {
+            "input_ids": self.input_ids[idx],
+            "attention_mask": self.attention_mask[idx],
+            "labels": self.labels[idx],
+        }
+
+
+class AnimeDataset(AnimeItemsDataset):
+    """
+    Dataset for anime filename token classification.
+
+    Loads pre-tokenized data from JSONL files and prepares model inputs.
+    Each sample has:
+        - input_ids: token IDs with [CLS] prefix and [SEP] suffix
+        - attention_mask: 1 for real tokens, 0 for padding
+        - labels: integer label IDs, -100 for special/padding tokens
+    """
+
+    def __init__(
+        self,
+        data_path: str,
+        tokenizer: AnimeTokenizer,
+        label2id: Dict[str, int],
+        max_length: int = 64,
+    ):
+        """
+        Args:
+            data_path: Path to JSONL file with tokens and labels.
+            tokenizer: AnimeTokenizer instance.
+            label2id: Mapping from label string to integer ID.
+            max_length: Maximum sequence length (including special tokens).
+        """
+        data: List[Dict] = []
+        with open(data_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    data.append(json.loads(line))
+        super().__init__(data, tokenizer, label2id, max_length)
+
+
+def align_tokens_for_tokenizer(
+    tokens: List[str],
+    labels: List[str],
+    tokenizer: AnimeTokenizer,
+) -> tuple[List[str], List[str]]:
+    """
+    Align pre-labeled JSONL samples to the selected tokenizer.
+
+    The existing datasets store regex-tokenized samples. For the char A/B run,
+    each original token is split into characters while preserving BIO spans:
+    B-X stays on the first character, and the rest become I-X.
+    """
+    if getattr(tokenizer, "tokenizer_variant", "regex") != "char":
+        return tokens, labels
+
+    aligned_tokens: List[str] = []
+    aligned_labels: List[str] = []
+
+    for token, label in zip(tokens, labels):
+        pieces = tokenizer.tokenize(token)
+        if not pieces:
+            continue
+
+        aligned_tokens.extend(pieces)
+        aligned_labels.append(label)
+
+        if label.startswith(("B-", "I-")):
+            continuation = "I-" + label.split("-", 1)[1]
+        else:
+            continuation = label
+        aligned_labels.extend([continuation] * (len(pieces) - 1))
+
+    return aligned_tokens, aligned_labels
+
+
+def labels_for_tokenizer(
+    item: Dict,
+    tokenizer: AnimeTokenizer,
+) -> Tuple[List[str], List[str]]:
+    """
+    Return tokens and labels in the exact tokenizer space used by the model.
+
+    Older DMHY weak-label files store a post-processed token sequence where
+    group/title brackets may be expanded even though AnimeTokenizer keeps the
+    same bracketed text as one inference token. If the raw filename is present,
+    project those weak labels back to character spans and then onto the current
+    tokenizer output. This keeps train/eval/inference preprocessing identical.
+    """
+    filename = item.get("filename")
+    source_tokens, source_labels, _repairs = repair_sequel_season_labels(item)
+    tokenizer_variant = getattr(tokenizer, "tokenizer_variant", "regex")
+
+    if not filename:
+        return align_tokens_for_tokenizer(source_tokens, source_labels, tokenizer)
+
+    # Current char datasets are already in the exact inference token space.
+    # Avoid re-scanning every filename during training.
+    if item.get("tokenizer_variant") == tokenizer_variant:
+        target_tokens = tokenizer.tokenize(filename)
+        if source_tokens == target_tokens:
+            return source_tokens, source_labels
+
+    projected = project_labels_from_filename(
+        filename=filename,
+        source_tokens=source_tokens,
+        source_labels=source_labels,
+        tokenizer=tokenizer,
+    )
+    if projected is not None:
+        return projected
+
+    # Fall back to the legacy behavior for synthetic fixtures or malformed rows.
+    return align_tokens_for_tokenizer(source_tokens, source_labels, tokenizer)
+
+
+def training_labels_for_tokenizer(
+    item: Dict,
+    tokenizer: AnimeTokenizer,
+    apply_label_repairs: bool,
+) -> Tuple[List[str], List[str]]:
+    """Fast path for authoritative char JSONL rows used in full training."""
+    tokenizer_variant = getattr(tokenizer, "tokenizer_variant", "regex")
+    if not apply_label_repairs and item.get("tokenizer_variant") == tokenizer_variant:
+        tokens = item.get("tokens", [])
+        labels = item.get("labels", [])
+        filename = item.get("filename")
+        if len(tokens) == len(labels):
+            if tokenizer_variant != "char" or filename is None or tokens == list(str(filename)):
+                return tokens, labels
+    return labels_for_tokenizer(item, tokenizer)
+
+
+def token_offsets_in_text(text: str, tokens: List[str]) -> Optional[List[Tuple[int, int]]]:
+    """Find token character offsets by scanning left to right."""
+    offsets: List[Tuple[int, int]] = []
+    cursor = 0
+    for token in tokens:
+        if token == "":
+            offsets.append((cursor, cursor))
+            continue
+        start = text.find(token, cursor)
+        if start < 0:
+            return None
+        end = start + len(token)
+        offsets.append((start, end))
+        cursor = end
+    return offsets
+
+
+def project_source_labels_to_chars(
+    text: str,
+    source_tokens: List[str],
+    source_labels: List[str],
+) -> Optional[List[str]]:
+    """Project source token BIO labels to per-character entity names."""
+    offsets = token_offsets_in_text(text, source_tokens)
+    if offsets is None or len(source_tokens) != len(source_labels):
+        return None
+
+    char_entities = ["O"] * len(text)
+    for token, label, (start, end) in zip(source_tokens, source_labels, offsets):
+        if not label.startswith(("B-", "I-")):
+            continue
+        entity = label.split("-", 1)[1]
+
+        # Bracketed single-token metadata in older data often includes the
+        # brackets in the token. Keep container punctuation as O so a tokenizer
+        # that splits brackets can learn cleaner boundaries.
+        inner_start = start
+        inner_end = end
+        if len(token) >= 2 and token[0] in "[【(《" and token[-1] in "]】)》":
+            inner_start += 1
+            inner_end -= 1
+
+        for pos in range(inner_start, inner_end):
+            if 0 <= pos < len(char_entities):
+                char_entities[pos] = entity
+    return char_entities
+
+
+def labels_from_char_projection(
+    text: str,
+    target_tokens: List[str],
+    char_entities: List[str],
+) -> Optional[List[str]]:
+    """Assign legal IOB2 labels to target tokens from per-character entities."""
+    offsets = token_offsets_in_text(text, target_tokens)
+    if offsets is None:
+        return None
+
+    labels: List[str] = []
+    active_entity: Optional[str] = None
+    for start, end in offsets:
+        span_entities = [
+            char_entities[pos]
+            for pos in range(start, end)
+            if 0 <= pos < len(char_entities) and char_entities[pos] != "O"
+        ]
+        if not span_entities:
+            labels.append("O")
+            active_entity = None
+            continue
+
+        entity = Counter(span_entities).most_common(1)[0][0]
+        prefix = "I" if active_entity == entity else "B"
+        labels.append(f"{prefix}-{entity}")
+        active_entity = entity
+    return labels
+
+
+def project_labels_from_filename(
+    filename: str,
+    source_tokens: List[str],
+    source_labels: List[str],
+    tokenizer: AnimeTokenizer,
+) -> Optional[Tuple[List[str], List[str]]]:
+    """
+    Re-tokenize filename and project weak BIO labels onto that tokenizer.
+
+    Returns None when source tokens cannot be aligned to the filename.
+    """
+    char_entities = project_source_labels_to_chars(filename, source_tokens, source_labels)
+    if char_entities is None:
+        return None
+
+    target_tokens = tokenizer.tokenize(filename)
+    target_labels = labels_from_char_projection(filename, target_tokens, char_entities)
+    if target_labels is None or len(target_tokens) != len(target_labels):
+        return None
+    return target_tokens, target_labels
+
+
+def create_datasets(
+    data_path: str,
+    tokenizer: AnimeTokenizer,
+    config: Config,
+) -> tuple:
+    """
+    Create train and validation datasets from a JSONL file.
+
+    The file is split by the first N samples for training,
+    the rest for validation based on config.train_split.
+
+    Returns:
+        (train_dataset, eval_dataset)
+    """
+    # Load all data to determine split
+    with open(data_path, 'r', encoding='utf-8') as f:
+        all_data = [json.loads(line) for line in f if line.strip()]
+
+    split_idx = int(len(all_data) * config.train_split)
+    train_data = all_data[:split_idx]
+    eval_data = all_data[split_idx:]
+
+    # Write temp files for each split
+    import tempfile
+    import os
+
+    train_file = os.path.join(tempfile.gettempdir(), "anime_train.jsonl")
+    eval_file = os.path.join(tempfile.gettempdir(), "anime_eval.jsonl")
+
+    with open(train_file, 'w', encoding='utf-8') as f:
+        for item in train_data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+
+    with open(eval_file, 'w', encoding='utf-8') as f:
+        for item in eval_data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+
+    train_dataset = AnimeDataset(
+        data_path=train_file,
+        tokenizer=tokenizer,
+        label2id=config.label2id,
+        max_length=config.max_seq_length,
+    )
+    eval_dataset = AnimeDataset(
+        data_path=eval_file,
+        tokenizer=tokenizer,
+        label2id=config.label2id,
+        max_length=config.max_seq_length,
+    )
+
+    return train_dataset, eval_dataset
+
+
+if __name__ == "__main__":
+    # Quick test
+    cfg = Config()
+
+    tok = AnimeTokenizer()
+    # Build a minimal vocab
+    tok.build_vocab([["[ANi]", "test", "S2", "-", "03"],
+                     ["[Baha]", "anime", "01"]])
+
+    ds = AnimeDataset(
+        data_path="data/synthetic.jsonl",
+        tokenizer=tok,
+        label2id=cfg.label2id,
+        max_length=cfg.max_seq_length,
+    )
+
+    print(f"Dataset size: {len(ds)}")
+    if len(ds) > 0:
+        sample = ds[0]
+        print(f"input_ids shape: {sample['input_ids'].shape}")
+        print(f"attention_mask shape: {sample['attention_mask'].shape}")
+        print(f"labels shape: {sample['labels'].shape}")
+        print(f"input_ids: {sample['input_ids'].tolist()}")
+        print(f"labels: {sample['labels'].tolist()}")
+        print(f"attention_mask: {sample['attention_mask'].tolist()}")
+

snapshots/anifilebert-dapt512-long/anifilebert/inference.py

@@ -0,0 +1,666 @@
+"""
+Inference script for anime filename parser.
+
+Loads a trained model and tokenizer, parses anime filenames,
+and outputs structured metadata.
+
+Usage:
+    python -m anifilebert.inference "[ANi] 葬送的芙莉莲 S2 - 03 [1080P][WEB-DL]"
+    python -m anifilebert.inference --input-file filenames.txt --output-file results.jsonl
+"""
+
+import argparse
+import json
+import re
+import sys
+from typing import Dict, List, Optional, Tuple
+
+import torch
+
+from .config import Config
+from .label_repairs import season_marker_number
+from .labels import is_file_title_entity, is_path_title_entity, title_entity_priority, title_language
+from .model import load_model
+from .tokenizer import AnimeTokenizer, load_tokenizer
+
+
+# Chinese number mapping
+CN_NUM_MAP: Dict[str, int] = {
+    "一": 1, "二": 2, "三": 3, "四": 4, "五": 5,
+    "六": 6, "七": 7, "八": 8, "九": 9, "十": 10,
+}
+
+
+STANDALONE_SPECIAL_RE = re.compile(
+    r"^(?:"
+    r"(?:BD\s*)?Menu\s*\d{0,2}(?:-\d{1,2})?|"
+    r"NCOP\s*\d{0,2}|NCED\s*\d{0,2}|"
+    r"OP\s*\d{0,2}|ED(?:\s*E?\d{0,2})?|"
+    r"PV\s*\d{0,2}|CM\s*\d{0,2}|"
+    r"OVA\s*\d{0,2}|OAD\s*\d{0,2}|SP\s*\d{0,2}|IV\d+"
+    r")$",
+    re.I,
+)
+
+BRACKETED_SEARCH_SPECIAL_RE = re.compile(
+    r"[\[【（(]\s*((?:檢索|检索|検索)\s*[:：][^\]】）)]+?)\s*[\]】）)]"
+)
+
+NEW_SHOW_BRACKET_TITLE_RE = re.compile(
+    r"[★☆][^★☆\[\]【】()（）]{0,24}(?:新番|月番)[^★☆\[\]【】()（）]{0,24}[★☆]"
+    r"\s*[\[【（(]\s*([^\]】）)]+?)\s*[\]】）)]"
+)
+
+
+def extract_season_number(text: str) -> Optional[int]:
+    """
+    Extract season number from various season formats.
+
+    Examples:
+        "S2" → 2, "Season 2" → 2, "第二季" → 2, "1st Season" → 1
+    """
+    marker_value = season_marker_number(text)
+    if marker_value is not None:
+        return marker_value
+
+    # Arabic digits
+    match = re.search(r'(\d+)', text)
+    if match:
+        return int(match.group(1))
+
+    # Chinese digits
+    for cn, num in CN_NUM_MAP.items():
+        if cn in text:
+            return num
+
+    return None
+
+
+def extract_episode_number(text: str) -> Optional[int]:
+    """
+    Extract episode number from various episode formats.
+
+    Examples:
+        "03" → 3, "EP21" → 21, "第7话" → 7, "#01" → 1
+    """
+    match = re.search(r'(\d+)', text)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+def extract_resolution(text: str) -> Optional[str]:
+    """Extract resolution string (e.g., '1080P', '4K', '1920x1080')."""
+    # Strip brackets for matching
+    clean = text.strip("[]()【】")
+    return clean if clean else None
+
+
+def normalize_field_text(text: str) -> str:
+    return trim_decorations(text).strip(" \t-_.")
+
+
+def thin_source_priority(source: str) -> int:
+    normalized = source.lower().replace("_", "-").replace(" ", "")
+    if normalized in {
+        "nf", "netflix", "amzn", "baha", "cr", "abema", "dsnp", "u-next", "hulu", "at-x",
+        "web-dl", "webdl", "webrip", "web-rip", "bdrip", "bluray", "bdmv", "bd",
+        "dvdrip", "dvd", "tvrip", "hdtv",
+    }:
+        return 90
+    if normalized in {"chs", "cht", "gb", "big5", "jpn", "jp", "jpsc", "jptc", "繁中", "简中"}:
+        return 70
+    if normalized in {
+        "x264", "x265", "h.264", "h264", "h.265", "h265", "hevc", "avc", "av1",
+        "aac", "flac", "mp3", "dts", "opus", "10bit", "8bit", "hi10p", "ma10p",
+        "srt", "srtx2", "ass", "assx2",
+    }:
+        return 20
+    return 40 if re.search(r"[&+/,]", source) else 30
+
+
+def normalize_source_text(text: str) -> str:
+    text = re.sub(r"\s+", "", text.strip())
+    text = re.sub(r"(?i)WEB[_ ]?DL", "WEB-DL", text)
+    text = re.sub(r"(?i)WEB[_ ]?Rip", "WebRip", text)
+    text = re.sub(r"(?i)U[_ ]?NEXT", "U-NEXT", text)
+    text = re.sub(r"(?i)AT[_ ]?X", "AT-X", text)
+    return text.replace("_", "-")
+
+
+def choose_thin_source(sources: List[str]) -> Optional[str]:
+    cleaned = [normalize_source_text(source) for source in sources if normalize_field_text(source)]
+    if not cleaned:
+        return None
+    return max(enumerate(cleaned), key=lambda item: (thin_source_priority(item[1]), -item[0]))[1]
+
+
+def normalize_standalone_special(text: str) -> Optional[str]:
+    special = normalize_field_text(text)
+    if not special:
+        return None
+    return special if STANDALONE_SPECIAL_RE.fullmatch(special) else None
+
+
+def extract_bracketed_search_special(text: str) -> Optional[str]:
+    """Return bracketed search-note tags such as [檢索：...]."""
+    for match in BRACKETED_SEARCH_SPECIAL_RE.finditer(text):
+        special = normalize_field_text(match.group(1))
+        if special:
+            return special
+    return None
+
+
+def extract_new_show_bracket_title(text: str) -> Optional[str]:
+    """Return title from release-promo layouts like ★04月新番★[葬送的芙莉莲]."""
+    for match in NEW_SHOW_BRACKET_TITLE_RE.finditer(text):
+        title = normalize_field_text(match.group(1))
+        if title:
+            return title
+    return None
+
+
+def display_token(token: str) -> str:
+    """Make whitespace tokens visible in debug output."""
+    if token == " ":
+        return "<SPACE>"
+    if token == "\t":
+        return "<TAB>"
+    return token
+
+
+def trim_decorations(text: str) -> str:
+    """Trim outer release brackets from an extracted entity."""
+    return text.strip().strip("[]()【】《》（）").strip()
+
+
+def join_entity_tokens(tokens: List[str], tokenizer: Optional[AnimeTokenizer] = None) -> str:
+    """Join entity tokens according to the tokenizer granularity."""
+    if tokenizer is not None and getattr(tokenizer, "tokenizer_variant", "regex") == "char":
+        return "".join(tokens)
+    text = "".join(tokens)
+    if " " in tokens:
+        return text
+    return text
+
+
+def labels_to_entities(
+    tokens: List[str],
+    labels: List[str],
+    tokenizer: Optional[AnimeTokenizer] = None,
+) -> List[Tuple[str, str]]:
+    """
+    Convert BIO labels into entity spans.
+
+    Illegal orphan I-X labels start a new entity so debug output exposes the
+    model behavior instead of silently dropping tokens.
+    """
+    entities: List[Tuple[str, str]] = []
+    current_entity: Optional[str] = None
+    current_tokens: List[str] = []
+
+    for token, label in zip(tokens, labels):
+        if label.startswith("B-"):
+            if current_entity:
+                entities.append((current_entity, join_entity_tokens(current_tokens, tokenizer)))
+            current_entity = label[2:]
+            current_tokens = [token]
+        elif label.startswith("I-"):
+            entity_type = label[2:]
+            if current_entity == entity_type:
+                current_tokens.append(token)
+            else:
+                if current_entity:
+                    entities.append((current_entity, join_entity_tokens(current_tokens, tokenizer)))
+                current_entity = entity_type
+                current_tokens = [token]
+        else:
+            if current_entity:
+                entities.append((current_entity, join_entity_tokens(current_tokens, tokenizer)))
+                current_entity = None
+                current_tokens = []
+
+    if current_entity:
+        entities.append((current_entity, join_entity_tokens(current_tokens, tokenizer)))
+    return entities
+
+
+def is_allowed_bio_transition(previous_label: str, label: str) -> bool:
+    """Return whether previous_label -> label is valid under IOB2."""
+    if label.startswith("I-"):
+        entity = label[2:]
+        return previous_label in {f"B-{entity}", f"I-{entity}"}
+    return True
+
+
+_BIO_TRANSITION_CACHE: Dict[Tuple[Tuple[int, str], ...], torch.Tensor] = {}
+
+
+def bio_transition_mask(id2label: Dict[int, str]) -> torch.Tensor:
+    """Return cached valid-transition mask shaped [prev_label, next_label]."""
+    key = tuple(sorted((int(label_id), label) for label_id, label in id2label.items()))
+    cached = _BIO_TRANSITION_CACHE.get(key)
+    if cached is not None:
+        return cached
+    num_labels = max(id2label) + 1 if id2label else 0
+    mask = torch.zeros((num_labels, num_labels), dtype=torch.bool)
+    for prev_id in range(num_labels):
+        prev_label = id2label.get(prev_id, "O")
+        for label_id in range(num_labels):
+            label = id2label.get(label_id, "O")
+            mask[prev_id, label_id] = is_allowed_bio_transition(prev_label, label)
+    _BIO_TRANSITION_CACHE[key] = mask
+    return mask
+
+
+def constrained_bio_decode(emissions: torch.Tensor, id2label: Dict[int, str]) -> List[int]:
+    """
+    Decode token logits with hard BIO transition constraints.
+
+    This is a lightweight CRF-style Viterbi decoder without learned transition
+    weights. It prevents impossible orphan I-X spans at inference time.
+    """
+    if emissions.numel() == 0:
+        return []
+
+    num_tokens, num_labels = emissions.shape
+    scores = emissions.detach().cpu()
+    transition_mask = bio_transition_mask(id2label)
+    backpointers = torch.zeros((num_tokens, num_labels), dtype=torch.long)
+    dp = torch.full((num_labels,), float("-inf"))
+
+    for label_id in range(num_labels):
+        label = id2label.get(label_id, "O")
+        if not label.startswith("I-"):
+            dp[label_id] = scores[0, label_id]
+
+    for idx in range(1, num_tokens):
+        candidates = dp.unsqueeze(1).expand(num_labels, num_labels)
+        candidates = candidates.masked_fill(~transition_mask, float("-inf"))
+        best_scores, best_prev = candidates.max(dim=0)
+        next_dp = best_scores + scores[idx]
+        backpointers[idx] = best_prev
+        dp = next_dp
+
+    best_last = int(torch.argmax(dp).item())
+    decoded = [best_last]
+    for idx in range(num_tokens - 1, 0, -1):
+        decoded.append(int(backpointers[idx, decoded[-1]].item()))
+    decoded.reverse()
+    return decoded
+
+
+def empty_parse_result() -> Dict:
+    return {
+        "title": None,
+        "season": None,
+        "episode": None,
+        "group": None,
+        "resolution": None,
+        "source": None,
+        "special": None,
+        "title_candidates": [],
+        "tags": [],
+    }
+
+
+def append_unique(values: List[str], value: str) -> None:
+    if value and value not in values:
+        values.append(value)
+
+
+def infer_title_kind(text: str) -> str:
+    has_latin = any(ch.isascii() and ch.isalpha() for ch in text)
+    has_han = any("\u4e00" <= ch <= "\u9fff" for ch in text)
+    has_kana = any("\u3040" <= ch <= "\u30ff" or "\u31f0" <= ch <= "\u31ff" for ch in text)
+    if has_kana:
+        return "jpn"
+    if has_latin and has_han:
+        return "mixed"
+    if has_han:
+        return "chs"
+    if has_latin:
+        return "latin"
+    return "mixed"
+
+
+def append_title_candidate(result: Dict, text: str, entity: Optional[str], source: str) -> None:
+    if not text:
+        return
+    kind = title_language(entity).lower() if entity else infer_title_kind(text)
+    candidate = {"text": text, "kind": kind, "source": source}
+    if candidate not in result["title_candidates"]:
+        result["title_candidates"].append(candidate)
+
+
+def choose_title_span(spans: List[Tuple[str, str, int]]) -> Optional[str]:
+    if not spans:
+        return None
+    return min(spans, key=lambda item: (title_entity_priority(item[0]), item[2]))[1]
+
+
+def postprocess(
+    tokens: List[str],
+    labels: List[str],
+    tokenizer: Optional[AnimeTokenizer] = None,
+) -> Dict:
+    """
+    Convert BIO-labeled tokens into structured metadata.
+
+    Merges consecutive B- / I- tokens of the same entity type,
+    then extracts structured fields.
+    """
+    result: Dict = empty_parse_result()
+
+    entities = labels_to_entities(tokens, labels, tokenizer)
+
+    grouped_entities: Dict[str, List[str]] = {}
+    file_title_spans: List[Tuple[str, str, int]] = []
+    path_title_spans: List[Tuple[str, str, int]] = []
+    for index, (entity_type, text) in enumerate(entities):
+        grouped_entities.setdefault(entity_type, []).append(text)
+        title = normalize_field_text(text)
+        if not title:
+            continue
+        if is_file_title_entity(entity_type):
+            file_title_spans.append((entity_type, title, index))
+        elif is_path_title_entity(entity_type):
+            path_title_spans.append((entity_type, title, index))
+
+    for entity, title, _index in file_title_spans:
+        append_title_candidate(result, title, entity, "file")
+    for entity, title, _index in path_title_spans:
+        append_title_candidate(result, title, entity, "path")
+
+    if file_title_spans and all(entity == "TITLE" for entity, _title, _index in file_title_spans):
+        result["title"] = " ".join(title for _entity, title, _index in file_title_spans)
+    else:
+        result["title"] = choose_title_span(file_title_spans) or choose_title_span(path_title_spans)
+
+    for text in grouped_entities.get("SEASON", []):
+        season_num = extract_season_number(text)
+        if season_num is not None:
+            result["season"] = season_num
+            break
+    if result["season"] is None:
+        for text in grouped_entities.get("PATH_SEASON", []):
+            season_num = extract_season_number(text)
+            if season_num is not None:
+                result["season"] = season_num
+                break
+
+    for text in grouped_entities.get("EPISODE", []):
+        ep_num = extract_episode_number(text)
+        if ep_num is not None:
+            if result["episode"] is None:
+                result["episode"] = ep_num
+
+    for text in grouped_entities.get("GROUP", []):
+        group = normalize_field_text(text)
+        if result["group"] is None:
+            result["group"] = group
+
+    for text in grouped_entities.get("SPECIAL", []):
+        special = normalize_field_text(text)
+        result["special"] = special
+
+    for text in grouped_entities.get("RESOLUTION", []):
+        res = extract_resolution(text)
+        if res:
+            result["resolution"] = res
+
+    for text in grouped_entities.get("TAG", []):
+        tag = normalize_field_text(text)
+        append_unique(result["tags"], tag)
+
+    result["source"] = choose_thin_source(grouped_entities.get("SOURCE", []))
+
+    whole_text = join_entity_tokens(tokens, tokenizer)
+    new_show_title = extract_new_show_bracket_title(whole_text)
+    if new_show_title is not None and (
+        result["title"] is None
+        or result["title"].startswith(("★", "☆"))
+        or "新番" in result["title"]
+        or "月番" in result["title"]
+    ):
+        result["title"] = new_show_title
+        append_title_candidate(result, new_show_title, None, "file")
+
+    search_special = extract_bracketed_search_special(whole_text)
+    if search_special is not None:
+        result["special"] = search_special
+
+    standalone_special = normalize_standalone_special(whole_text)
+    if standalone_special is not None:
+        result.update(
+            {
+                "title": None,
+                "season": None,
+                "episode": None,
+                "group": None,
+                "resolution": None,
+                "source": None,
+                "special": standalone_special,
+                "title_candidates": [],
+                "tags": [],
+            }
+        )
+
+    return result
+
+
+def parse_filename(
+    filename: str,
+    model: torch.nn.Module,
+    tokenizer: AnimeTokenizer,
+    id2label: Dict[int, str],
+    max_length: int = 64,
+    debug: bool = False,
+    constrain_bio: bool = True,
+) -> Dict:
+    """
+    Parse an anime filename and extract structured metadata.
+
+    Args:
+        filename: Raw anime filename string.
+        model: Trained BertForTokenClassification model.
+        tokenizer: AnimeTokenizer instance.
+        id2label: Mapping from label ID to label string.
+        max_length: Maximum sequence length (including special tokens).
+
+    Returns:
+        Dict with parsed fields (title, season, episode, etc.).
+    """
+    # Tokenize
+    tokens = tokenizer.tokenize(filename)
+    if not tokens:
+        return empty_parse_result()
+
+    # Convert to input IDs
+    input_ids = tokenizer.convert_tokens_to_ids(tokens)
+    embedding_size = model.get_input_embeddings().weight.shape[0]
+    out_of_range_tokens = [
+        token for token, token_id in zip(tokens, input_ids)
+        if token_id >= embedding_size
+    ]
+    if out_of_range_tokens:
+        input_ids = [
+            token_id if token_id < embedding_size else tokenizer.unk_token_id
+            for token_id in input_ids
+        ]
+    unk_token_id = tokenizer.unk_token_id
+    unk_tokens = [token for token, token_id in zip(tokens, input_ids) if token_id == unk_token_id]
+
+    # Add special tokens
+    input_ids = [tokenizer.cls_token_id] + input_ids + [tokenizer.sep_token_id]
+    attention_mask = [1] * len(input_ids)
+
+    # Truncate if needed
+    if len(input_ids) > max_length:
+        input_ids = [input_ids[0]] + input_ids[1:max_length - 1] + [tokenizer.sep_token_id]
+        attention_mask = [1] * len(input_ids)
+
+    # Pad
+    pad_len = max_length - len(input_ids)
+    if pad_len > 0:
+        input_ids += [tokenizer.pad_token_id] * pad_len
+        attention_mask += [0] * pad_len
+
+    # Predict
+    device = next(model.parameters()).device
+    input_tensor = torch.tensor([input_ids], device=device)
+    mask_tensor = torch.tensor([attention_mask], device=device)
+
+    # Remove special token predictions
+    # Count real tokens used (minus CLS/SEP)
+    real_token_count = len(tokens)
+    # Truncate real tokens if we had to truncate
+    available = min(real_token_count, max_length - 2)
+    if available <= 0:
+        return empty_parse_result()
+
+    with torch.no_grad():
+        logits = model(input_ids=input_tensor, attention_mask=mask_tensor).logits
+    token_logits = logits[0, 1:1 + available, :]
+    probabilities = torch.softmax(token_logits, dim=-1)
+    scores, greedy_predictions = torch.max(probabilities, dim=-1)
+    decoder_name = "greedy"
+    if constrain_bio:
+        if hasattr(model, "decode"):
+            pred_labels = model.decode(logits, mask_tensor)[0][:available]
+            decoder_name = "crf"
+        else:
+            pred_labels = constrained_bio_decode(token_logits, id2label)
+            decoder_name = "constrained_bio"
+        selected_scores = [
+            probabilities[idx, label_id].detach().cpu().item()
+            for idx, label_id in enumerate(pred_labels)
+        ]
+    else:
+        pred_labels = greedy_predictions.detach().cpu().tolist()
+        selected_scores = scores.detach().cpu().tolist()
+    label_strings = [id2label.get(p, "O") for p in pred_labels]
+
+    # Post-process
+    result = postprocess(
+        tokens[:available],
+        label_strings,
+        tokenizer=tokenizer,
+    )
+    if debug:
+        result["_debug"] = {
+            "tokenizer_variant": getattr(tokenizer, "tokenizer_variant", "regex"),
+            "decoder": decoder_name,
+            "postprocess": "thin_normalize",
+            "max_length": max_length,
+            "token_count": len(tokens),
+            "available_token_count": available,
+            "truncated": len(tokens) > available,
+            "unk_count": len(unk_tokens),
+            "unk_rate": len(unk_tokens) / len(tokens) if tokens else 0.0,
+            "unk_tokens": unk_tokens[:50],
+            "vocab_mismatch": bool(out_of_range_tokens),
+            "model_embedding_size": int(embedding_size),
+            "tokenizer_vocab_size": int(tokenizer.vocab_size),
+            "out_of_range_tokens": out_of_range_tokens[:50],
+            "tokens": tokens[:available],
+            "labels": label_strings,
+            "scores": [round(float(score), 4) for score in selected_scores],
+            "token_table": [
+                {
+                    "i": i,
+                    "token": display_token(token),
+                    "id": int(token_id),
+                    "label": label,
+                    "score": round(float(score), 4),
+                }
+                for i, (token, token_id, label, score) in enumerate(
+                    zip(tokens[:available], input_ids[1:1 + available], label_strings, selected_scores)
+                )
+            ],
+            "entities": [
+                {"type": entity_type, "text": text}
+                for entity_type, text in labels_to_entities(tokens[:available], label_strings, tokenizer)
+            ],
+        }
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Anime filename parser")
+    parser.add_argument("filename", nargs="?", type=str, help="Anime filename to parse")
+    parser.add_argument("--input-file", type=str, help="File with filenames (one per line)")
+    parser.add_argument("--output-file", type=str, help="Output file for results (JSONL)")
+    parser.add_argument("--model-dir", type=str, default=".",
+                        help="Path to trained model directory")
+    parser.add_argument("--tokenizer", choices=["regex", "char"], default=None,
+                        help="Tokenizer variant override. Defaults to checkpoint metadata")
+    parser.add_argument("--max-length", type=int, default=64,
+                        help="Maximum sequence length")
+    parser.add_argument("--debug", action="store_true",
+                        help="Include tokenizer, labels, scores, and entity spans in JSON output")
+    parser.add_argument("--no-constrained-bio", action="store_true",
+                        help="Use greedy per-token decoding instead of constrained BIO Viterbi")
+    args = parser.parse_args()
+
+    # Load config
+    cfg = Config()
+
+    # Load tokenizer
+    print(f"Loading tokenizer from {args.model_dir}...", file=sys.stderr)
+    tokenizer = load_tokenizer(args.model_dir, args.tokenizer)
+
+    # Load model
+    print(f"Loading model from {args.model_dir}...", file=sys.stderr)
+    model = load_model(args.model_dir)
+    model.eval()
+
+    id2label = {int(k): v for k, v in getattr(model.config, "id2label", cfg.id2label).items()}
+    max_length = args.max_length
+    if max_length == 64:
+        max_length = int(getattr(model.config, "max_seq_length", max_length))
+
+    # Process filenames
+    filenames_to_parse: List[str] = []
+
+    if args.filename:
+        filenames_to_parse.append(args.filename)
+
+    if args.input_file:
+        with open(args.input_file, 'r', encoding='utf-8') as f:
+            filenames_to_parse.extend(line.strip() for line in f if line.strip())
+
+    if not filenames_to_parse:
+        # Read from stdin
+        filenames_to_parse.extend(sys.stdin.read().strip().splitlines())
+
+    # Parse and output
+    results: List[Dict] = []
+    for fn in filenames_to_parse:
+        if not fn.strip():
+            continue
+        result = parse_filename(
+            fn,
+            model,
+            tokenizer,
+            id2label,
+            max_length,
+            debug=args.debug,
+            constrain_bio=not args.no_constrained_bio,
+        )
+        result["_input"] = fn
+        results.append(result)
+
+        if args.output_file is None:
+            print(json.dumps(result, ensure_ascii=False))
+
+    if args.output_file:
+        with open(args.output_file, 'w', encoding='utf-8') as f:
+            for r in results:
+                f.write(json.dumps(r, ensure_ascii=False) + '\n')
+        print(f"Results saved to {args.output_file}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()
+

snapshots/anifilebert-dapt512-long/anifilebert/label_repairs.py

@@ -0,0 +1,520 @@
+"""Deterministic label repairs for known weak-label blind spots."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple
+
+from .labels import is_same_entity_label, is_season_like_label, is_title_like_label, label_entity
+
+
+SEPARATOR_CHARS = set(" \t-_.|~～")
+
+ROMAN_NUMERAL_VALUES = {
+    "II": 2,
+    "III": 3,
+    "IV": 4,
+    "V": 5,
+    "VI": 6,
+    "VII": 7,
+    "VIII": 8,
+    "IX": 9,
+    "Ⅱ": 2,
+    "Ⅲ": 3,
+    "Ⅳ": 4,
+    "Ⅴ": 5,
+    "Ⅵ": 6,
+    "Ⅶ": 7,
+    "Ⅷ": 8,
+    "Ⅸ": 9,
+}
+
+CN_NUMERAL_VALUES = {
+    "一": 1,
+    "二": 2,
+    "兩": 2,
+    "两": 2,
+    "貳": 2,
+    "贰": 2,
+    "弐": 2,
+    "弍": 2,
+    "三": 3,
+    "參": 3,
+    "叁": 3,
+    "参": 3,
+    "四": 4,
+    "肆": 4,
+    "五": 5,
+    "伍": 5,
+    "六": 6,
+    "陸": 6,
+    "陆": 6,
+    "七": 7,
+    "柒": 7,
+    "八": 8,
+    "捌": 8,
+    "九": 9,
+    "玖": 9,
+    "十": 10,
+}
+
+READING_MARKER_VALUES = {
+    "ni no sara": 2,
+    "ni no shou": 2,
+    "ni no sho": 2,
+    "ni no syo": 2,
+    "ni no shō": 2,
+    "ni gakki": 2,
+    "sono ni": 2,
+    "san no sara": 3,
+    "san no shou": 3,
+    "san no sho": 3,
+    "san no syo": 3,
+    "yon no sara": 4,
+    "shi no sara": 4,
+    "shin no sara": 4,
+    "go no sara": 5,
+    "gou no sara": 5,
+}
+
+# Bare "Ni" is often the Japanese particle に in romanized titles. Only repair
+# it for titles that have been verified as a sequel marker in the release name.
+STANDALONE_NI_SEASON_BASES = {
+    "Kakuriyo no Yadomeshi": 2,
+}
+
+EPISODE_CONTEXT_RE = re.compile(
+    r"^\s*(?:"
+    r"[-_]\s*(?:\d{1,4}|NCOP|NCED|OP|ED|OVA|OAD|SP|END)\b|"
+    r"#\s*\d{1,4}|"
+    r"[\[\(【《]\s*(?:EP?|#)?\d{1,4}"
+    r")",
+    re.I,
+)
+
+EPISODE_SPAN_RE = re.compile(
+    r"(?:"
+    r"[Ss]\d{1,2}[Ee]\d{1,4}(?:v\d+)?|"
+    r"(?:^|[\s._])[-_]\s*\d{1,4}(?:v\d+)?(?=$|[\s._\-\]\)】》\[])|"
+    r"[\[\(【《](?:EP?|#)?\d{1,4}(?:v\d+)?[\]\)】》]|"
+    r"(?:^|[\s._\-\[\(【《#])(?:EP?|第|#)\d{1,4}(?:v\d+)?(?:[话話集])?(?=$|[\s._\-\]\)】》])"
+    r")",
+    re.I,
+)
+BRACKET_RE = re.compile(r"\[([^\]]*)\]|\(([^)]*)\)|【([^】]*)】|《([^》]*)》")
+RESOLUTION_RE = re.compile(r"(?<![A-Za-z0-9])(?:\d{3,4}[pP]|\d[Kk]|\d{3,4}[xX×]\d{3,4})(?![A-Za-z0-9])")
+SOURCE_TOKEN_PATTERN = (
+    r"WEB[-_ ]?DL|WEB[-_ ]?Rip|BDRip|BluRay|BDMV|BD|DVDRip|DVD|TVRip|HDTV|"
+    r"Netflix|NF|AMZN|Baha|CR|ABEMA|DSNP|U[-_ ]?NEXT|Hulu|AT[-_ ]?X|"
+    r"x26[45]|h\.?26[45]|HEVC|AVC|AV1|AAC\d*(?:\.\d+)?|AAC|FLAC|MP3|DTS|Opus|"
+    r"CHS|CHT|GB|BIG5|JPN?|JPSC|JPTC|繁中|简中"
+)
+SOURCE_RE = re.compile(rf"(?<![A-Za-z0-9])(?:{SOURCE_TOKEN_PATTERN})(?![A-Za-z0-9])", re.I)
+SOURCE_TAG_RE = re.compile(
+    rf"^(?:{SOURCE_TOKEN_PATTERN})(?:\s*(?:[&+/,_-]|,\s*)\s*(?:{SOURCE_TOKEN_PATTERN}))*$",
+    re.I,
+)
+SPECIAL_TAG_RE = re.compile(
+    r"^(?:檢索|检索|搜索|搜寻|搜尋|别名|別名|alias|search|keyword)\s*[:：].+",
+    re.I,
+)
+SPECIAL_CODE_RE = re.compile(
+    r"^(?:NCOP|NCED|OP|ED|PV|CM)\d*$|^IV\d+$|^(?:OVA|OAD|SP)\d*$",
+    re.I,
+)
+
+READING_MARKER_RE = re.compile(
+    r"(?<![A-Za-z0-9])"
+    r"(?P<marker>"
+    r"Ni\s+no\s+(?:Sara|Shou|Sho|Syo|Shō)|"
+    r"San\s+no\s+(?:Sara|Shou|Sho|Syo)|"
+    r"(?:Yon|Shi|Shin)\s+no\s+Sara|"
+    r"(?:Go|Gou)\s+no\s+Sara|"
+    r"Ni\s+Gakki|"
+    r"Sono\s+Ni"
+    r")"
+    r"(?![A-Za-z0-9])",
+)
+
+ROMAN_MARKER_RE = re.compile(
+    r"(?<![A-Za-z0-9])"
+    r"(?P<marker>II|III|IV|V|VI|VII|VIII|IX|[ⅡⅢⅣⅤⅥⅦⅧⅨ])"
+    r"(?![A-Za-z0-9])"
+)
+
+CJK_MARKER_RE = re.compile(
+    r"(?P<marker>"
+    r"[一二三四五六七八九十兩两貳贰弐弍參叁参肆伍陸陆柒捌玖](?:\s*(?:ノ|の|之)\s*(?:章|期|季|部))?|"
+    r"第[一二三四五六七八九十兩两貳贰弐弍參叁参肆伍陸陆柒捌玖\d]+[季期部章]"
+    r")"
+)
+
+
+@dataclass(frozen=True)
+class LabelRepair:
+    kind: str
+    marker: str
+    value: int
+    start: int
+    end: int
+
+
+def clean_marker_text(text: str) -> str:
+    return text.strip().strip("[]()【】《》（）").strip()
+
+
+def cn_number_to_int(text: str) -> Optional[int]:
+    text = text.strip()
+    if text.isdigit():
+        return int(text)
+    if text in CN_NUMERAL_VALUES:
+        return CN_NUMERAL_VALUES[text]
+    values = CN_NUMERAL_VALUES
+    if text.startswith("十") and len(text) == 2:
+        return 10 + values.get(text[1], 0)
+    if text.endswith("十") and len(text) == 2:
+        return values.get(text[0], 0) * 10
+    if "十" in text and len(text) == 3:
+        return values.get(text[0], 0) * 10 + values.get(text[2], 0)
+    return None
+
+
+def season_marker_number(text: str) -> Optional[int]:
+    """Return season number for compact sequel markers such as II or Ni no Sara."""
+    clean = clean_marker_text(text)
+    if not clean:
+        return None
+
+    if clean in ROMAN_NUMERAL_VALUES:
+        return ROMAN_NUMERAL_VALUES[clean]
+
+    lowered = re.sub(r"\s+", " ", clean.lower()).strip()
+    if lowered in READING_MARKER_VALUES:
+        return READING_MARKER_VALUES[lowered]
+    if lowered == "ni":
+        return 2
+
+    explicit = re.fullmatch(r"第(.+)[季期部章]", clean)
+    if explicit:
+        return cn_number_to_int(explicit.group(1))
+
+    cjk = re.fullmatch(r"([一二三四五六七八九十兩两貳贰弐弍參叁参肆伍陸陆柒捌玖])(?:\s*(?:ノ|の|之)\s*(?:章|期|季|部))?", clean)
+    if cjk:
+        return cn_number_to_int(cjk.group(1))
+
+    return None
+
+
+def token_offsets_in_text(text: str, tokens: Sequence[str]) -> Optional[List[Tuple[int, int]]]:
+    offsets: List[Tuple[int, int]] = []
+    cursor = 0
+    for token in tokens:
+        if token == "":
+            offsets.append((cursor, cursor))
+            continue
+        position = text.find(token, cursor)
+        if position < 0:
+            return None
+        end = position + len(token)
+        offsets.append((position, end))
+        cursor = end
+    return offsets
+
+
+def has_episode_context(text: str, marker_end: int) -> bool:
+    tail = text[marker_end:]
+    if EPISODE_CONTEXT_RE.match(tail):
+        return True
+
+    # Some releases put a season marker at the end of a title bracket and the
+    # episode in the next bracket: `[Title 貳之章][01]`.
+    tail = tail.lstrip()
+    tail = re.sub(r"^[\]\)】》]\s*", "", tail)
+    tail = re.sub(
+        r"^(?:[\[\(【《]\s*(?:menu|menus|bdmenu|ncop|nced|op|ed|ova|oad|sp)\s*[\]\)】》]\s*){0,2}",
+        "",
+        tail,
+        flags=re.I,
+    )
+    return bool(EPISODE_CONTEXT_RE.match(tail))
+
+
+def find_sequel_season_markers(text: str) -> List[LabelRepair]:
+    """Find high-confidence sequel markers that should be labeled as SEASON."""
+    repairs: List[LabelRepair] = []
+
+    for pattern, kind in (
+        (READING_MARKER_RE, "reading"),
+        (ROMAN_MARKER_RE, "roman"),
+        (CJK_MARKER_RE, "cjk"),
+    ):
+        for match in pattern.finditer(text):
+            marker = match.group("marker")
+            value = season_marker_number(marker)
+            if value is None or not has_episode_context(text, match.end()):
+                continue
+            repairs.append(LabelRepair(kind, marker, value, match.start(), match.end()))
+
+    for base, value in STANDALONE_NI_SEASON_BASES.items():
+        pattern = re.compile(rf"(?<![A-Za-z0-9]){re.escape(base)}\s+(?P<marker>Ni)(?![A-Za-z0-9])")
+        for match in pattern.finditer(text):
+            if not has_episode_context(text, match.end("marker")):
+                continue
+            repairs.append(
+                LabelRepair(
+                    kind="verified_bare_ni",
+                    marker=match.group("marker"),
+                    value=value,
+                    start=match.start("marker"),
+                    end=match.end("marker"),
+                )
+            )
+
+    repairs.sort(key=lambda item: (item.start, item.end))
+    deduped: List[LabelRepair] = []
+    for repair in repairs:
+        if deduped and repair.start < deduped[-1].end:
+            previous = deduped[-1]
+            if (repair.end - repair.start) > (previous.end - previous.start):
+                deduped[-1] = repair
+            continue
+        deduped.append(repair)
+    return deduped
+
+
+def labels_have_season_before(labels: Sequence[str], offsets: Sequence[Tuple[int, int]], marker_start: int) -> bool:
+    return any(is_season_like_label(label) and end <= marker_start for label, (_start, end) in zip(labels, offsets))
+
+
+def token_indices_for_span(offsets: Sequence[Tuple[int, int]], start: int, end: int) -> List[int]:
+    return [
+        idx for idx, (tok_start, tok_end) in enumerate(offsets)
+        if tok_start < end and tok_end > start
+    ]
+
+
+def label_span(labels: List[str], indices: Sequence[int], entity: str) -> None:
+    previous_is_same_entity = bool(indices) and indices[0] > 0 and is_same_entity_label(labels[indices[0] - 1], entity)
+    first = not previous_is_same_entity
+    for idx in indices:
+        labels[idx] = f"B-{entity}" if first else f"I-{entity}"
+        first = False
+
+
+def label_span_if_changed(labels: List[str], indices: Sequence[int], entity: str) -> bool:
+    previous_is_same_entity = bool(indices) and indices[0] > 0 and is_same_entity_label(labels[indices[0] - 1], entity)
+    first_label = f"I-{entity}" if previous_is_same_entity else f"B-{entity}"
+    expected = [first_label] + [f"I-{entity}"] * max(0, len(indices) - 1)
+    if [labels[idx] for idx in indices] == expected:
+        return False
+    label_span(labels, indices, entity)
+    return True
+
+
+def safe_to_overwrite_meta(labels: Sequence[str], indices: Sequence[int]) -> bool:
+    if not indices:
+        return False
+    return not any(
+        label_entity(labels[idx]) in {"GROUP", "EPISODE", "SEASON", "PATH_SEASON"}
+        for idx in indices
+    )
+
+
+def mark_adjacent_title_separators_o(
+    tokens: Sequence[str],
+    labels: List[str],
+    marker_indices: Sequence[int],
+) -> None:
+    if not marker_indices:
+        return
+
+    idx = marker_indices[0] - 1
+    while idx >= 0 and "".join(tokens[idx]).strip() == "" and is_title_like_label(labels[idx]):
+        labels[idx] = "O"
+        idx -= 1
+
+    idx = marker_indices[-1] + 1
+    while idx < len(tokens) and tokens[idx] in SEPARATOR_CHARS and is_title_like_label(labels[idx]):
+        labels[idx] = "O"
+        idx += 1
+
+
+def first_episode_end(labels: Sequence[str], offsets: Sequence[Tuple[int, int]], text: str) -> int:
+    ends = [
+        end for label, (_start, end) in zip(labels, offsets)
+        if label_entity(label) == "EPISODE"
+    ]
+    if ends:
+        return min(ends)
+    match = EPISODE_SPAN_RE.search(text)
+    return match.end() if match else 0
+
+
+def bracket_content_spans(text: str) -> Iterable[Tuple[str, int, int, int, int]]:
+    for match in BRACKET_RE.finditer(text):
+        groups = match.groups()
+        group_index = next((idx for idx, value in enumerate(groups) if value is not None), None)
+        if group_index is None:
+            continue
+        inner = groups[group_index] or ""
+        # The opening delimiter is one code point in all supported bracket forms.
+        inner_start = match.start() + 1
+        inner_end = inner_start + len(inner)
+        yield inner.strip(), inner_start, inner_end, match.start(), match.end()
+
+
+def repair_structural_meta_labels(
+    text: str,
+    tokens: Sequence[str],
+    labels: List[str],
+    offsets: Sequence[Tuple[int, int]],
+) -> List[LabelRepair]:
+    repairs: List[LabelRepair] = []
+    episode_end = first_episode_end(labels, offsets, text)
+
+    for clean, inner_start, inner_end, bracket_start, _bracket_end in bracket_content_spans(text):
+        if bracket_start < episode_end:
+            continue
+        if not clean:
+            continue
+
+        if SPECIAL_TAG_RE.fullmatch(clean) or SPECIAL_CODE_RE.fullmatch(clean):
+            indices = token_indices_for_span(offsets, inner_start, inner_end)
+            if safe_to_overwrite_meta(labels, indices) and label_span_if_changed(labels, indices, "SPECIAL"):
+                repairs.append(LabelRepair("special", clean, 0, inner_start, inner_end))
+            continue
+
+        if SOURCE_TAG_RE.fullmatch(clean):
+            indices = token_indices_for_span(offsets, inner_start, inner_end)
+            if safe_to_overwrite_meta(labels, indices) and label_span_if_changed(labels, indices, "SOURCE"):
+                repairs.append(LabelRepair("source", clean, 0, inner_start, inner_end))
+            continue
+
+        for match in RESOLUTION_RE.finditer(clean):
+            start = inner_start + match.start()
+            end = inner_start + match.end()
+            indices = token_indices_for_span(offsets, start, end)
+            if safe_to_overwrite_meta(labels, indices) and label_span_if_changed(labels, indices, "RESOLUTION"):
+                repairs.append(LabelRepair("resolution", match.group(0), 0, start, end))
+
+        for match in SOURCE_RE.finditer(clean):
+            start = inner_start + match.start()
+            end = inner_start + match.end()
+            indices = token_indices_for_span(offsets, start, end)
+            if safe_to_overwrite_meta(labels, indices) and label_span_if_changed(labels, indices, "SOURCE"):
+                repairs.append(LabelRepair("source", match.group(0), 0, start, end))
+
+    # Dot-separated WEB names often carry source/resolution after SxxEyy without
+    # brackets. Repair only after the episode span to avoid touching titles.
+    for pattern, entity in ((RESOLUTION_RE, "RESOLUTION"), (SOURCE_RE, "SOURCE")):
+        for match in pattern.finditer(text):
+            if match.start() < episode_end:
+                continue
+            indices = token_indices_for_span(offsets, match.start(), match.end())
+            if safe_to_overwrite_meta(labels, indices) and label_span_if_changed(labels, indices, entity):
+                repairs.append(LabelRepair(entity.lower(), match.group(0), 0, match.start(), match.end()))
+
+    return repairs
+
+
+def repair_known_label_issues(
+    item: Dict,
+) -> Tuple[List[str], List[str], List[LabelRepair]]:
+    """
+    Repair known weak-label issues.
+
+    The repair is intentionally conservative:
+    - sequel markers must be immediately before an episode/special context;
+    - sequel marker spans must currently be part of TITLE/O, not group/meta;
+    - rows that already have a season before the marker are left alone;
+    - structural meta repairs only touch spans after the first episode.
+    """
+    source_tokens = [str(token) for token in item.get("tokens", [])]
+    source_labels = [str(label) for label in item.get("labels", [])]
+    if len(source_tokens) != len(source_labels):
+        return source_tokens, source_labels, []
+
+    filename = str(item.get("filename") or "")
+    text = filename if filename else "".join(source_tokens)
+    offsets = token_offsets_in_text(text, source_tokens)
+    if offsets is None:
+        text = "".join(source_tokens)
+        offsets = token_offsets_in_text(text, source_tokens)
+    if offsets is None:
+        return source_tokens, source_labels, []
+
+    repaired_labels = list(source_labels)
+    applied: List[LabelRepair] = []
+
+    quick_text = text.lower()
+    has_sequel_marker_hint = any(
+        needle in text or needle in quick_text
+        for needle in (
+            " II", " III", " IV", " V", " VI", " VII", " VIII", " IX",
+            "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ",
+            "之章", "之期", "之季", "之部", "ノ章", "ノ期", "の章", "の期",
+            "貳", "贰", "弐", "弍", "參", "叁", "参", "肆", "陸", "陆",
+            "Ni ", " ni ", " no Sara", "Gakki",
+        )
+    )
+    if has_sequel_marker_hint:
+        for repair in find_sequel_season_markers(text):
+            if labels_have_season_before(repaired_labels, offsets, repair.start):
+                continue
+            indices = token_indices_for_span(offsets, repair.start, repair.end)
+            if not indices:
+                continue
+            existing = [repaired_labels[idx] for idx in indices]
+            if any(
+                label_entity(label) in {"GROUP", "EPISODE", "RESOLUTION", "SOURCE", "SPECIAL", "TAG", "PATH_SEASON"}
+                for label in existing
+            ):
+                continue
+            if not any(is_title_like_label(label) for label in existing):
+                continue
+
+            label_span(repaired_labels, indices, "SEASON")
+            mark_adjacent_title_separators_o(source_tokens, repaired_labels, indices)
+            applied.append(repair)
+
+    applied.extend(repair_structural_meta_labels(text, source_tokens, repaired_labels, offsets))
+    return source_tokens, repaired_labels, applied
+
+
+def repair_sequel_season_labels(
+    item: Dict,
+) -> Tuple[List[str], List[str], List[LabelRepair]]:
+    """Backward-compatible wrapper for callers that repair known label issues."""
+    return repair_known_label_issues(item)
+
+
+def repair_jsonl_item(item: Dict) -> Tuple[Dict, List[LabelRepair]]:
+    tokens, labels, repairs = repair_known_label_issues(item)
+    labels = normalize_iob2(labels)
+    if not repairs:
+        if labels == item.get("labels", []):
+            return item, []
+        repaired = dict(item)
+        repaired["labels"] = labels
+        return repaired, []
+    repaired = dict(item)
+    repaired["tokens"] = tokens
+    repaired["labels"] = labels
+    return repaired, repairs
+
+
+def normalize_iob2(labels: Sequence[str]) -> List[str]:
+    normalized: List[str] = []
+    previous_entity: Optional[str] = None
+    for label in labels:
+        if not label.startswith(("B-", "I-")):
+            normalized.append("O")
+            previous_entity = None
+            continue
+        entity = label.split("-", 1)[1]
+        prefix = "I" if previous_entity == entity else "B"
+        normalized.append(f"{prefix}-{entity}")
+        previous_entity = entity
+    return normalized
+

snapshots/anifilebert-dapt512-long/anifilebert/labels.py

@@ -0,0 +1,205 @@
+"""Shared BIO label schema and helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+
+LABEL_SCHEMA_VERSION = 2
+
+TITLE_SUFFIXES = ("CHS", "CHT", "JPN", "LATIN", "MIXED")
+TITLE_PRIORITY = ("CHS", "CHT", "JPN", "MIXED", "LATIN")
+
+FILE_TITLE_ENTITIES = tuple(f"TITLE_{suffix}" for suffix in TITLE_SUFFIXES)
+PATH_TITLE_ENTITIES = tuple(f"PATH_TITLE_{suffix}" for suffix in TITLE_SUFFIXES)
+TITLE_ENTITIES = FILE_TITLE_ENTITIES + PATH_TITLE_ENTITIES
+TITLE_LIKE_ENTITIES = TITLE_ENTITIES + ("TITLE",)
+SEASON_LIKE_ENTITIES = ("SEASON", "PATH_SEASON")
+
+DEFAULT_TITLE_ENTITY = "TITLE_MIXED"
+
+_FALLBACK_LABELS = (
+    "O",
+    "B-TITLE_CHS",
+    "I-TITLE_CHS",
+    "B-TITLE_CHT",
+    "I-TITLE_CHT",
+    "B-TITLE_JPN",
+    "I-TITLE_JPN",
+    "B-TITLE_LATIN",
+    "I-TITLE_LATIN",
+    "B-TITLE_MIXED",
+    "I-TITLE_MIXED",
+    "B-PATH_TITLE_CHS",
+    "I-PATH_TITLE_CHS",
+    "B-PATH_TITLE_CHT",
+    "I-PATH_TITLE_CHT",
+    "B-PATH_TITLE_JPN",
+    "I-PATH_TITLE_JPN",
+    "B-PATH_TITLE_LATIN",
+    "I-PATH_TITLE_LATIN",
+    "B-PATH_TITLE_MIXED",
+    "I-PATH_TITLE_MIXED",
+    "B-PATH_SEASON",
+    "I-PATH_SEASON",
+    "B-SEASON",
+    "I-SEASON",
+    "B-EPISODE",
+    "I-EPISODE",
+    "B-SPECIAL",
+    "I-SPECIAL",
+    "B-GROUP",
+    "I-GROUP",
+    "B-RESOLUTION",
+    "I-RESOLUTION",
+    "B-SOURCE",
+    "I-SOURCE",
+    "B-TAG",
+    "I-TAG",
+)
+
+
+def _load_schema_labels() -> Tuple[str, ...]:
+    schema_path = Path(__file__).resolve().parents[1] / "label_schema.json"
+    try:
+        with schema_path.open("r", encoding="utf-8") as fh:
+            payload = json.load(fh)
+    except OSError:
+        return _FALLBACK_LABELS
+
+    labels = payload.get("labels")
+    if not isinstance(labels, list) or not labels:
+        return _FALLBACK_LABELS
+    if not all(isinstance(label, str) and label for label in labels):
+        return _FALLBACK_LABELS
+    return tuple(labels)
+
+
+LABELS = _load_schema_labels()
+
+LEGACY_15_LABELS = (
+    "O",
+    "B-TITLE",
+    "I-TITLE",
+    "B-SEASON",
+    "I-SEASON",
+    "B-EPISODE",
+    "I-EPISODE",
+    "B-SPECIAL",
+    "I-SPECIAL",
+    "B-GROUP",
+    "I-GROUP",
+    "B-RESOLUTION",
+    "I-RESOLUTION",
+    "B-SOURCE",
+    "I-SOURCE",
+)
+
+LABEL2ID = {label: idx for idx, label in enumerate(LABELS)}
+ID2LABEL = {idx: label for idx, label in enumerate(LABELS)}
+
+
+def make_label2id() -> Dict[str, int]:
+    return dict(LABEL2ID)
+
+
+def make_id2label() -> Dict[int, str]:
+    return dict(ID2LABEL)
+
+
+def split_bio_label(label: str) -> Tuple[Optional[str], Optional[str]]:
+    if not isinstance(label, str) or label == "O":
+        return None, None
+    prefix, sep, entity = label.partition("-")
+    if sep != "-" or prefix not in {"B", "I"} or not entity:
+        return None, None
+    return prefix, entity
+
+
+def label_entity(label: str) -> Optional[str]:
+    return split_bio_label(label)[1]
+
+
+def canonical_entity(entity: str) -> str:
+    return DEFAULT_TITLE_ENTITY if entity == "TITLE" else entity
+
+
+def canonical_bio_label(label: str) -> str:
+    prefix, entity = split_bio_label(label)
+    if prefix is None or entity is None:
+        return "O" if label == "O" else label
+    return f"{prefix}-{canonical_entity(entity)}"
+
+
+def is_title_entity(entity: Optional[str]) -> bool:
+    return entity in TITLE_LIKE_ENTITIES
+
+
+def is_file_title_entity(entity: Optional[str]) -> bool:
+    return entity in FILE_TITLE_ENTITIES or entity == "TITLE"
+
+
+def is_path_title_entity(entity: Optional[str]) -> bool:
+    return entity in PATH_TITLE_ENTITIES
+
+
+def is_title_like_label(label: str) -> bool:
+    return is_title_entity(label_entity(label))
+
+
+def is_season_entity(entity: Optional[str]) -> bool:
+    return entity in SEASON_LIKE_ENTITIES
+
+
+def is_season_like_label(label: str) -> bool:
+    return is_season_entity(label_entity(label))
+
+
+def is_same_entity_label(label: str, entity: str) -> bool:
+    return label_entity(label) == entity
+
+
+def title_language(entity: Optional[str]) -> str:
+    if entity == "TITLE":
+        return "MIXED"
+    if not entity:
+        return "MIXED"
+    if entity.startswith("PATH_TITLE_"):
+        return entity.removeprefix("PATH_TITLE_")
+    if entity.startswith("TITLE_"):
+        return entity.removeprefix("TITLE_")
+    return "MIXED"
+
+
+def title_entity_priority(entity: Optional[str]) -> Tuple[int, int]:
+    language = title_language(entity)
+    language_rank = TITLE_PRIORITY.index(language) if language in TITLE_PRIORITY else len(TITLE_PRIORITY)
+    path_rank = 1 if is_path_title_entity(entity) else 0
+    return path_rank, language_rank
+
+
+def label_migration_sources(target_label: str) -> Tuple[str, ...]:
+    """Return old-label candidates that can initialize a target label row."""
+    if target_label == "O":
+        return ("O",)
+
+    prefix, entity = split_bio_label(target_label)
+    if prefix is None or entity is None:
+        return (target_label,)
+
+    sources = [target_label]
+    if is_title_entity(entity):
+        sources.append(f"{prefix}-TITLE")
+    elif entity == "PATH_SEASON":
+        sources.append(f"{prefix}-SEASON")
+    return tuple(dict.fromkeys(sources))
+
+
+def infer_legacy_id2label(num_labels: int) -> Optional[Dict[int, str]]:
+    if num_labels == len(LEGACY_15_LABELS):
+        return {idx: label for idx, label in enumerate(LEGACY_15_LABELS)}
+    if num_labels == len(LABELS):
+        return make_id2label()
+    return None

snapshots/anifilebert-dapt512-long/anifilebert/model.py

@@ -0,0 +1,465 @@
+"""
+Tiny BERT models for anime filename token classification.
+
+The default linear token-classification head is kept for compatibility.  A
+learned linear-chain CRF head is also available for structural sequence-label
+training while preserving the same emission logits used by the thin runtime.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import List, Optional
+
+import torch
+from torch import nn
+from transformers import BertConfig, BertForTokenClassification, BertModel, BertPreTrainedModel
+from transformers.modeling_outputs import TokenClassifierOutput
+from transformers.modeling_utils import PreTrainedModel
+
+from .config import Config
+from .labels import infer_legacy_id2label, label_migration_sources
+
+
+class LinearChainCRF(nn.Module):
+    """A small batched linear-chain CRF for BIO token classification."""
+
+    def __init__(self, num_labels: int, id2label: Optional[dict] = None) -> None:
+        super().__init__()
+        self.num_labels = num_labels
+        self.start_transitions = nn.Parameter(torch.zeros(num_labels))
+        self.end_transitions = nn.Parameter(torch.zeros(num_labels))
+        self.transitions = nn.Parameter(torch.zeros(num_labels, num_labels))
+        self.register_buffer("start_allowed", torch.ones(num_labels, dtype=torch.bool))
+        self.register_buffer("transition_allowed", torch.ones(num_labels, num_labels, dtype=torch.bool))
+        if id2label:
+            self._configure_bio_masks(id2label)
+
+    @staticmethod
+    def _normalize_label_map(id2label: dict) -> dict[int, str]:
+        return {int(label_id): str(label) for label_id, label in id2label.items()}
+
+    def _configure_bio_masks(self, id2label: dict) -> None:
+        label_map = self._normalize_label_map(id2label)
+        for prev_id in range(self.num_labels):
+            prev_label = label_map.get(prev_id, "O")
+            self.start_allowed[prev_id] = not prev_label.startswith("I-")
+            for next_id in range(self.num_labels):
+                next_label = label_map.get(next_id, "O")
+                if next_label.startswith("I-"):
+                    entity = next_label[2:]
+                    allowed = prev_label in {f"B-{entity}", f"I-{entity}"}
+                else:
+                    allowed = True
+                self.transition_allowed[prev_id, next_id] = allowed
+
+    def neg_log_likelihood(
+        self,
+        emissions: torch.Tensor,
+        tags: torch.Tensor,
+        mask: torch.Tensor,
+    ) -> torch.Tensor:
+        """Return mean negative log likelihood for a padded batch."""
+        if emissions.ndim != 3:
+            raise ValueError("emissions must have shape [batch, seq, labels]")
+        if tags.shape != emissions.shape[:2]:
+            raise ValueError("tags must have shape [batch, seq]")
+        if mask.shape != tags.shape:
+            raise ValueError("mask must have shape [batch, seq]")
+
+        mask = mask.bool()
+        lengths = mask.long().sum(dim=1)
+        if torch.any(lengths == 0):
+            raise ValueError("CRF received an empty token sequence")
+
+        safe_tags = tags.masked_fill(~mask, 0)
+        log_partition = self._compute_log_partition(emissions, mask)
+        gold_score = self._compute_gold_score(emissions, safe_tags, mask, lengths)
+        return (log_partition - gold_score).mean()
+
+    def _compute_log_partition(self, emissions: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+        batch_size, sequence_length, _num_labels = emissions.shape
+        emissions = emissions.float()
+        start_transitions = self.start_transitions.float()
+        transition_scores = self.transitions.float()
+        scores = start_transitions + emissions[:, 0]
+
+        for idx in range(1, sequence_length):
+            next_scores = (
+                scores.unsqueeze(2)
+                + transition_scores.unsqueeze(0)
+                + emissions[:, idx].unsqueeze(1)
+            )
+            next_scores = torch.logsumexp(next_scores, dim=1)
+            scores = torch.where(mask[:, idx].unsqueeze(1), next_scores, scores)
+
+        scores = scores + self.end_transitions
+        return torch.logsumexp(scores, dim=1)
+
+    def _compute_gold_score(
+        self,
+        emissions: torch.Tensor,
+        tags: torch.Tensor,
+        mask: torch.Tensor,
+        lengths: torch.Tensor,
+    ) -> torch.Tensor:
+        emissions = emissions.float()
+        start_transitions = self.start_transitions.float()
+        transition_scores = self.transitions.float()
+        end_transitions = self.end_transitions.float()
+        batch_indices = torch.arange(emissions.shape[0], device=emissions.device)
+        score = start_transitions[tags[:, 0]]
+        score = score + emissions[batch_indices, 0, tags[:, 0]]
+
+        for idx in range(1, emissions.shape[1]):
+            transition_score = transition_scores[tags[:, idx - 1], tags[:, idx]]
+            emission_score = emissions[batch_indices, idx, tags[:, idx]]
+            score = score + (transition_score + emission_score) * mask[:, idx]
+
+        last_tag_indices = (lengths - 1).unsqueeze(1)
+        last_tags = tags.gather(1, last_tag_indices).squeeze(1)
+        return score + end_transitions[last_tags]
+
+    def decode(self, emissions: torch.Tensor, mask: torch.Tensor) -> List[List[int]]:
+        """Viterbi decode a padded batch and return variable-length label IDs."""
+        if emissions.ndim != 3:
+            raise ValueError("emissions must have shape [batch, seq, labels]")
+        mask = mask.bool()
+        lengths = mask.long().sum(dim=1)
+        if torch.any(lengths == 0):
+            raise ValueError("CRF received an empty token sequence")
+
+        start_transitions = self.start_transitions.masked_fill(~self.start_allowed, float("-inf"))
+        transition_scores = self.transitions.masked_fill(~self.transition_allowed, float("-inf"))
+        scores = start_transitions + emissions[:, 0]
+        history: List[torch.Tensor] = []
+
+        for idx in range(1, emissions.shape[1]):
+            next_scores = scores.unsqueeze(2) + transition_scores.unsqueeze(0)
+            best_scores, best_tags = next_scores.max(dim=1)
+            best_scores = best_scores + emissions[:, idx]
+            scores = torch.where(mask[:, idx].unsqueeze(1), best_scores, scores)
+            history.append(best_tags)
+
+        scores = scores + self.end_transitions
+        best_last_tags = scores.argmax(dim=1)
+
+        paths: List[List[int]] = []
+        for batch_idx in range(emissions.shape[0]):
+            length = int(lengths[batch_idx].item())
+            best_tag = int(best_last_tags[batch_idx].item())
+            path = [best_tag]
+            for hist in reversed(history[: max(0, length - 1)]):
+                best_tag = int(hist[batch_idx, best_tag].item())
+                path.append(best_tag)
+            path.reverse()
+            paths.append(path)
+        return paths
+
+
+class BertCrfForTokenClassification(BertPreTrainedModel):
+    """BERT emission classifier trained with a learned CRF sequence loss."""
+
+    config_class = BertConfig
+
+    def __init__(self, config: BertConfig) -> None:
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.bert = BertModel(config, add_pooling_layer=False)
+        classifier_dropout = getattr(config, "classifier_dropout", None)
+        dropout_prob = classifier_dropout if classifier_dropout is not None else config.hidden_dropout_prob
+        self.dropout = nn.Dropout(dropout_prob)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+        self.crf = LinearChainCRF(config.num_labels, getattr(config, "id2label", None))
+        self.post_init()
+        # Keep CRF transitions neutral when bootstrapping from a linear checkpoint.
+        nn.init.zeros_(self.crf.start_transitions)
+        nn.init.zeros_(self.crf.end_transitions)
+        nn.init.zeros_(self.crf.transitions)
+
+    def _crf_inputs(
+        self,
+        logits: torch.Tensor,
+        labels: Optional[torch.Tensor],
+        attention_mask: Optional[torch.Tensor],
+    ) -> tuple[torch.Tensor, Optional[torch.Tensor], torch.Tensor]:
+        if logits.shape[1] <= 2:
+            raise ValueError("CRF token classification expects CLS, tokens, and SEP positions")
+        emissions = logits[:, 1:-1, :]
+        if attention_mask is None:
+            if labels is None:
+                mask = torch.ones(emissions.shape[:2], dtype=torch.bool, device=logits.device)
+            else:
+                mask = labels[:, 1:-1].ne(-100)
+        else:
+            if labels is None:
+                real_lengths = attention_mask.long().sum(dim=1).clamp_min(2) - 2
+                positions = torch.arange(emissions.shape[1], device=logits.device).unsqueeze(0)
+                mask = positions < real_lengths.unsqueeze(1)
+            else:
+                mask = attention_mask[:, 1:-1].bool()
+                mask = mask & labels[:, 1:-1].ne(-100)
+        tags = labels[:, 1:-1] if labels is not None else None
+        return emissions, tags, mask
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> TokenClassifierOutput:
+        return_dict = return_dict if return_dict is not None else getattr(self.config, "return_dict", True)
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = self.dropout(outputs[0])
+        logits = self.classifier(sequence_output)
+
+        loss = None
+        if labels is not None:
+            emissions, tags, mask = self._crf_inputs(logits, labels, attention_mask)
+            if tags is None:
+                raise ValueError("labels are required for CRF loss")
+            loss = self.crf.neg_log_likelihood(emissions, tags, mask)
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+        return TokenClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def decode(self, logits: torch.Tensor, attention_mask: Optional[torch.Tensor] = None) -> List[List[int]]:
+        """Decode full-sequence logits, excluding CLS/SEP and padding positions."""
+        emissions, _tags, mask = self._crf_inputs(logits, None, attention_mask)
+        return self.crf.decode(emissions, mask)
+
+
+def build_bert_config(config: Config) -> BertConfig:
+    """Build the Hugging Face BERT config shared by both model heads."""
+    return BertConfig(
+        vocab_size=config.vocab_size,
+        hidden_size=config.hidden_size,
+        num_hidden_layers=config.num_hidden_layers,
+        num_attention_heads=config.num_attention_heads,
+        intermediate_size=config.intermediate_size,
+        max_position_embeddings=config.max_position_embeddings,
+        num_labels=config.num_labels,
+        hidden_dropout_prob=config.hidden_dropout_prob,
+        attention_probs_dropout_prob=config.attention_probs_dropout_prob,
+        id2label=config.id2label,
+        label2id=config.label2id,
+        label_schema_version=config.label_schema_version,
+    )
+
+
+def normalize_model_head(model_head: Optional[str]) -> str:
+    head = (model_head or "linear").strip().lower()
+    if head not in {"linear", "crf"}:
+        raise ValueError(f"Unsupported model head: {model_head}")
+    return head
+
+
+def create_model(config: Config, model_head: str = "linear") -> PreTrainedModel:
+    """
+    Create a Tiny BERT model for token classification.
+
+    Args:
+        config: Config object with model hyperparameters.
+        model_head: ``linear`` for Hugging Face's standard token classifier or
+            ``crf`` for a learned linear-chain CRF sequence head.
+    """
+    head = normalize_model_head(model_head)
+    bert_config = build_bert_config(config)
+    bert_config.model_head = head
+    if head == "crf":
+        bert_config.architectures = ["BertCrfForTokenClassification"]
+        return BertCrfForTokenClassification(bert_config)
+    bert_config.architectures = ["BertForTokenClassification"]
+    return BertForTokenClassification(bert_config)
+
+
+def infer_model_head(config: BertConfig) -> str:
+    head = getattr(config, "model_head", None)
+    if head:
+        return normalize_model_head(str(head))
+    architectures = getattr(config, "architectures", None) or []
+    if any("Crf" in str(architecture) or "CRF" in str(architecture) for architecture in architectures):
+        return "crf"
+    return "linear"
+
+
+def load_model(model_dir: str, model_head: Optional[str] = None) -> PreTrainedModel:
+    """Load a linear or CRF token classifier from a Hugging Face checkpoint."""
+    config = BertConfig.from_pretrained(model_dir)
+    head = normalize_model_head(model_head) if model_head is not None else infer_model_head(config)
+    if head == "crf":
+        return BertCrfForTokenClassification.from_pretrained(model_dir)
+    return BertForTokenClassification.from_pretrained(model_dir)
+
+
+def _model_id2label_for_migration(model: PreTrainedModel) -> dict[int, str]:
+    raw_id2label = getattr(model.config, "id2label", None) or {}
+    normalized = {int(label_id): str(label) for label_id, label in raw_id2label.items()}
+    classifier = getattr(model, "classifier", None)
+    out_features = getattr(classifier, "out_features", None)
+    if out_features is not None and len(normalized) != int(out_features):
+        inferred = infer_legacy_id2label(int(out_features))
+        if inferred is not None:
+            return inferred
+    return normalized
+
+
+def migrate_token_classifier_labels(
+    model: PreTrainedModel,
+    target_label2id: dict[str, int],
+    target_id2label: dict[int, str],
+) -> dict[str, object]:
+    """
+    Expand or reorder token-classification label rows for the shared schema.
+
+    Exact labels are copied by name. Legacy 15-label TITLE rows initialize all
+    title-like rows, and legacy SEASON rows initialize PATH_SEASON.
+    """
+    classifier = getattr(model, "classifier", None)
+    if classifier is None or not isinstance(classifier, nn.Linear):
+        return {"changed": False, "reason": "no_linear_classifier"}
+
+    target_id2label = {int(label_id): str(label) for label_id, label in target_id2label.items()}
+    target_label2id = {str(label): int(label_id) for label, label_id in target_label2id.items()}
+    old_id2label = _model_id2label_for_migration(model)
+    old_label2id = {label: label_id for label_id, label in old_id2label.items()}
+    old_num_labels = int(classifier.out_features)
+    new_num_labels = len(target_label2id)
+
+    same_schema = (
+        old_num_labels == new_num_labels
+        and all(old_id2label.get(idx) == target_id2label.get(idx) for idx in range(new_num_labels))
+    )
+    if same_schema:
+        model.config.num_labels = new_num_labels
+        model.config.id2label = target_id2label
+        model.config.label2id = target_label2id
+        return {"changed": False, "copied": new_num_labels, "target_labels": new_num_labels}
+
+    old_weight = classifier.weight.detach()
+    old_bias = classifier.bias.detach() if classifier.bias is not None else None
+    new_classifier = nn.Linear(
+        classifier.in_features,
+        new_num_labels,
+        bias=classifier.bias is not None,
+        device=old_weight.device,
+        dtype=old_weight.dtype,
+    )
+    nn.init.normal_(
+        new_classifier.weight,
+        mean=0.0,
+        std=getattr(model.config, "initializer_range", 0.02),
+    )
+    if new_classifier.bias is not None:
+        nn.init.zeros_(new_classifier.bias)
+
+    row_sources: dict[int, int] = {}
+    copied = 0
+    for target_label, target_id in target_label2id.items():
+        for source_label in label_migration_sources(target_label):
+            source_id = old_label2id.get(source_label)
+            if source_id is None or source_id >= old_num_labels:
+                continue
+            new_classifier.weight.data[target_id].copy_(old_weight[source_id])
+            if new_classifier.bias is not None and old_bias is not None:
+                new_classifier.bias.data[target_id].copy_(old_bias[source_id])
+            row_sources[target_id] = source_id
+            copied += 1
+            break
+
+    model.classifier = new_classifier
+    model.num_labels = new_num_labels
+    model.config.num_labels = new_num_labels
+    model.config.id2label = target_id2label
+    model.config.label2id = target_label2id
+
+    if hasattr(model, "crf"):
+        old_crf = model.crf
+        new_crf = LinearChainCRF(new_num_labels, target_id2label).to(
+            device=old_weight.device,
+            dtype=old_weight.dtype,
+        )
+        nn.init.zeros_(new_crf.start_transitions)
+        nn.init.zeros_(new_crf.end_transitions)
+        nn.init.zeros_(new_crf.transitions)
+        with torch.no_grad():
+            for target_id, source_id in row_sources.items():
+                if source_id < old_crf.start_transitions.shape[0]:
+                    new_crf.start_transitions[target_id].copy_(old_crf.start_transitions[source_id])
+                    new_crf.end_transitions[target_id].copy_(old_crf.end_transitions[source_id])
+            for target_to_id, source_to_id in row_sources.items():
+                for target_from_id, source_from_id in row_sources.items():
+                    if (
+                        source_from_id < old_crf.transitions.shape[0]
+                        and source_to_id < old_crf.transitions.shape[1]
+                    ):
+                        new_crf.transitions[target_from_id, target_to_id].copy_(
+                            old_crf.transitions[source_from_id, source_to_id]
+                        )
+        model.crf = new_crf
+
+    return {
+        "changed": True,
+        "source_labels": old_num_labels,
+        "target_labels": new_num_labels,
+        "copied": copied,
+    }
+
+
+def save_model_head_config(model: PreTrainedModel, model_head: str) -> None:
+    """Persist the selected head in config.json for later auto-loading."""
+    head = normalize_model_head(model_head)
+    model.config.model_head = head
+    model.config.architectures = [
+        "BertCrfForTokenClassification" if head == "crf" else "BertForTokenClassification"
+    ]
+
+
+def count_parameters(model) -> int:
+    """Count total trainable parameters in a model."""
+    return sum(p.numel() for p in model.parameters())
+
+
+def print_model_summary(model):
+    """Print model architecture summary with parameter count."""
+    total_params = count_parameters(model)
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"Total parameters: {total_params:,}")
+    print(f"Trainable parameters: {trainable_params:,}")
+    print(f"Parameter limit: 5,000,000")
+    if total_params < 5_000_000:
+        print(f"[OK] Within 5M limit ({(5_000_000 - total_params):,} remaining)")
+    else:
+        print(f"[FAIL] Exceeds 5M limit by {total_params - 5_000_000:,}")
+    return total_params
+
+
+if __name__ == "__main__":
+    cfg = Config()
+    cfg.vocab_size = 3000
+    model = create_model(cfg, model_head=os.environ.get("ANIFILEBERT_MODEL_HEAD", "linear"))
+    print_model_summary(model)

snapshots/anifilebert-dapt512-long/anifilebert/tokenizer.py

@@ -0,0 +1,411 @@
+"""
+Custom tokenizers for anime filenames.
+
+AnimeTokenizer keeps the original regex-based structure tokenization:
+1. Bracket protection: [...], (...), 【...】, 《...》 are kept as single tokens
+2. Format token recognition: S2, 1080P, x265, WEB-DL, etc. are preserved
+3. Remainder splitting: separators, Chinese/Japanese char-level, English/number tokens
+
+CharAnimeTokenizer is the A/B variant that tokenizes every code point as its
+own token. Dataset alignment expands existing token-level BIO labels to match
+this tokenizer, so the same generated and real-world JSONL files can be reused.
+"""
+
+import re
+import json
+import os
+from typing import Dict, List, Optional, Tuple, Set
+from transformers import PreTrainedTokenizer
+
+
+class AnimeTokenizer(PreTrainedTokenizer):
+    """
+    Custom regex-based tokenizer for anime filenames.
+    Inherits from PreTrainedTokenizer for HuggingFace Trainer compatibility.
+    """
+
+    # Required for PreTrainedTokenizer save/load mechanism
+    vocab_files_names: Dict[str, str] = {"vocab_file": "vocab.json"}
+    tokenizer_variant: str = "regex"
+
+    # Layer 1: Bracket patterns (kept whole)
+    BRACKET_PATTERNS: List[str] = [
+        r'\[[^\]]*\]',     # [...]
+        r'\([^\)]*\)',     # (...)
+        r'【[^】]*】',      # 【...】
+        r'《[^》]*》',      # 《...》
+    ]
+
+    # Composite format patterns (checked before individual, higher priority).
+    #
+    # Keep this empty for S01E01-style names: token classification needs separate
+    # S01 and E01 tokens so the model can label season and episode independently.
+    COMPOSITE_FORMAT_PATTERNS: List[str] = []
+
+    # Layer 2: Individual format token patterns
+    FORMAT_PATTERNS: List[str] = [
+        # Resolution
+        r'(?<![A-Za-z0-9])\d{3,4}[pP](?![A-Za-z0-9])',
+        r'(?<![A-Za-z0-9])\d{3,4}[xX×]\d{3,4}(?![A-Za-z0-9])',
+        r'(?<![A-Za-z0-9])\d[Kk](?![A-Za-z0-9])',
+
+        # Codec
+        r'[xX]26[45]',
+        r'HEVC', r'AVC', r'AV1',
+        r'[hH]\.?26[45]',
+
+        # Audio
+        r'FLAC', r'AAC', r'MP3', r'DTS', r'Opus',
+
+        # Season
+        r'Seasons?\s*\d+',
+        r'第[一二三四五六七八九十\d]+季',
+        r'\d+(?:st|nd|rd|th)\s+Season',
+        r'[Ss]\d+',
+
+        # Episode
+        r'[Ee][Pp]?\d+',
+        r'#\d+',
+        r'第\d+[话話]',
+        r'\d+[Vv]\d*',
+
+        # Language
+        r'CH[ST]',
+        r'简[体體]',
+        r'繁[体體]',
+        r'JP', r'GB', r'BIG5',
+        r'简日双语',
+
+        # Source
+        r'WEB[-_]?DL',
+        r'BDRip', r'DVDRip', r'TVRip',
+        r'Baha', r'Netflix', r'AMZN', r'CR', r'WebRip',
+
+        # Aspect ratio
+        r'\d+:\d+',
+    ]
+
+    # Layer 3: Separators for splitting
+    SEPARATORS: Set[str] = set(' -_|～~.')
+
+    def __init__(self, vocab_file: Optional[str] = None, **kwargs):
+        kwargs.pop("tokenizer_variant", None)
+        kwargs.pop("backend", None)
+
+        self._vocab: Dict[str, int] = {}
+        self._ids_to_tokens: Dict[int, str] = {}
+
+        # Load vocab from file if provided
+        if vocab_file is not None and os.path.isfile(vocab_file):
+            with open(vocab_file, 'r', encoding='utf-8') as f:
+                loaded = json.load(f)
+            self._vocab = loaded
+            self._ids_to_tokens = {int(v): k for k, v in loaded.items()}
+
+        # Initialize PreTrainedTokenizer with special tokens.
+        # Only set defaults for tokens not already provided via kwargs
+        # (from_pretrained may pass these through).
+        special_kwargs = {}
+        for token_name, token_value in [
+            ('pad_token', '[PAD]'),
+            ('unk_token', '[UNK]'),
+            ('cls_token', '[CLS]'),
+            ('sep_token', '[SEP]'),
+        ]:
+            if token_name not in kwargs:
+                special_kwargs[token_name] = token_value
+
+        super().__init__(**special_kwargs, **kwargs)
+        self.init_kwargs["backend"] = "custom"
+        self.init_kwargs["tokenizer_variant"] = self.tokenizer_variant
+
+        # Compile regex patterns for efficiency
+        self._bracket_re = re.compile('|'.join(self.BRACKET_PATTERNS))
+        self._composite_format_re = (
+            re.compile('|'.join(self.COMPOSITE_FORMAT_PATTERNS))
+            if self.COMPOSITE_FORMAT_PATTERNS else None
+        )
+        self._format_re = re.compile('|'.join(self.FORMAT_PATTERNS))
+
+    # ---- Properties ----
+
+    @property
+    def vocab_size(self) -> int:
+        return len(self._vocab)
+
+    # ---- Tokenization (3-layer pipeline) ----
+
+    def tokenize(self, text: str, **kwargs) -> List[str]:
+        """
+        Tokenize an anime filename into a list of tokens.
+
+        Uses a 3-layer pipeline:
+        1. Bracket protection (kept whole)
+        2. Format token recognition (composite then individual)
+        3. Remainder splitting (separators, char-level for CJK)
+        """
+        if not text or not text.strip():
+            return []
+
+        placeholder_counter = [0]
+        placeholders: Dict[int, str] = {}
+
+        def _ph(idx: int) -> str:
+            return f'\x00{idx}\x00'
+
+        def _replace_match(m: re.Match) -> str:
+            idx = placeholder_counter[0]
+            placeholder_counter[0] += 1
+            placeholders[idx] = m.group()
+            return _ph(idx)
+
+        # Layer 1: Extract bracket content as whole tokens
+        processed = self._bracket_re.sub(_replace_match, text)
+
+        # Layer 2a: Composite format patterns (e.g. S01E01 before S01)
+        if self._composite_format_re is not None:
+            processed = self._composite_format_re.sub(_replace_match, processed)
+
+        # Layer 2b: Individual format tokens
+        processed = self._format_re.sub(_replace_match, processed)
+
+        # Layer 3a: Split remainder by separators
+        separator_pattern = '|'.join(re.escape(s) for s in sorted(self.SEPARATORS, key=len, reverse=True))
+        # Use capturing group to keep separators
+        remaining_parts = re.split(f'({separator_pattern})', processed)
+
+        # Layer 3b: Process each part
+        result: List[str] = []
+        for part in remaining_parts:
+            if not part:
+                continue
+
+            if part in self.SEPARATORS:
+                result.append(part)
+            elif '\x00' in part:
+                # Extract all placeholder tokens from this part
+                # Handles consecutive placeholders like \x001\x00\x002\x00
+                ph_pattern = re.compile(r'\x00(\d+)\x00')
+                last_end = 0
+                for m in ph_pattern.finditer(part):
+                    # Add any non-placeholder text before this match
+                    if m.start() > last_end:
+                        before = part[last_end:m.start()]
+                        result.extend(self._split_fragment(before))
+                    idx = int(m.group(1))
+                    if idx in placeholders:
+                        result.append(placeholders[idx])
+                    last_end = m.end()
+                # Add any remaining text after the last placeholder
+                if last_end < len(part):
+                    after = part[last_end:]
+                    result.extend(self._split_fragment(after))
+            else:
+                # Split remaining text by character type
+                result.extend(self._split_fragment(part))
+
+        return result
+
+    def _split_fragment(self, fragment: str) -> List[str]:
+        """
+        Split a text fragment by character type:
+        - Chinese chars → individual characters
+        - Japanese kana → individual characters
+        - ASCII letters → whole word
+        - Digits → whole number
+        - Other → individual characters
+        """
+        tokens: List[str] = []
+        i = 0
+        n = len(fragment)
+
+        while i < n:
+            ch = fragment[i]
+
+            # Chinese characters (CJK Unified Ideographs + Extension A)
+            if '\u4e00' <= ch <= '\u9fff' or '\u3400' <= ch <= '\u4dbf':
+                tokens.append(ch)
+                i += 1
+            # Japanese hiragana
+            elif '\u3040' <= ch <= '\u309f':
+                tokens.append(ch)
+                i += 1
+            # Japanese katakana
+            elif '\u30a0' <= ch <= '\u30ff':
+                tokens.append(ch)
+                i += 1
+            # ASCII letter sequence (kept whole)
+            elif ch.isascii() and ch.isalpha():
+                j = i
+                while j < n and fragment[j].isascii() and fragment[j].isalpha():
+                    j += 1
+                tokens.append(fragment[i:j])
+                i = j
+            # Digit sequence (kept whole)
+            elif ch.isdigit():
+                j = i
+                while j < n and fragment[j].isdigit():
+                    j += 1
+                tokens.append(fragment[i:j])
+                i = j
+            else:
+                # Other character (punctuation, symbols, etc.)
+                tokens.append(ch)
+                i += 1
+
+        return tokens
+
+    # ---- Vocabulary Management ----
+
+    def build_vocab(
+        self,
+        tokens_list: List[List[str]],
+        max_size: Optional[int] = None,
+        base_vocab: Optional[Dict[str, int]] = None,
+    ) -> None:
+        """
+        Build vocabulary from a list of tokenized texts.
+
+        Args:
+            tokens_list: List of token lists from tokenize() output.
+            max_size: Optional cap including special tokens.
+            base_vocab: Optional existing vocabulary whose token IDs are preserved.
+        """
+        freq: Dict[str, int] = {}
+        for tokens in tokens_list:
+            for token in tokens:
+                freq[token] = freq.get(token, 0) + 1
+
+        # Start with special tokens at fixed positions, preserving any supplied
+        # base vocabulary so a checkpoint can be fine-tuned after adding tokens.
+        vocab: Dict[str, int] = dict(base_vocab or {})
+        for token, token_id in {
+            '[PAD]': 0,
+            '[UNK]': 1,
+            '[CLS]': 2,
+            '[SEP]': 3,
+        }.items():
+            vocab[token] = token_id
+
+        # Add all tokens sorted by frequency descending
+        next_id = max(vocab.values(), default=-1) + 1
+        for token in sorted(freq, key=lambda t: (-freq[t], t)):
+            if token not in vocab:
+                if max_size is not None and len(vocab) >= max_size:
+                    break
+                vocab[token] = next_id
+                next_id += 1
+
+        self._vocab = vocab
+        self._ids_to_tokens = {v: k for k, v in vocab.items()}
+
+    # ---- Token-ID Conversion ----
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self._vocab.get(token, self.unk_token_id if self.unk_token_id is not None else 1)
+
+    def _convert_id_to_token(self, index: int) -> str:
+        return self._ids_to_tokens.get(index, self.unk_token if self.unk_token else '[UNK]')
+
+    def get_vocab(self) -> Dict[str, int]:
+        return dict(self._vocab)
+
+    # ---- Save / Load ----
+
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
+        """Save vocabulary to a JSON file. Required by PreTrainedTokenizer."""
+        file_path = os.path.join(
+            save_directory,
+            f"{filename_prefix or ''}vocab.json"
+        )
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(self._vocab, f, ensure_ascii=False, indent=2)
+        return (file_path,)
+
+    # ---- Utility ----
+
+    def __len__(self) -> int:
+        return len(self._vocab)
+
+    def __str__(self) -> str:
+        return f"AnimeTokenizer(vocab_size={self.vocab_size})"
+
+
+class CharAnimeTokenizer(AnimeTokenizer):
+    """
+    Character-level tokenizer for A/B testing.
+
+    Unlike AnimeTokenizer, this variant does not preserve bracketed groups,
+    English words, numbers, or format tags. Every character in the filename is
+    one token, which gives the model maximum visibility into real fansub names.
+    """
+
+    tokenizer_variant: str = "char"
+
+    def tokenize(self, text: str, **kwargs) -> List[str]:
+        if text is None or text == "":
+            return []
+        return list(text)
+
+    def __str__(self) -> str:
+        return f"CharAnimeTokenizer(vocab_size={self.vocab_size})"
+
+
+TOKENIZER_VARIANTS = {
+    "regex": AnimeTokenizer,
+    "char": CharAnimeTokenizer,
+}
+
+
+def create_tokenizer(
+    variant: str = "regex",
+    vocab_file: Optional[str] = None,
+    **kwargs,
+) -> AnimeTokenizer:
+    """Create a tokenizer by variant name."""
+    try:
+        tokenizer_cls = TOKENIZER_VARIANTS[variant]
+    except KeyError as exc:
+        supported = ", ".join(sorted(TOKENIZER_VARIANTS))
+        raise ValueError(f"Unsupported tokenizer variant '{variant}'. Expected one of: {supported}") from exc
+    return tokenizer_cls(vocab_file=vocab_file, **kwargs)
+
+
+def load_tokenizer(model_dir: str, variant: Optional[str] = None) -> AnimeTokenizer:
+    """
+    Load a tokenizer from a checkpoint directory.
+
+    The variant is read from tokenizer_config.json when available. Older
+    checkpoints do not contain it, so they default to the original regex mode.
+    """
+    resolved_variant = variant
+    if resolved_variant is None:
+        config_path = os.path.join(model_dir, "tokenizer_config.json")
+        if os.path.isfile(config_path):
+            with open(config_path, "r", encoding="utf-8") as f:
+                resolved_variant = json.load(f).get("tokenizer_variant")
+    tokenizer_cls = TOKENIZER_VARIANTS.get(resolved_variant or "regex", AnimeTokenizer)
+    return tokenizer_cls.from_pretrained(model_dir)
+
+
+# Quick test
+if __name__ == "__main__":
+    tokenizer = AnimeTokenizer()
+
+    test_cases = [
+        "[ANi] 葬送的芙莉莲 S2 - 03 [1080P][WEB-DL]",
+        "[SubsPlease] Mushoku Tensei - 12 (1080p) [x265][AAC]",
+        "【喵萌奶茶屋】★04月新番★[葬送的芙莉莲][01][1080P][HEVC]",
+        "Sousou no Frieren S01E01 [BDRip 1920x1080 FLAC]",
+        "[VCB-Studio] Girls Band Cry [01][Ma10p_1080p][x265_flac]",
+        "86 Eighty Six - 01 [1080P][Baha]",
+        "",
+        "test",
+    ]
+
+    for case in test_cases:
+        toks = tokenizer.tokenize(case)
+        print(f"Input:  {case}")
+        print(f"Tokens: {toks}")
+        print()
+

snapshots/anifilebert-dapt512-long/anifilebert/train.py

@@ -0,0 +1,1838 @@
+"""
+Train AniFileBERT for structured anime filename parsing.
+
+The training loop keeps the existing PyTorch/Transformers stack, writes
+Hugging Face checkpoints, records token/entity metrics, and also evaluates
+end-to-end parser exact-match on held-out filenames and fixed real-world cases.
+"""
+
+import os
+import sys
+import json
+import argparse
+import random
+import subprocess
+import threading
+import time
+import gc
+from collections import Counter
+from ctypes import POINTER, Structure, byref, c_int, c_uint, c_ulonglong, c_void_p, cdll
+from ctypes import util as ctypes_util
+from typing import Dict, List, Optional, Sequence
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import SequentialSampler
+from transformers import (
+    Trainer,
+    TrainingArguments,
+    TrainerCallback,
+)
+from seqeval.metrics import classification_report, accuracy_score, f1_score, precision_score, recall_score
+
+from .config import Config
+from .tokenizer import AnimeTokenizer, create_tokenizer, load_tokenizer
+from .model import (
+    create_model,
+    print_model_summary,
+    count_parameters,
+    load_model,
+    migrate_token_classifier_labels,
+    save_model_head_config,
+)
+from .dataset import AnimeItemsDataset, EncodedAnimeDataset, labels_for_tokenizer
+from .inference import parse_filename, postprocess
+from .labels import (
+    canonical_entity,
+    canonical_bio_label,
+    is_season_like_label,
+    is_title_entity,
+)
+from .virtual_dataset import DatasetRangeView, ShardedEncodedDataset
+
+
+def compute_metrics(p):
+    """Compute token-level and entity-level metrics using seqeval."""
+    predictions, labels = p
+    predictions = np.argmax(predictions, axis=2)
+
+    # Remove ignored index (special tokens)
+    true_predictions = []
+    true_labels = []
+
+    id2label = Config().id2label
+
+    for pred_seq, label_seq in zip(predictions, labels):
+        preds = []
+        lbls = []
+        for p, l in zip(pred_seq, label_seq):
+            if l != -100:
+                preds.append(id2label[p])
+                lbls.append(id2label[l])
+        true_predictions.append(preds)
+        true_labels.append(lbls)
+
+    # Entity-level metrics (via seqeval)
+    return {
+        "precision": precision_score(true_labels, true_predictions),
+        "recall": recall_score(true_labels, true_predictions),
+        "f1": f1_score(true_labels, true_predictions),
+        "accuracy": accuracy_score(true_labels, true_predictions),
+    }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Train anime filename parser")
+    parser.add_argument("--tokenizer", choices=["regex", "char"], default=None,
+                        help="Tokenizer variant for A/B testing. Defaults to dataset metadata")
+    parser.add_argument("--data-file", default=None, help="Primary training JSONL file")
+    parser.add_argument("--extra-data-file", action="append", default=[],
+                        help="Additional training JSONL file. Can be passed multiple times.")
+    parser.add_argument("--extra-data-repeat", type=int, default=1,
+                        help="Repeat each extra dataset this many times after loading")
+    parser.add_argument("--virtual-dataset-dir", default=None,
+                        help="Pre-encoded shard directory generated by tools/virtual_dataset_generator")
+    parser.add_argument("--encoded-cache-dir", default=None,
+                        help="Split train/eval encoded shard cache generated by tools/encoded_dataset_cache")
+    parser.add_argument("--vocab-file", default=None,
+                        help="Tokenizer vocab JSON. Defaults to data/vocab.json or data/vocab.char.json")
+    parser.add_argument("--save-dir", default=None, help="Checkpoint output directory")
+    parser.add_argument("--init-model-dir", default=None, help="Optional checkpoint to fine-tune from")
+    parser.add_argument("--model-head", choices=["auto", "linear", "crf"], default="auto",
+                        help="Token classification head. 'crf' trains a learned linear-chain CRF loss.")
+    parser.add_argument("--train-crf-only", action="store_true",
+                        help="Freeze BERT and classifier weights and train only CRF transitions.")
+    parser.add_argument("--rdrop-alpha", type=float, default=0.0,
+                        help="Symmetric KL weight for R-Drop regularization; 0 disables it.")
+    parser.add_argument("--epochs", type=float, default=None, help="Number of training epochs")
+    parser.add_argument("--max-steps", type=int, default=-1,
+                        help="Override epoch-based training and stop after this many optimizer steps")
+    parser.add_argument("--batch-size", type=int, default=None, help="Per-device train/eval batch size")
+    parser.add_argument("--learning-rate", type=float, default=None, help="Learning rate")
+    parser.add_argument("--warmup-steps", type=int, default=None, help="Warmup steps")
+    parser.add_argument("--train-split", type=float, default=None, help="Train split ratio")
+    parser.add_argument("--max-seq-length", type=int, default=None, help="Maximum sequence length")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument("--limit-samples", type=int, default=None,
+                        help="Use only the first N samples for quick A/B smoke runs")
+    parser.add_argument("--augment-partial-samples", type=int, default=0,
+                        help="Generate this many partial BIO-span samples in memory before training")
+    parser.add_argument("--augment-permutation-samples", type=int, default=0,
+                        help="Generate this many random BIO-span permutation samples in memory before training")
+    parser.add_argument("--augment-special-samples", type=int, default=0,
+                        help="Generate this many special-only/title+special samples such as Menu01 in memory")
+    parser.add_argument("--augment-max-chars", type=int, default=160,
+                        help="Maximum character length for generated augmentation samples")
+    parser.add_argument("--rebuild-vocab", action="store_true",
+                        help="Rebuild vocab from the selected data file before training")
+    parser.add_argument("--max-vocab-size", type=int, default=None,
+                        help="Optional vocab cap used with --rebuild-vocab")
+    parser.add_argument("--checkpoint-steps", type=int, default=None,
+                        help="Save resumable checkpoints every N steps instead of only at epoch end")
+    parser.add_argument("--save-total-limit", type=int, default=2,
+                        help="Maximum number of checkpoints to keep")
+    parser.add_argument("--no-periodic-eval", action="store_true",
+                        help="Skip Trainer's scheduled train-time eval/load-best-model; final evaluation still runs")
+    parser.add_argument("--keep-raw-dataset", action="store_true",
+                        help="Keep raw JSONL dictionaries in memory after encoded datasets are built")
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=1,
+                        help="Accumulate gradients across this many steps")
+    parser.add_argument("--num-workers", type=int, default=None,
+                        help="DataLoader worker count. Defaults to config.num_workers")
+    parser.add_argument("--prefetch-factor", type=int, default=None,
+                        help="DataLoader prefetch factor when workers are enabled")
+    parser.add_argument("--persistent-workers", action="store_true",
+                        help="Keep DataLoader workers alive between epochs")
+    parser.add_argument("--lazy-dataset", action="store_true",
+                        help="Tokenize samples lazily in DataLoader workers instead of pre-encoding tensors")
+    parser.add_argument("--apply-label-repairs", action="store_true",
+                        help="Apply runtime deterministic label repairs while building training tensors")
+    parser.add_argument("--encoded-dataset-device", choices=["cpu", "cuda"], default="cpu",
+                        help="Store pre-encoded dataset tensors on this device; cuda requires --num-workers 0")
+    parser.add_argument("--bf16", action="store_true",
+                        help="Use bfloat16 mixed precision on CUDA instead of fp16")
+    parser.add_argument("--no-mixed-precision", action="store_true",
+                        help="Disable fp16/bf16 mixed precision even when CUDA is available")
+    parser.add_argument("--tf32", dest="tf32", action="store_true",
+                        help="Enable TF32 matmul/cudnn kernels on CUDA")
+    parser.add_argument("--no-tf32", dest="tf32", action="store_false",
+                        help="Disable TF32 matmul/cudnn kernels")
+    parser.add_argument("--torch-compile", action="store_true",
+                        help="Enable torch.compile through Hugging Face Trainer")
+    parser.add_argument("--auto-find-batch-size", action="store_true",
+                        help="Let Trainer reduce batch size automatically on CUDA OOM")
+    parser.add_argument("--perf-log-steps", type=int, default=100,
+                        help="Sample training throughput, memory, and GPU stats every N steps; 0 disables")
+    parser.add_argument("--perf-sample-interval", type=float, default=1.0,
+                        help="Background NVML sampling interval in seconds during training; 0 disables")
+    parser.add_argument("--cpu", action="store_true", help="Force CPU training")
+    parser.add_argument("--no-shuffle", action="store_true", help="Do not shuffle before train/eval split")
+    parser.add_argument("--resume-from-checkpoint", default=None,
+                        help="Resume Trainer state from a checkpoint directory, or 'auto' for the latest checkpoint")
+    parser.add_argument("--tensorboard", dest="tensorboard", action="store_true",
+                        help="Log metrics to TensorBoard in addition to stdout/checkpoints")
+    parser.add_argument("--no-tensorboard", dest="tensorboard", action="store_false",
+                        help="Disable TensorBoard logging")
+    parser.add_argument("--experiment-name", default=None,
+                        help="Optional experiment name written to run_metadata.json")
+    parser.add_argument("--parse-eval-limit", type=int, default=512,
+                        help="Run field exact-match evaluation on up to N eval samples after training; 0 disables it")
+    parser.add_argument("--case-eval-file", default=os.path.join("data", "parser_regression_cases.json"),
+                        help="Fixed real-world parser regression case file evaluated after training")
+    parser.add_argument("--case-eval-output", default=None,
+                        help="Optional output path for fixed case metrics; defaults to final/case_metrics.json")
+    parser.add_argument("--no-case-eval", action="store_true",
+                        help="Skip fixed real-world parser regression evaluation")
+    parser.add_argument("--hidden-size", type=int, default=None, help="Override BERT hidden size")
+    parser.add_argument("--num-hidden-layers", type=int, default=None, help="Override BERT layer count")
+    parser.add_argument("--num-attention-heads", type=int, default=None, help="Override BERT attention heads")
+    parser.add_argument("--intermediate-size", type=int, default=None, help="Override BERT FFN intermediate size")
+    parser.set_defaults(tf32=True)
+    parser.set_defaults(tensorboard=True)
+    return parser.parse_args()
+
+
+def detect_tokenizer_variant(
+    data_file: str,
+    explicit_variant: Optional[str],
+    explicit_vocab_path: Optional[str],
+    sample_size: int = 256,
+) -> str:
+    """Infer tokenizer variant from CLI, dataset metadata, or vocab filename."""
+    if explicit_variant:
+        return explicit_variant
+
+    variants = set()
+    char_like = 0
+    inspected = 0
+    with open(data_file, "r", encoding="utf-8") as f:
+        for line in f:
+            if inspected >= sample_size:
+                break
+            line = line.strip()
+            if not line:
+                continue
+            item = json.loads(line)
+            inspected += 1
+            variant = item.get("tokenizer_variant")
+            if variant:
+                variants.add(variant)
+            tokens = item.get("tokens", [])
+            filename = item.get("filename")
+            if filename is not None and tokens == list(filename):
+                char_like += 1
+
+    if len(variants) == 1:
+        return next(iter(variants))
+    if len(variants) > 1:
+        raise ValueError(f"Mixed tokenizer_variant values in {data_file}: {sorted(variants)}")
+    if explicit_vocab_path and ".char" in os.path.basename(explicit_vocab_path).lower():
+        return "char"
+    if inspected and char_like / inspected >= 0.95:
+        return "char"
+    return "regex"
+
+
+def detect_tokenizer_variant_from_files(
+    data_files: List[str],
+    explicit_variant: Optional[str],
+    explicit_vocab_path: Optional[str],
+) -> str:
+    if explicit_variant:
+        return explicit_variant
+    variants = {
+        detect_tokenizer_variant(path, None, explicit_vocab_path)
+        for path in data_files
+    }
+    if len(variants) > 1:
+        raise ValueError(f"Mixed tokenizer variants across datasets: {sorted(variants)}")
+    return next(iter(variants))
+
+
+def resolve_vocab_path(data_file: str, tokenizer_variant: str, explicit_path: Optional[str]) -> str:
+    if explicit_path:
+        return explicit_path
+    name = "vocab.json" if tokenizer_variant == "regex" else "vocab.char.json"
+    return os.path.join(os.path.dirname(data_file), name)
+
+
+def latest_checkpoint(save_dir: str) -> Optional[str]:
+    if not os.path.isdir(save_dir):
+        return None
+    checkpoints = []
+    for name in os.listdir(save_dir):
+        if not name.startswith("checkpoint-"):
+            continue
+        path = os.path.join(save_dir, name)
+        if not os.path.isdir(path):
+            continue
+        try:
+            step = int(name.split("-")[-1])
+        except ValueError:
+            continue
+        checkpoints.append((step, path))
+    if not checkpoints:
+        return None
+    return max(checkpoints)[1]
+
+
+def load_encoded_cache_manifest(cache_dir: str) -> Dict:
+    manifest_path = os.path.join(cache_dir, "manifest.json")
+    if not os.path.isfile(manifest_path):
+        raise FileNotFoundError(f"Encoded cache manifest not found: {manifest_path}")
+    with open(manifest_path, "r", encoding="utf-8") as f:
+        manifest = json.load(f)
+    if manifest.get("format") != "anifilebert.encoded_dataset_cache.v1":
+        raise ValueError(f"Unsupported encoded cache manifest: {manifest_path}")
+    return manifest
+
+
+def encoded_cache_split_dir(cache_dir: str, manifest: Dict, split: str) -> str:
+    split_meta = manifest.get(split) or {}
+    relative_dir = split_meta.get("directory") or split
+    return os.path.join(cache_dir, relative_dir)
+
+
+def load_encoded_cache_eval_data(cache_dir: str, manifest: Dict) -> List[Dict]:
+    relative_path = manifest.get("eval_records") or "eval_records.jsonl"
+    eval_path = os.path.join(cache_dir, relative_path)
+    if not os.path.isfile(eval_path):
+        raise FileNotFoundError(f"Encoded cache eval records not found: {eval_path}")
+    return load_jsonl(eval_path)
+
+
+def validate_dataset_tokenizer_metadata(data: List[Dict], tokenizer_variant: str) -> None:
+    variants = {item.get("tokenizer_variant") for item in data if item.get("tokenizer_variant")}
+    if variants and variants != {tokenizer_variant}:
+        raise ValueError(
+            f"Dataset tokenizer_variant {sorted(variants)} does not match selected tokenizer "
+            f"'{tokenizer_variant}'. Pass --tokenizer explicitly only when this is intentional."
+        )
+
+
+def load_jsonl(data_file: str, limit: Optional[int] = None) -> List[Dict]:
+    """Load JSONL rows, stopping early for smoke runs."""
+    data: List[Dict] = []
+    with open(data_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            data.append(json.loads(line))
+            if limit is not None and len(data) >= limit:
+                break
+    return data
+
+
+def load_training_sources(
+    primary_data_file: str,
+    extra_data_files: List[str],
+    extra_repeat: int,
+    limit: Optional[int] = None,
+) -> tuple[List[Dict], List[Dict]]:
+    """Load primary plus extra datasets while preserving source metadata."""
+    sources: List[Dict] = []
+    primary = load_jsonl(primary_data_file, limit)
+    all_data: List[Dict] = list(primary)
+    sources.append(
+        {
+            "role": "primary",
+            "path": primary_data_file,
+            "samples": len(primary),
+            "repeat": 1,
+            "effective_samples": len(primary),
+        }
+    )
+
+    repeat = max(1, extra_repeat)
+    for path in extra_data_files:
+        rows = load_jsonl(path, None)
+        for _ in range(repeat):
+            all_data.extend(rows)
+        sources.append(
+            {
+                "role": "extra",
+                "path": path,
+                "samples": len(rows),
+                "repeat": repeat,
+                "effective_samples": len(rows) * repeat,
+            }
+        )
+    return all_data, sources
+
+
+def extract_entities_from_labels(tokens: Sequence[str], labels: Sequence[str]) -> Dict[str, List[str]]:
+    """Extract contiguous BIO entity text spans from token/label arrays."""
+    entities: Dict[str, List[str]] = {}
+    active_entity: Optional[str] = None
+    active_tokens: List[str] = []
+
+    for token, label in zip(tokens, labels):
+        label = canonical_bio_label(str(label))
+        if label.startswith("B-"):
+            if active_entity and active_tokens:
+                entities.setdefault(active_entity, []).append("".join(active_tokens))
+            entity = label[2:]
+            active_entity = "TITLE" if is_title_entity(entity) else ("SEASON" if entity == "PATH_SEASON" else entity)
+            active_tokens = [str(token)]
+        elif label.startswith("I-"):
+            entity = label[2:]
+            entity = "TITLE" if is_title_entity(entity) else ("SEASON" if entity == "PATH_SEASON" else entity)
+            if active_entity == entity:
+                active_tokens.append(str(token))
+            else:
+                if active_entity and active_tokens:
+                    entities.setdefault(active_entity, []).append("".join(active_tokens))
+                active_entity = entity
+                active_tokens = [str(token)]
+        else:
+            if active_entity and active_tokens:
+                entities.setdefault(active_entity, []).append("".join(active_tokens))
+            active_entity = None
+            active_tokens = []
+
+    if active_entity and active_tokens:
+        entities.setdefault(active_entity, []).append("".join(active_tokens))
+    return entities
+
+
+def char_item_from_spans(filename: str, spans: Sequence[tuple[str, str]], source: str) -> Optional[Dict]:
+    """Create a char-tokenized BIO item from ordered text/entity spans."""
+    filename = filename.strip()
+    if not filename:
+        return None
+    tokens = list(filename)
+    labels = ["O"] * len(tokens)
+    cursor = 0
+    for text, entity in spans:
+        if not text:
+            continue
+        entity = canonical_entity(entity)
+        start = filename.find(text, cursor)
+        if start < 0:
+            start = filename.find(text)
+        if start < 0:
+            return None
+        end = start + len(text)
+        labels[start] = f"B-{entity}"
+        for idx in range(start + 1, end):
+            labels[idx] = f"I-{entity}"
+        cursor = end
+    return {
+        "filename": filename,
+        "tokens": tokens,
+        "labels": labels,
+        "tokenizer_variant": "char",
+        "source": source,
+    }
+
+
+def entity_keep_probability(entity: str) -> float:
+    return {
+        "GROUP": 0.35,
+        "TITLE": 0.65,
+        "SEASON": 0.35,
+        "EPISODE": 0.7,
+        "SPECIAL": 0.3,
+        "RESOLUTION": 0.65,
+        "SOURCE": 0.65,
+        "TAG": 0.35,
+    }.get(entity, 0.5)
+
+
+def build_partial_augmented_item(item: Dict, max_chars: int) -> List[Dict]:
+    entities = extract_entities_from_labels(item.get("tokens", []), item.get("labels", []))
+    title = next((value.strip() for value in entities.get("TITLE", []) if value.strip()), None)
+    season = next((value.strip() for value in entities.get("SEASON", []) if value.strip()), None)
+    episode = next((value.strip() for value in entities.get("EPISODE", []) if value.strip()), None)
+    special = next((value.strip() for value in entities.get("SPECIAL", []) if value.strip()), None)
+    resolution = next((value.strip() for value in entities.get("RESOLUTION", []) if value.strip()), None)
+    source = next((value.strip() for value in entities.get("SOURCE", []) if value.strip()), None)
+    tag = next((value.strip() for value in entities.get("TAG", []) if value.strip()), None)
+
+    specs: List[tuple[str, List[tuple[str, str]]]] = []
+    if title:
+        specs.append((title, [(title, "TITLE")]))
+    if title and season:
+        specs.append((f"{title} {season}", [(title, "TITLE"), (season, "SEASON")]))
+    if episode:
+        specs.append((episode, [(episode, "EPISODE")]))
+    if episode and resolution:
+        specs.append((f"{episode} [{resolution}]", [(episode, "EPISODE"), (resolution, "RESOLUTION")]))
+    if episode and resolution and source:
+        specs.append(
+            (
+                f"{episode} [{resolution}][{source}]",
+                [(episode, "EPISODE"), (resolution, "RESOLUTION"), (source, "SOURCE")],
+            )
+        )
+    if special:
+        specs.append((special, [(special, "SPECIAL")]))
+    if title and special:
+        specs.append((f"{title} - {special}", [(title, "TITLE"), (special, "SPECIAL")]))
+    if title and tag:
+        specs.append((f"{title} [{tag}]", [(title, "TITLE"), (tag, "TAG")]))
+
+    augmented: List[Dict] = []
+    for text, spans in specs:
+        if 2 <= len(text) <= max_chars:
+            generated = char_item_from_spans(text, spans, "train_partial_augmentation")
+            if generated is not None:
+                augmented.append(generated)
+    return augmented
+
+
+def build_permutation_augmented_item(item: Dict, rng: random.Random, max_chars: int) -> Optional[Dict]:
+    entities = extract_entities_from_labels(item.get("tokens", []), item.get("labels", []))
+    available = [
+        entity
+        for entity in ("GROUP", "TITLE", "SEASON", "EPISODE", "SPECIAL", "RESOLUTION", "SOURCE", "TAG")
+        if entities.get(entity)
+    ]
+    if not available:
+        return None
+    selected = [
+        entity
+        for entity in available
+        if rng.random() < entity_keep_probability(entity)
+    ]
+    if not selected:
+        selected = [rng.choice(available)]
+    if "TITLE" not in selected and "EPISODE" not in selected and "SPECIAL" not in selected:
+        extras = [entity for entity in available if entity not in selected]
+        selected.append(rng.choice(extras or available))
+    rng.shuffle(selected)
+
+    separators = [" ", " - ", ".", "_", "]["]
+    sep = rng.choice(separators)
+    parts: List[str] = []
+    spans: List[tuple[str, str]] = []
+    for entity in selected:
+        values = [value.strip() for value in entities.get(entity, []) if value.strip()]
+        if not values:
+            continue
+        value = rng.choice(values)
+        if entity in {"GROUP", "EPISODE", "SPECIAL", "RESOLUTION", "SOURCE", "TAG"} and rng.random() < 0.35:
+            parts.append(f"[{value}]")
+        else:
+            parts.append(value)
+        spans.append((value, entity))
+    text = sep.join(parts).strip()
+    if not (2 <= len(text) <= max_chars):
+        return None
+    return char_item_from_spans(text, spans, "train_permutation_augmentation")
+
+
+def build_special_augmented_item(data: List[Dict], rng: random.Random, max_chars: int) -> Optional[Dict]:
+    base_titles: List[str] = []
+    for _ in range(min(16, len(data))):
+        item = data[rng.randrange(len(data))]
+        entities = extract_entities_from_labels(item.get("tokens", []), item.get("labels", []))
+        base_titles.extend(value.strip() for value in entities.get("TITLE", []) if 2 <= len(value.strip()) <= 80)
+    title = rng.choice(base_titles) if base_titles else None
+    special = rng.choice(
+        [
+            f"Menu{rng.randint(1, 24):02d}",
+            f"Menu {rng.randint(1, 24):02d}",
+            f"BDMenu{rng.randint(1, 24):02d}",
+            f"BD Menu{rng.randint(1, 24):02d}",
+            f"Menu{rng.randint(1, 24):02d}-01",
+            "Menu",
+            f"OP{rng.randint(1, 6):02d}",
+            f"ED E{rng.randint(1, 24):02d}",
+            f"NCOP{rng.randint(1, 6):02d}",
+            f"NCED{rng.randint(1, 6):02d}",
+            f"CM{rng.randint(1, 12):02d}",
+            f"PV{rng.randint(1, 12):02d}",
+        ]
+    )
+    if title and rng.random() < 0.55:
+        text = f"{title} - {special}"
+        spans = [(title, "TITLE"), (special, "SPECIAL")]
+    else:
+        text = special
+        spans = [(special, "SPECIAL")]
+    if len(text) > max_chars:
+        return None
+    return char_item_from_spans(text, spans, "train_special_augmentation")
+
+
+def process_memory_mb() -> Optional[float]:
+    try:
+        import psutil  # type: ignore
+
+        return psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)
+    except Exception:
+        pass
+
+    if os.name == "nt":
+        try:
+            import ctypes
+            from ctypes import wintypes
+
+            class PROCESS_MEMORY_COUNTERS(ctypes.Structure):
+                _fields_ = [
+                    ("cb", wintypes.DWORD),
+                    ("PageFaultCount", wintypes.DWORD),
+                    ("PeakWorkingSetSize", ctypes.c_size_t),
+                    ("WorkingSetSize", ctypes.c_size_t),
+                    ("QuotaPeakPagedPoolUsage", ctypes.c_size_t),
+                    ("QuotaPagedPoolUsage", ctypes.c_size_t),
+                    ("QuotaPeakNonPagedPoolUsage", ctypes.c_size_t),
+                    ("QuotaNonPagedPoolUsage", ctypes.c_size_t),
+                    ("PagefileUsage", ctypes.c_size_t),
+                    ("PeakPagefileUsage", ctypes.c_size_t),
+                ]
+
+            counters = PROCESS_MEMORY_COUNTERS()
+            counters.cb = ctypes.sizeof(counters)
+            handle = ctypes.windll.kernel32.GetCurrentProcess()
+            if ctypes.windll.psapi.GetProcessMemoryInfo(handle, ctypes.byref(counters), counters.cb):
+                return float(counters.WorkingSetSize) / (1024 * 1024)
+        except Exception:
+            pass
+
+    try:
+        import resource  # type: ignore
+
+        usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+        if sys.platform == "darwin":
+            usage = usage / 1024 / 1024
+        else:
+            usage = usage / 1024
+        return float(usage)
+    except Exception:
+        return None
+
+
+class NvmlSampler:
+    """Tiny NVML binding for runtime GPU telemetry without adding dependencies."""
+
+    NVML_TEMPERATURE_GPU = 0
+
+    def __init__(self):
+        self._lib = None
+        self._handle = None
+        self._available = False
+        self._init()
+
+    def _candidate_names(self) -> List[str]:
+        names = []
+        found = ctypes_util.find_library("nvidia-ml")
+        if found:
+            names.append(found)
+        if os.name == "nt":
+            names.extend(
+                [
+                    os.path.join(os.environ.get("SystemRoot", r"C:\Windows"), "System32", "nvml.dll"),
+                    "nvml.dll",
+                    "nvidia-ml.dll",
+                ]
+            )
+        else:
+            names.extend(["libnvidia-ml.so.1", "libnvidia-ml.so"])
+        return names
+
+    def _init(self) -> None:
+        for name in self._candidate_names():
+            try:
+                lib = cdll.LoadLibrary(name)
+                break
+            except Exception:
+                continue
+        else:
+            return
+
+        class NVMLUtilization(Structure):
+            _fields_ = [("gpu", c_uint), ("memory", c_uint)]
+
+        class NVMLMemory(Structure):
+            _fields_ = [("total", c_ulonglong), ("free", c_ulonglong), ("used", c_ulonglong)]
+
+        self.NVMLUtilization = NVMLUtilization
+        self.NVMLMemory = NVMLMemory
+        lib.nvmlInit_v2.restype = c_int
+        lib.nvmlDeviceGetHandleByIndex_v2.argtypes = [c_uint, POINTER(c_void_p)]
+        lib.nvmlDeviceGetHandleByIndex_v2.restype = c_int
+        handle = c_void_p()
+        try:
+            if lib.nvmlInit_v2() != 0:
+                return
+            if lib.nvmlDeviceGetHandleByIndex_v2(0, byref(handle)) != 0:
+                return
+        except Exception:
+            return
+        self._lib = lib
+        self._handle = handle
+        self._available = True
+
+    @property
+    def available(self) -> bool:
+        return self._available
+
+    def sample(self) -> Dict[str, Optional[float]]:
+        if not self._available or self._lib is None or self._handle is None:
+            return {}
+        stats: Dict[str, Optional[float]] = {}
+        try:
+            util_rates = self.NVMLUtilization()
+            self._lib.nvmlDeviceGetUtilizationRates.argtypes = [c_void_p, POINTER(self.NVMLUtilization)]
+            if self._lib.nvmlDeviceGetUtilizationRates(self._handle, byref(util_rates)) == 0:
+                stats["gpu_util_percent"] = float(util_rates.gpu)
+                stats["gpu_memory_util_percent"] = float(util_rates.memory)
+        except Exception:
+            pass
+        try:
+            memory = self.NVMLMemory()
+            self._lib.nvmlDeviceGetMemoryInfo.argtypes = [c_void_p, POINTER(self.NVMLMemory)]
+            if self._lib.nvmlDeviceGetMemoryInfo(self._handle, byref(memory)) == 0:
+                stats["gpu_memory_used_mb"] = float(memory.used) / (1024 * 1024)
+                stats["gpu_memory_total_mb"] = float(memory.total) / (1024 * 1024)
+        except Exception:
+            pass
+        try:
+            temperature = c_uint()
+            self._lib.nvmlDeviceGetTemperature.argtypes = [c_void_p, c_uint, POINTER(c_uint)]
+            if self._lib.nvmlDeviceGetTemperature(self._handle, self.NVML_TEMPERATURE_GPU, byref(temperature)) == 0:
+                stats["gpu_temperature_c"] = float(temperature.value)
+        except Exception:
+            pass
+        try:
+            power_mw = c_uint()
+            self._lib.nvmlDeviceGetPowerUsage.argtypes = [c_void_p, POINTER(c_uint)]
+            if self._lib.nvmlDeviceGetPowerUsage(self._handle, byref(power_mw)) == 0:
+                stats["gpu_power_w"] = float(power_mw.value) / 1000.0
+        except Exception:
+            pass
+        return stats
+
+
+_NVML_SAMPLER: Optional[NvmlSampler] = None
+
+
+def query_nvml() -> Dict[str, Optional[float]]:
+    global _NVML_SAMPLER
+    if _NVML_SAMPLER is None:
+        _NVML_SAMPLER = NvmlSampler()
+    return _NVML_SAMPLER.sample()
+
+
+def query_nvidia_smi() -> Dict[str, Optional[float]]:
+    try:
+        result = subprocess.run(
+            [
+                "nvidia-smi",
+                "--query-gpu=utilization.gpu,memory.used,memory.total,power.draw",
+                "--format=csv,noheader,nounits",
+            ],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+    except Exception:
+        return {}
+    if result.returncode != 0 or not result.stdout.strip():
+        return {}
+    first_line = result.stdout.strip().splitlines()[0]
+    values = [part.strip() for part in first_line.split(",")]
+    keys = ["gpu_util_percent", "gpu_memory_used_mb", "gpu_memory_total_mb", "gpu_power_w"]
+    stats: Dict[str, Optional[float]] = {}
+    for key, value in zip(keys, values):
+        try:
+            stats[key] = float(value)
+        except ValueError:
+            stats[key] = None
+    return stats
+
+
+def cuda_memory_stats_mb() -> Dict[str, float]:
+    if not torch.cuda.is_available():
+        return {}
+    return {
+        "cuda_allocated_mb": torch.cuda.memory_allocated() / (1024 * 1024),
+        "cuda_reserved_mb": torch.cuda.memory_reserved() / (1024 * 1024),
+        "cuda_max_allocated_mb": torch.cuda.max_memory_allocated() / (1024 * 1024),
+        "cuda_max_reserved_mb": torch.cuda.max_memory_reserved() / (1024 * 1024),
+    }
+
+
+def snapshot_perf_stats() -> Dict[str, Optional[float]]:
+    stats: Dict[str, Optional[float]] = {}
+    stats["process_rss_mb"] = process_memory_mb()
+    stats.update(cuda_memory_stats_mb())
+    gpu_stats = query_nvml()
+    if not gpu_stats:
+        gpu_stats = query_nvidia_smi()
+    stats.update(gpu_stats)
+    return stats
+
+
+class TrainingPerfCallback(TrainerCallback):
+    """Lightweight runtime telemetry for spotting data-pipeline starvation."""
+
+    def __init__(self, batch_size: int, sequence_length: int, log_steps: int, sample_interval: float):
+        self.batch_size = batch_size
+        self.sequence_length = sequence_length
+        self.log_steps = max(0, log_steps)
+        self.sample_interval = max(0.0, sample_interval)
+        self.samples: List[Dict[str, Optional[float]]] = []
+        self.background_samples: List[Dict[str, Optional[float]]] = []
+        self._last_step = 0
+        self._last_time: Optional[float] = None
+        self._start_time: Optional[float] = None
+        self._training = False
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+
+    def on_train_begin(self, args, state, control, **kwargs):
+        now = time.perf_counter()
+        self._start_time = now
+        self._last_time = now
+        self._last_step = int(state.global_step)
+        self._training = True
+        self._stop_event.clear()
+        if self.sample_interval > 0:
+            self._thread = threading.Thread(target=self._background_sample_loop, daemon=True)
+            self._thread.start()
+
+    def on_train_end(self, args, state, control, **kwargs):
+        self._training = False
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=max(self.sample_interval * 2, 1.0))
+            self._thread = None
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        if not self._training:
+            return
+        step = int(state.global_step)
+        if self.log_steps <= 0 or step <= 0 or step % self.log_steps != 0:
+            return
+        self._record_sample(step)
+
+    def on_step_end(self, args, state, control, **kwargs):
+        if not self._training:
+            return
+        step = int(state.global_step)
+        if self.log_steps <= 0 or step <= 0 or step % self.log_steps != 0:
+            return
+        if self.samples and self.samples[-1].get("step") == float(step):
+            return
+        self._record_sample(step)
+
+    def _record_sample(self, step: int) -> None:
+        if self.samples and self.samples[-1].get("step") == float(step):
+            return
+        now = time.perf_counter()
+        last_time = self._last_time or now
+        elapsed = max(now - last_time, 1e-9)
+        step_delta = max(step - self._last_step, 0)
+        samples_per_second = step_delta * self.batch_size / elapsed
+        tokens_per_second = samples_per_second * self.sequence_length
+        stats = snapshot_perf_stats()
+        sample: Dict[str, Optional[float]] = {
+            "step": float(step),
+            "elapsed_seconds": now - (self._start_time or now),
+            "window_seconds": elapsed,
+            "steps_per_second": step_delta / elapsed,
+            "samples_per_second": samples_per_second,
+            "tokens_per_second": tokens_per_second,
+        }
+        sample.update(stats)
+        self.samples.append(sample)
+        print(
+            "  perf "
+            f"step={step} "
+            f"samples/s={samples_per_second:.1f} "
+            f"tokens/s={tokens_per_second:.0f} "
+            f"rss={stats.get('process_rss_mb') or 0:.0f}MB "
+            f"cuda_alloc={stats.get('cuda_allocated_mb') or 0:.0f}MB "
+            f"gpu_util={stats.get('gpu_util_percent') if stats.get('gpu_util_percent') is not None else 'n/a'}%"
+        )
+        self._last_time = now
+        self._last_step = step
+
+    def _background_sample_loop(self) -> None:
+        while not self._stop_event.wait(self.sample_interval):
+            if not self._training:
+                continue
+            sample = snapshot_perf_stats()
+            sample["elapsed_seconds"] = (
+                time.perf_counter() - self._start_time
+                if self._start_time is not None
+                else None
+            )
+            self.background_samples.append(sample)
+
+    def summary(self) -> Dict:
+        numeric_keys = [
+            "samples_per_second",
+            "tokens_per_second",
+            "process_rss_mb",
+            "cuda_max_allocated_mb",
+            "gpu_util_percent",
+            "gpu_memory_util_percent",
+            "gpu_power_w",
+            "gpu_temperature_c",
+        ]
+        summary: Dict[str, object] = {
+            "sample_count": len(self.samples),
+            "samples": self.samples,
+            "background_sample_count": len(self.background_samples),
+            "background_samples": self.background_samples,
+        }
+        sample_groups = {
+            "step": self.samples,
+            "background": self.background_samples,
+        }
+        for prefix, samples in sample_groups.items():
+            if not samples:
+                continue
+            for key in numeric_keys:
+                values = [
+                    float(sample[key])
+                    for sample in samples
+                    if sample.get(key) is not None
+                ]
+                if values:
+                    summary[f"{prefix}_{key}_avg"] = sum(values) / len(values)
+                    summary[f"{prefix}_{key}_max"] = max(values)
+                    summary[f"{prefix}_{key}_min"] = min(values)
+        if not self.samples and not self.background_samples:
+            return summary
+        for key in numeric_keys:
+            values = [
+                float(sample[key])
+                for sample in self.samples
+                if sample.get(key) is not None
+            ]
+            if values:
+                summary[f"{key}_avg"] = sum(values) / len(values)
+                summary[f"{key}_max"] = max(values)
+        return summary
+
+
+class FastTokenClassificationCollator:
+    """Stack already padded token-classification tensors without extra work."""
+
+    def __call__(self, features: List[Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:
+        batch = {
+            key: torch.stack([feature[key] for feature in features])
+            for key in features[0].keys()
+        }
+        if "input_ids" in batch:
+            batch["input_ids"] = batch["input_ids"].long()
+        if "labels" in batch:
+            batch["labels"] = batch["labels"].long()
+        if "attention_mask" in batch:
+            batch["attention_mask"] = batch["attention_mask"].to(dtype=torch.bool)
+        return batch
+
+
+class OrderedTrainer(Trainer):
+    """Trainer variant that preserves pre-shuffled order for virtual datasets."""
+
+    def _get_train_sampler(self, train_dataset=None):
+        dataset = train_dataset if train_dataset is not None else self.train_dataset
+        if getattr(dataset, "preserve_order", False):
+            return SequentialSampler(dataset)
+        return super()._get_train_sampler(train_dataset)
+
+
+class RDropTrainer(OrderedTrainer):
+    """Trainer that adds symmetric KL regularization between two dropout passes."""
+
+    def __init__(self, *args, rdrop_alpha: float = 0.0, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.rdrop_alpha = float(rdrop_alpha)
+
+    @staticmethod
+    def _active_mask(labels: torch.Tensor, attention_mask: Optional[torch.Tensor]) -> torch.Tensor:
+        mask = labels.ne(-100)
+        if attention_mask is not None:
+            mask = mask & attention_mask.bool()
+        if mask.shape[1] > 2:
+            mask = mask[:, 1:-1]
+        return mask
+
+    def _symmetric_kl(
+        self,
+        logits_a: torch.Tensor,
+        logits_b: torch.Tensor,
+        labels: torch.Tensor,
+        attention_mask: Optional[torch.Tensor],
+    ) -> torch.Tensor:
+        if logits_a.shape != logits_b.shape:
+            raise ValueError("R-Drop requires matching logit shapes")
+        if logits_a.shape[1] <= 2:
+            return logits_a.new_tensor(0.0)
+        active_mask = self._active_mask(labels, attention_mask)
+        if active_mask.numel() == 0 or active_mask.sum() == 0:
+            return logits_a.new_tensor(0.0)
+        active_a = logits_a[:, 1:-1, :]
+        active_b = logits_b[:, 1:-1, :]
+        log_probs_a = F.log_softmax(active_a, dim=-1)
+        log_probs_b = F.log_softmax(active_b, dim=-1)
+        probs_a = log_probs_a.exp()
+        probs_b = log_probs_b.exp()
+        kl_ab = F.kl_div(log_probs_a, probs_b, reduction="none").sum(dim=-1)
+        kl_ba = F.kl_div(log_probs_b, probs_a, reduction="none").sum(dim=-1)
+        active_mask = active_mask.to(dtype=kl_ab.dtype)
+        return ((kl_ab + kl_ba) * active_mask).sum() / active_mask.sum().clamp_min(1.0)
+
+    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+        labels = inputs.pop("labels")
+        attention_mask = inputs.get("attention_mask")
+        outputs_a = model(**inputs, labels=labels)
+        outputs_b = model(**inputs, labels=labels)
+        base_loss = 0.5 * (outputs_a.loss + outputs_b.loss)
+        kl_loss = self._symmetric_kl(outputs_a.logits, outputs_b.logits, labels, attention_mask)
+        loss = base_loss + self.rdrop_alpha * 0.5 * kl_loss
+        if return_outputs:
+            return loss, outputs_a
+        return loss
+
+
+def augment_training_data(
+    data: List[Dict],
+    partial_count: int,
+    permutation_count: int,
+    special_count: int,
+    max_chars: int,
+    seed: int,
+) -> tuple[List[Dict], Dict]:
+    """Append generated partial/permutation samples without modifying source JSONL."""
+    rng = random.Random(seed)
+    augmented: List[Dict] = []
+    seen = {
+        item.get("filename") or "".join(str(token) for token in item.get("tokens", []))
+        for item in data
+    }
+
+    partial_written = 0
+    if partial_count > 0:
+        candidates: List[Dict] = []
+        attempts = 0
+        max_attempts = max(partial_count * 20, len(data))
+        while len(candidates) < partial_count * 4 and attempts < max_attempts:
+            attempts += 1
+            candidates.extend(build_partial_augmented_item(rng.choice(data), max_chars))
+        rng.shuffle(candidates)
+        for item in candidates:
+            key = item["filename"]
+            if key in seen:
+                continue
+            seen.add(key)
+            augmented.append(item)
+            partial_written += 1
+            if partial_written >= partial_count:
+                break
+
+    permutation_written = 0
+    attempts = 0
+    while permutation_written < permutation_count and attempts < max(permutation_count * 20, 100):
+        attempts += 1
+        item = build_permutation_augmented_item(rng.choice(data), rng, max_chars)
+        if item is None:
+            continue
+        key = item["filename"]
+        if key in seen:
+            continue
+        seen.add(key)
+        augmented.append(item)
+        permutation_written += 1
+
+    special_written = 0
+    attempts = 0
+    while special_written < special_count and attempts < max(special_count * 20, 100):
+        attempts += 1
+        item = build_special_augmented_item(data, rng, max_chars)
+        if item is None:
+            continue
+        key = item["filename"]
+        if key in seen:
+            continue
+        seen.add(key)
+        augmented.append(item)
+        special_written += 1
+
+    meta = {
+        "partial_requested": partial_count,
+        "partial_written": partial_written,
+        "permutation_requested": permutation_count,
+        "permutation_written": permutation_written,
+        "special_requested": special_count,
+        "special_written": special_written,
+        "max_chars": max_chars,
+    }
+    return data + augmented, meta
+
+
+def normalize_field_value(field: str, value) -> Optional[str]:
+    if value is None:
+        return None
+    if isinstance(value, list):
+        normalized_items = [
+            normalize_field_value(field, item)
+            for item in value
+            if item is not None
+        ]
+        return "|".join(item for item in normalized_items if item)
+    if field in {"episode", "season"}:
+        try:
+            return str(int(value))
+        except (TypeError, ValueError):
+            return str(value).strip().lower()
+    text = str(value).strip()
+    if field in {"resolution", "source"}:
+        return text.lower().replace("_", "-")
+    return " ".join(text.lower().split())
+
+
+def parse_exact_metrics(
+    samples: List[Dict],
+    model: torch.nn.Module,
+    tokenizer: AnimeTokenizer,
+    id2label: Dict[int, str],
+    max_length: int,
+    limit: Optional[int],
+    constrain_bio: bool = True,
+) -> Dict:
+    """Evaluate end-to-end field exact match on filenames, not just token loss."""
+    fields = ["group", "title", "season", "episode", "resolution", "source", "special"]
+    selected = [sample for sample in samples if sample.get("filename")]
+    if limit is not None and limit > 0:
+        selected = selected[:limit]
+
+    counter: Counter = Counter()
+    failures: List[Dict] = []
+    model.eval()
+
+    for sample in selected:
+        filename = sample["filename"]
+        tokens, gold_labels = labels_for_tokenizer(sample, tokenizer)
+        available = max(0, max_length - 2)
+        tokens = tokens[:available]
+        gold_labels = gold_labels[:available]
+        gold = postprocess(tokens, gold_labels, tokenizer=tokenizer)
+        gold_entities = {label.split("-", 1)[1] for label in gold_labels if label.startswith(("B-", "I-"))}
+        if "EPISODE" not in gold_entities:
+            gold["episode"] = None
+        if not any(is_season_like_label(label) for label in gold_labels):
+            gold["season"] = None
+        pred = parse_filename(
+            filename,
+            model,
+            tokenizer,
+            id2label,
+            max_length=max_length,
+            debug=False,
+            constrain_bio=constrain_bio,
+        )
+
+        full_match = True
+        field_errors: Dict[str, Dict[str, Optional[str]]] = {}
+        for field in fields:
+            gold_value = normalize_field_value(field, gold.get(field))
+            pred_value = normalize_field_value(field, pred.get(field))
+            counter[f"{field}_total"] += 1
+            if gold_value == pred_value:
+                counter[f"{field}_correct"] += 1
+            else:
+                full_match = False
+                field_errors[field] = {"gold": gold_value, "pred": pred_value}
+        counter["full_total"] += 1
+        if full_match:
+            counter["full_correct"] += 1
+        elif len(failures) < 20:
+            failures.append(
+                {
+                    "filename": filename,
+                    "errors": field_errors,
+                    "gold": {field: gold.get(field) for field in fields},
+                    "pred": {field: pred.get(field) for field in fields},
+                }
+            )
+
+    field_accuracy = {}
+    for field in fields:
+        total = counter.get(f"{field}_total", 0)
+        correct = counter.get(f"{field}_correct", 0)
+        field_accuracy[field] = correct / total if total else 0.0
+
+    total = counter.get("full_total", 0)
+    correct = counter.get("full_correct", 0)
+    return {
+        "constrain_bio": constrain_bio,
+        "sample_count": total,
+        "field_accuracy": field_accuracy,
+        "field_correct": {field: counter.get(f"{field}_correct", 0) for field in fields},
+        "field_total": {field: counter.get(f"{field}_total", 0) for field in fields},
+        "full_match_accuracy": correct / total if total else 0.0,
+        "full_match_correct": correct,
+        "full_match_total": total,
+        "failures": failures,
+    }
+
+
+def parse_exact_metrics_all_modes(
+    samples: List[Dict],
+    model: torch.nn.Module,
+    tokenizer: AnimeTokenizer,
+    id2label: Dict[int, str],
+    max_length: int,
+    limit: Optional[int],
+) -> Dict:
+    modes = {
+        "model_only": {"constrain_bio": False},
+        "normalized_only": {"constrain_bio": True},
+    }
+    return {
+        "primary_metric": "normalized_only",
+        "modes": {
+            name: parse_exact_metrics(
+                samples,
+                model,
+                tokenizer,
+                id2label,
+                max_length,
+                limit,
+                constrain_bio=settings["constrain_bio"],
+            )
+            for name, settings in modes.items()
+        },
+    }
+
+
+def remap_token_embeddings(
+    model: torch.nn.Module,
+    old_vocab: Dict[str, int],
+    new_vocab: Dict[str, int],
+    pad_token_id: int,
+) -> int:
+    """
+    Replace the input embedding table for a changed vocabulary.
+
+    resize_token_embeddings() preserves rows by numeric ID, which is unsafe when
+    two tokenizers assign different tokens to the same ID. This remaps by token
+    string and randomly initializes tokens that do not exist in the old vocab.
+    """
+    old_embeddings = model.get_input_embeddings()
+    old_weight = old_embeddings.weight.data
+    embedding_dim = old_weight.shape[1]
+    new_embeddings = torch.nn.Embedding(
+        len(new_vocab),
+        embedding_dim,
+        padding_idx=pad_token_id,
+        device=old_weight.device,
+        dtype=old_weight.dtype,
+    )
+    torch.nn.init.normal_(
+        new_embeddings.weight,
+        mean=0.0,
+        std=getattr(model.config, "initializer_range", 0.02),
+    )
+    if pad_token_id is not None and 0 <= pad_token_id < len(new_vocab):
+        new_embeddings.weight.data[pad_token_id].zero_()
+
+    copied = 0
+    for token, new_id in new_vocab.items():
+        old_id = old_vocab.get(token)
+        if old_id is None or old_id >= old_weight.shape[0]:
+            continue
+        new_embeddings.weight.data[new_id].copy_(old_weight[old_id])
+        copied += 1
+
+    model.set_input_embeddings(new_embeddings)
+    model.config.vocab_size = len(new_vocab)
+    return copied
+
+
+def build_vocab_from_data(data: List[Dict], tokenizer: AnimeTokenizer, vocab_path: str,
+                         max_size: Optional[int] = None) -> None:
+    token_lists: List[List[str]] = []
+    for item in data:
+        tokens, _labels = labels_for_tokenizer(item, tokenizer)
+        token_lists.append(tokens)
+
+    tokenizer.build_vocab(token_lists, max_size=max_size)
+    save_dir = os.path.dirname(vocab_path) or "."
+    os.makedirs(save_dir, exist_ok=True)
+    with open(vocab_path, "w", encoding="utf-8") as f:
+        json.dump(tokenizer.get_vocab(), f, ensure_ascii=False, indent=2)
+
+
+def architecture_matches_config(model, config: Config) -> bool:
+    model_config = model.config
+    return (
+        int(getattr(model_config, "hidden_size", -1)) == int(config.hidden_size)
+        and int(getattr(model_config, "num_hidden_layers", -1)) == int(config.num_hidden_layers)
+        and int(getattr(model_config, "num_attention_heads", -1)) == int(config.num_attention_heads)
+        and int(getattr(model_config, "intermediate_size", -1)) == int(config.intermediate_size)
+        and int(getattr(model_config, "max_position_embeddings", -1)) >= int(config.max_position_embeddings)
+    )
+
+
+def rebuild_model_with_architecture_overrides(source_model, config: Config, model_head: str):
+    """Create a target architecture and copy same-shaped tensors from source."""
+    target_model = create_model(config, model_head=model_head)
+    source_state = source_model.state_dict()
+    target_state = target_model.state_dict()
+    copied_tensors = 0
+    copied_parameters = 0
+    skipped = []
+
+    with torch.no_grad():
+        for name, target_tensor in target_state.items():
+            source_tensor = source_state.get(name)
+            if source_tensor is None or tuple(source_tensor.shape) != tuple(target_tensor.shape):
+                skipped.append(name)
+                continue
+            target_tensor.copy_(source_tensor.to(device=target_tensor.device, dtype=target_tensor.dtype))
+            copied_tensors += 1
+            copied_parameters += target_tensor.numel()
+
+    target_model.load_state_dict(target_state)
+    return target_model, {
+        "copied_tensors": copied_tensors,
+        "copied_parameters": copied_parameters,
+        "skipped_tensors": len(skipped),
+        "skipped_examples": skipped[:10],
+    }
+
+
+def main():
+    args = parse_args()
+    config = Config()
+    if args.data_file is not None:
+        config.data_file = args.data_file
+    training_files = [config.data_file] + list(args.extra_data_file or [])
+    tokenizer_variant = detect_tokenizer_variant_from_files(training_files, args.tokenizer, args.vocab_file)
+    if args.save_dir is not None:
+        config.save_dir = args.save_dir
+    elif tokenizer_variant == "char":
+        config.save_dir = "./checkpoints_char"
+    if args.epochs is not None:
+        config.num_epochs = args.epochs
+    if args.batch_size is not None:
+        config.batch_size = args.batch_size
+    if args.learning_rate is not None:
+        config.learning_rate = args.learning_rate
+    if args.warmup_steps is not None:
+        config.warmup_steps = args.warmup_steps
+    if args.train_split is not None:
+        config.train_split = args.train_split
+    if args.num_workers is not None:
+        config.num_workers = args.num_workers
+    if args.max_seq_length is not None:
+        config.max_seq_length = args.max_seq_length
+    elif tokenizer_variant == "char":
+        config.max_seq_length = max(config.max_seq_length, 128)
+    if args.hidden_size is not None:
+        config.hidden_size = args.hidden_size
+    if args.num_hidden_layers is not None:
+        config.num_hidden_layers = args.num_hidden_layers
+    if args.num_attention_heads is not None:
+        config.num_attention_heads = args.num_attention_heads
+    if args.intermediate_size is not None:
+        config.intermediate_size = args.intermediate_size
+    if config.hidden_size % config.num_attention_heads != 0:
+        raise ValueError(
+            f"hidden_size ({config.hidden_size}) must be divisible by "
+            f"num_attention_heads ({config.num_attention_heads})."
+        )
+    config.max_position_embeddings = max(config.max_position_embeddings, config.max_seq_length)
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+
+    print("Loading dataset...")
+    load_started_at = time.perf_counter()
+    augmentation_metadata = {
+        "partial_requested": 0,
+        "partial_written": 0,
+        "permutation_requested": 0,
+        "permutation_written": 0,
+        "special_requested": 0,
+        "special_written": 0,
+        "max_chars": args.augment_max_chars,
+    }
+    encoded_cache_manifest = None
+    if args.encoded_cache_dir:
+        if args.extra_data_file:
+            raise ValueError("--encoded-cache-dir cannot be combined with --extra-data-file.")
+        if args.limit_samples is not None:
+            raise ValueError("--encoded-cache-dir cannot be combined with --limit-samples.")
+        if args.rebuild_vocab:
+            raise ValueError("--encoded-cache-dir requires an existing vocab; do not pass --rebuild-vocab.")
+        if args.augment_partial_samples or args.augment_permutation_samples or args.augment_special_samples:
+            raise ValueError("--encoded-cache-dir cannot be combined with training-time augmentation.")
+        if args.apply_label_repairs:
+            raise ValueError("--encoded-cache-dir expects labels already repaired; do not pass --apply-label-repairs.")
+        encoded_cache_manifest = load_encoded_cache_manifest(args.encoded_cache_dir)
+        eval_data = load_encoded_cache_eval_data(args.encoded_cache_dir, encoded_cache_manifest)
+        train_data: List[Dict] = []
+        all_data: List[Dict] = []
+        data_sources = [
+            {
+                "role": "encoded_cache",
+                "path": args.encoded_cache_dir,
+                "samples": int(encoded_cache_manifest.get("source_rows", 0)),
+                "repeat": 1,
+                "effective_samples": int(encoded_cache_manifest.get("source_rows", 0)),
+            }
+        ]
+    else:
+        all_data, data_sources = load_training_sources(
+            primary_data_file=config.data_file,
+            extra_data_files=list(args.extra_data_file or []),
+            extra_repeat=args.extra_data_repeat,
+            limit=args.limit_samples,
+        )
+        if args.augment_partial_samples or args.augment_permutation_samples or args.augment_special_samples:
+            if tokenizer_variant != "char":
+                raise ValueError("Training-time BIO span augmentation currently requires --tokenizer char.")
+            all_data, augmentation_metadata = augment_training_data(
+                data=all_data,
+                partial_count=args.augment_partial_samples,
+                permutation_count=args.augment_permutation_samples,
+                special_count=args.augment_special_samples,
+                max_chars=args.augment_max_chars,
+                seed=args.seed + 1009,
+            )
+    load_finished_at = time.perf_counter()
+    if args.encoded_cache_dir:
+        if not eval_data:
+            raise ValueError("Encoded cache eval_records.jsonl is empty.")
+        validate_dataset_tokenizer_metadata(eval_data, tokenizer_variant)
+    else:
+        if len(all_data) < 2:
+            raise ValueError("Need at least two samples so train/eval split is non-empty.")
+        if not args.no_shuffle:
+            random.shuffle(all_data)
+        validate_dataset_tokenizer_metadata(all_data, tokenizer_variant)
+
+    # Load tokenizer
+    print("Loading tokenizer...")
+    vocab_path = resolve_vocab_path(config.data_file, tokenizer_variant, args.vocab_file)
+    tokenizer = create_tokenizer(tokenizer_variant)
+    if args.rebuild_vocab or not os.path.isfile(vocab_path):
+        max_vocab_size = args.max_vocab_size if args.max_vocab_size is not None else config.vocab_size
+        print(f"  Building {tokenizer_variant} vocab: {vocab_path} (max_size={max_vocab_size})")
+        build_vocab_from_data(all_data, tokenizer, vocab_path, max_size=max_vocab_size)
+    tokenizer = create_tokenizer(tokenizer_variant, vocab_file=vocab_path)
+    print(f"  Variant: {tokenizer_variant}")
+    print(f"  Vocab size: {tokenizer.vocab_size}")
+    print(f"  Max sequence length: {config.max_seq_length}")
+    if torch.cuda.is_available() and not args.cpu:
+        print(f"  CUDA device: {torch.cuda.get_device_name(0)}")
+
+    # Update config with actual vocab size
+    config.vocab_size = tokenizer.vocab_size
+
+    # Create model
+    requested_model_head = None if args.model_head == "auto" else args.model_head
+    if args.init_model_dir:
+        print(f"Loading model for fine-tuning: {args.init_model_dir}")
+        model = load_model(args.init_model_dir, model_head=requested_model_head)
+        selected_model_head = requested_model_head or str(getattr(model.config, "model_head", "linear"))
+        init_tokenizer = load_tokenizer(args.init_model_dir, tokenizer_variant)
+        init_vocab = init_tokenizer.get_vocab()
+        embedding_size = model.get_input_embeddings().weight.shape[0]
+        if len(init_vocab) != embedding_size:
+            print(
+                "  WARNING: init checkpoint tokenizer vocab length does not match model embedding size "
+                f"({len(init_vocab):,} vs {embedding_size:,}). Prefer a self-consistent checkpoint."
+            )
+        init_variant = getattr(init_tokenizer, "tokenizer_variant", None)
+        if init_variant != tokenizer_variant:
+            print(f"  WARNING: tokenizer variant changes during fine-tune: {init_variant} -> {tokenizer_variant}")
+            print("  Token embeddings will be remapped by token string; unmatched tokens are newly initialized.")
+        if model.config.vocab_size != config.vocab_size or init_vocab != tokenizer.get_vocab():
+            copied = remap_token_embeddings(
+                model=model,
+                old_vocab=init_vocab,
+                new_vocab=tokenizer.get_vocab(),
+                pad_token_id=tokenizer.pad_token_id,
+            )
+            print(
+                f"  Remapped token embeddings: copied {copied:,}/{config.vocab_size:,} "
+                f"tokens from init checkpoint"
+            )
+        migration = migrate_token_classifier_labels(model, config.label2id, config.id2label)
+        if migration.get("changed"):
+            print(
+                "  Migrated token classifier labels: "
+                f"{migration.get('source_labels')} -> {migration.get('target_labels')} "
+                f"(copied {migration.get('copied')} rows)"
+            )
+        model.config.num_labels = config.num_labels
+        model.config.id2label = config.id2label
+        model.config.label2id = config.label2id
+        model.config.label_schema_version = config.label_schema_version
+        if not architecture_matches_config(model, config):
+            print(
+                "  Rebuilding model for architecture overrides: "
+                f"layers={config.num_hidden_layers}, heads={config.num_attention_heads}, "
+                f"hidden={config.hidden_size}, intermediate={config.intermediate_size}"
+            )
+            model, architecture_copy = rebuild_model_with_architecture_overrides(
+                source_model=model,
+                config=config,
+                model_head=selected_model_head,
+            )
+            print(
+                "  Copied compatible tensors into override architecture: "
+                f"{architecture_copy['copied_tensors']} tensors, "
+                f"{architecture_copy['copied_parameters']:,} params; "
+                f"skipped {architecture_copy['skipped_tensors']} tensors"
+            )
+            if architecture_copy["skipped_examples"]:
+                print(f"  Skipped tensor examples: {architecture_copy['skipped_examples']}")
+    else:
+        print("Creating model...")
+        selected_model_head = "linear" if args.model_head == "auto" else args.model_head
+        model = create_model(config, model_head=selected_model_head)
+    if args.train_crf_only:
+        if not hasattr(model, "crf"):
+            raise ValueError("--train-crf-only requires the CRF model head.")
+        for parameter in model.bert.parameters():
+            parameter.requires_grad = False
+        for parameter in model.classifier.parameters():
+            parameter.requires_grad = False
+        print("  CRF warmup: encoder and classifier frozen; training transitions only.")
+    save_model_head_config(model, selected_model_head)
+    print(f"  Model head: {selected_model_head}")
+    total_params = print_model_summary(model)
+
+    if total_params >= 5_000_000:
+        print("WARNING: Model exceeds the historical 5M target; continuing because vocab size is configurable.")
+
+    use_cpu = args.cpu or not torch.cuda.is_available()
+    if not args.encoded_cache_dir:
+        split_idx = int(len(all_data) * config.train_split)
+        split_idx = max(1, min(len(all_data) - 1, split_idx))
+        train_data = all_data[:split_idx]
+        eval_data = all_data[split_idx:]
+
+    encode_started_at = time.perf_counter()
+    if args.encoded_cache_dir:
+        assert encoded_cache_manifest is not None
+        train_cache_dir = encoded_cache_split_dir(args.encoded_cache_dir, encoded_cache_manifest, "train")
+        eval_cache_dir = encoded_cache_split_dir(args.encoded_cache_dir, encoded_cache_manifest, "eval")
+        train_dataset = ShardedEncodedDataset(train_cache_dir)
+        eval_dataset = ShardedEncodedDataset(eval_cache_dir)
+        for split_name, dataset in (("train", train_dataset), ("eval", eval_dataset)):
+            if dataset.max_length != config.max_seq_length:
+                raise ValueError(
+                    f"Encoded cache {split_name} max_length {dataset.max_length} does not match "
+                    f"configured max_seq_length {config.max_seq_length}"
+                )
+        if len(eval_dataset) != len(eval_data):
+            raise ValueError(
+                f"Encoded cache eval rows ({len(eval_dataset)}) do not match eval_records.jsonl "
+                f"({len(eval_data)}). Regenerate the cache."
+            )
+        dataset_mode = "encoded-cache-sharded"
+        if not args.keep_raw_dataset:
+            all_data = []
+            train_data = []
+            gc.collect()
+    elif args.virtual_dataset_dir:
+        virtual_dataset = ShardedEncodedDataset(args.virtual_dataset_dir)
+        if virtual_dataset.max_length != config.max_seq_length:
+            raise ValueError(
+                f"Virtual dataset max_length {virtual_dataset.max_length} does not match "
+                f"configured max_seq_length {config.max_seq_length}"
+            )
+        train_dataset = virtual_dataset
+        eval_dataset = EncodedAnimeDataset(
+            data=eval_data,
+            tokenizer=tokenizer,
+            label2id=config.label2id,
+            max_length=config.max_seq_length,
+            device=torch.device("cpu"),
+            apply_label_repairs=args.apply_label_repairs,
+        )
+        dataset_mode = "virtual-sharded"
+        if not args.keep_raw_dataset:
+            train_data = []
+            all_data = []
+            gc.collect()
+    elif args.lazy_dataset:
+        train_dataset = AnimeItemsDataset(
+            data=train_data,
+            tokenizer=tokenizer,
+            label2id=config.label2id,
+            max_length=config.max_seq_length,
+            apply_label_repairs=args.apply_label_repairs,
+        )
+        eval_dataset = AnimeItemsDataset(
+            data=eval_data,
+            tokenizer=tokenizer,
+            label2id=config.label2id,
+            max_length=config.max_seq_length,
+            apply_label_repairs=args.apply_label_repairs,
+        )
+        dataset_mode = "lazy"
+    else:
+        encoded_device = torch.device(args.encoded_dataset_device)
+        if encoded_device.type == "cuda" and use_cpu:
+            raise ValueError("--encoded-dataset-device cuda cannot be used with CPU training.")
+        if encoded_device.type == "cuda" and config.num_workers > 0:
+            raise ValueError("--encoded-dataset-device cuda requires --num-workers 0 to avoid worker duplication.")
+        train_dataset = EncodedAnimeDataset(
+            data=train_data,
+            tokenizer=tokenizer,
+            label2id=config.label2id,
+            max_length=config.max_seq_length,
+            device=encoded_device,
+            apply_label_repairs=args.apply_label_repairs,
+        )
+        eval_dataset = EncodedAnimeDataset(
+            data=eval_data,
+            tokenizer=tokenizer,
+            label2id=config.label2id,
+            max_length=config.max_seq_length,
+            device=encoded_device,
+            apply_label_repairs=args.apply_label_repairs,
+        )
+        dataset_mode = "encoded"
+        if not args.keep_raw_dataset:
+            train_data = []
+            all_data = []
+            gc.collect()
+    encode_finished_at = time.perf_counter()
+
+    print(f"  Train samples: {len(train_dataset)}")
+    print(f"  Eval samples: {len(eval_dataset)}")
+    print(f"  Dataset mode: {dataset_mode}")
+    print(f"  Load time: {load_finished_at - load_started_at:.2f}s")
+    print(f"  Encode time: {encode_finished_at - encode_started_at:.2f}s")
+
+    use_bf16 = bool(args.bf16 and not use_cpu)
+    use_fp16 = bool((not use_cpu) and not use_bf16 and not args.no_mixed_precision)
+    if use_cpu and args.no_mixed_precision:
+        use_fp16 = False
+    if torch.cuda.is_available() and not use_cpu and args.tf32:
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+    print(f"  Device: {'CPU' if use_cpu else 'CUDA'}")
+    if not use_cpu:
+        print(f"  Mixed precision: {'bf16' if use_bf16 else ('fp16' if use_fp16 else 'disabled')}")
+        print(f"  TF32: {'enabled' if args.tf32 else 'disabled'}")
+    eval_save_strategy = "no" if args.no_periodic_eval else ("steps" if args.checkpoint_steps else "epoch")
+    save_strategy = "steps" if args.checkpoint_steps else "epoch"
+
+    dataloader_prefetch_factor = args.prefetch_factor
+    if dataloader_prefetch_factor is None:
+        dataloader_prefetch_factor = 4 if config.num_workers > 0 else None
+    persistent_workers = bool(args.persistent_workers and config.num_workers > 0)
+    dataloader_pin_memory = bool((not use_cpu) and not (not args.lazy_dataset and args.encoded_dataset_device == "cuda"))
+    if args.lazy_dataset and config.num_workers == 0:
+        print("  WARNING: lazy dataset mode is slower with zero workers; consider --num-workers 4+.")
+
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir=config.save_dir,
+        num_train_epochs=config.num_epochs,
+        max_steps=args.max_steps,
+        per_device_train_batch_size=config.batch_size,
+        per_device_eval_batch_size=config.batch_size,
+        eval_strategy=eval_save_strategy,
+        save_strategy=save_strategy,
+        eval_steps=args.checkpoint_steps if eval_save_strategy == "steps" else None,
+        save_steps=args.checkpoint_steps,
+        logging_steps=config.log_interval,
+        learning_rate=config.learning_rate,
+        weight_decay=config.weight_decay,
+        warmup_steps=config.warmup_steps,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        use_cpu=use_cpu,
+        report_to=["tensorboard"] if args.tensorboard else "none",
+        save_total_limit=args.save_total_limit,
+        load_best_model_at_end=not args.no_periodic_eval,
+        metric_for_best_model="f1",
+        greater_is_better=True,
+        dataloader_num_workers=config.num_workers,
+        dataloader_pin_memory=dataloader_pin_memory,
+        dataloader_prefetch_factor=dataloader_prefetch_factor,
+        dataloader_persistent_workers=persistent_workers,
+        fp16=use_fp16,
+        bf16=use_bf16,
+        tf32=args.tf32 and not use_cpu,
+        torch_compile=bool(args.torch_compile and not use_cpu),
+        auto_find_batch_size=bool(args.auto_find_batch_size and not use_cpu),
+        include_num_input_tokens_seen=True,
+    )
+
+    # Data collator
+    data_collator = FastTokenClassificationCollator()
+
+    # Trainer
+    perf_callback = TrainingPerfCallback(
+        batch_size=config.batch_size,
+        sequence_length=config.max_seq_length,
+        log_steps=args.perf_log_steps,
+        sample_interval=args.perf_sample_interval,
+    )
+    trainer_cls = RDropTrainer if args.rdrop_alpha > 0 else OrderedTrainer
+    trainer_kwargs = {}
+    if args.rdrop_alpha > 0:
+        trainer_kwargs["rdrop_alpha"] = args.rdrop_alpha
+    trainer = trainer_cls(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics,
+        callbacks=[perf_callback],
+        **trainer_kwargs,
+    )
+
+    # Train
+    print("Starting training...")
+    resume_from_checkpoint = args.resume_from_checkpoint
+    if resume_from_checkpoint == "auto":
+        resume_from_checkpoint = latest_checkpoint(config.save_dir)
+        if resume_from_checkpoint:
+            print(f"Resuming from latest checkpoint: {resume_from_checkpoint}")
+        else:
+            print("No checkpoint found; starting a fresh training run.")
+    trainer.train(resume_from_checkpoint=resume_from_checkpoint)
+
+    # Set proper label mappings in model config before saving
+    model.config.id2label = config.id2label
+    model.config.label2id = config.label2id
+    model.config.label_schema_version = config.label_schema_version
+    model.config.tokenizer_variant = tokenizer_variant
+    model.config.max_seq_length = config.max_seq_length
+    save_model_head_config(model, selected_model_head)
+
+    # Save final model
+    final_save_path = os.path.join(config.save_dir, "final")
+    trainer.save_model(final_save_path)
+    tokenizer.save_pretrained(final_save_path)
+    metadata = {
+        "experiment_name": args.experiment_name,
+        "data_file": config.data_file,
+        "data_sources": data_sources,
+        "augmentation": augmentation_metadata,
+        "dataset_mode": dataset_mode,
+        "encoded_cache_dir": args.encoded_cache_dir,
+        "virtual_dataset_dir": args.virtual_dataset_dir,
+        "apply_label_repairs": args.apply_label_repairs,
+        "keep_raw_dataset": args.keep_raw_dataset,
+        "tokenizer_variant": tokenizer_variant,
+        "model_head": selected_model_head,
+        "train_crf_only": args.train_crf_only,
+        "rdrop_alpha": args.rdrop_alpha,
+        "vocab_file": vocab_path,
+        "vocab_size": tokenizer.vocab_size,
+        "max_seq_length": config.max_seq_length,
+        "hidden_size": config.hidden_size,
+        "num_hidden_layers": config.num_hidden_layers,
+        "num_attention_heads": config.num_attention_heads,
+        "intermediate_size": config.intermediate_size,
+        "train_samples": len(train_dataset),
+        "eval_samples": len(eval_dataset),
+        "load_seconds": load_finished_at - load_started_at,
+        "encode_seconds": encode_finished_at - encode_started_at,
+        "epochs": config.num_epochs,
+        "max_steps": args.max_steps,
+        "batch_size": config.batch_size,
+        "learning_rate": config.learning_rate,
+        "warmup_steps": config.warmup_steps,
+        "seed": args.seed,
+        "device": "cpu" if use_cpu else "cuda",
+        "fp16": use_fp16,
+        "gradient_accumulation_steps": training_args.gradient_accumulation_steps,
+        "dataloader_num_workers": config.num_workers,
+        "dataloader_prefetch_factor": dataloader_prefetch_factor,
+        "dataloader_persistent_workers": persistent_workers,
+        "dataloader_pin_memory": dataloader_pin_memory,
+        "encoded_dataset_device": args.encoded_dataset_device if not args.lazy_dataset else None,
+        "mixed_precision": "bf16" if use_bf16 else ("fp16" if use_fp16 else "none"),
+        "tf32": bool(args.tf32 and not use_cpu),
+        "torch_compile": bool(args.torch_compile and not use_cpu),
+        "auto_find_batch_size": bool(args.auto_find_batch_size and not use_cpu),
+        "perf_log_steps": args.perf_log_steps,
+        "perf_sample_interval": args.perf_sample_interval,
+        "periodic_eval": not args.no_periodic_eval,
+    }
+    with open(os.path.join(final_save_path, "run_metadata.json"), "w", encoding="utf-8") as f:
+        json.dump(metadata, f, ensure_ascii=False, indent=2)
+    print(f"Model saved to: {final_save_path}")
+    with open(os.path.join(final_save_path, "perf_metrics.json"), "w", encoding="utf-8") as f:
+        json.dump(perf_callback.summary(), f, ensure_ascii=False, indent=2)
+    train_runtime = None
+    if trainer.state.log_history:
+        for entry in reversed(trainer.state.log_history):
+            if "train_runtime" in entry:
+                train_runtime = entry["train_runtime"]
+                break
+    if train_runtime is not None:
+        print(f"  Train runtime: {train_runtime:.2f}s")
+        print(f"  Total wall time (load+encode+train): {(load_finished_at - load_started_at) + (encode_finished_at - encode_started_at) + train_runtime:.2f}s")
+
+    # Final evaluation
+    print("\nFinal evaluation:")
+    eval_results = trainer.evaluate()
+    for key, value in eval_results.items():
+        print(f"  {key}: {value:.4f}")
+    with open(os.path.join(final_save_path, "trainer_eval_metrics.json"), "w", encoding="utf-8") as f:
+        json.dump({key: float(value) for key, value in eval_results.items()}, f, ensure_ascii=False, indent=2)
+
+    if args.parse_eval_limit != 0:
+        parse_limit = args.parse_eval_limit if args.parse_eval_limit and args.parse_eval_limit > 0 else None
+        parse_metrics = parse_exact_metrics_all_modes(
+            eval_data,
+            trainer.model,
+            tokenizer,
+            config.id2label,
+            config.max_seq_length,
+            parse_limit,
+        )
+        with open(os.path.join(final_save_path, "parse_eval_metrics.json"), "w", encoding="utf-8") as f:
+            json.dump(parse_metrics, f, ensure_ascii=False, indent=2)
+        print("\nParse exact-match evaluation:")
+        for mode_name, mode_metrics in parse_metrics["modes"].items():
+            print(
+                f"  {mode_name}: {mode_metrics['full_match_correct']}/"
+                f"{mode_metrics['full_match_total']} ({mode_metrics['full_match_accuracy']:.4f})"
+            )
+
+    if not args.no_case_eval:
+        if args.case_eval_file and os.path.isfile(args.case_eval_file):
+            from tools.evaluate_parser_cases import evaluate_case_modes
+
+            case_metrics = evaluate_case_modes(
+                model_dir=final_save_path,
+                case_file=args.case_eval_file,
+                tokenizer_variant=tokenizer_variant,
+                max_length=config.max_seq_length,
+            )
+            case_output = args.case_eval_output or os.path.join(final_save_path, "case_metrics.json")
+            os.makedirs(os.path.dirname(case_output) or ".", exist_ok=True)
+            with open(case_output, "w", encoding="utf-8") as f:
+                json.dump(case_metrics, f, ensure_ascii=False, indent=2)
+            print("\nFixed case regression evaluation:")
+            for mode_name, mode_metrics in case_metrics["modes"].items():
+                print(
+                    f"  {mode_name}: {mode_metrics['full_correct']}/"
+                    f"{mode_metrics['case_count']} ({mode_metrics['full_accuracy']:.4f})"
+                )
+            primary = case_metrics["modes"][case_metrics["primary_metric"]]
+            if primary["failures"]:
+                print(f"  primary failures: {len(primary['failures'])} (see {case_output})")
+        elif args.case_eval_file:
+            print(f"\nSkipping fixed case regression evaluation; file not found: {args.case_eval_file}")
+
+
+if __name__ == "__main__":
+    main()
+

snapshots/anifilebert-dapt512-long/anifilebert/virtual_dataset.py

@@ -0,0 +1,114 @@
+"""Pre-encoded sharded datasets generated by the Rust virtual dataset tool."""
+
+from __future__ import annotations
+
+import bisect
+import json
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+
+class ShardedEncodedDataset(Dataset):
+    """Map-style dataset backed by pre-encoded `.npy` shards.
+
+    The Rust generator writes compact uint16/int16/u8 arrays. This class loads
+    one shard at a time and relies on sequential sampling over pre-shuffled
+    shards, so Python does no tokenization or BIO permutation during training.
+    """
+
+    preserve_order = True
+
+    def __init__(self, dataset_dir: str | Path, manifest_name: str = "manifest.json"):
+        self.dataset_dir = Path(dataset_dir)
+        self.manifest_path = self.dataset_dir / manifest_name
+        self.manifest = json.loads(self.manifest_path.read_text(encoding="utf-8"))
+        if self.manifest.get("format") != "anifilebert.virtual_dataset.shards.v1":
+            raise ValueError(f"Unsupported virtual dataset manifest: {self.manifest_path}")
+
+        self.max_length = int(self.manifest["max_length"])
+        self.shards: List[Dict] = list(self.manifest.get("shards") or [])
+        if not self.shards:
+            raise ValueError(f"Virtual dataset has no shards: {self.manifest_path}")
+
+        self._starts: List[int] = []
+        total = 0
+        for shard in self.shards:
+            self._starts.append(total)
+            total += int(shard["rows"])
+        self.total_rows = total
+
+        declared_total = int(self.manifest.get("total_rows", total))
+        if declared_total != total:
+            raise ValueError(
+                f"Virtual dataset row count mismatch: manifest total_rows={declared_total}, "
+                f"shard rows={total}"
+            )
+
+        self._cache_index: Optional[int] = None
+        self._cache: Optional[Dict[str, np.ndarray]] = None
+
+    def __len__(self) -> int:
+        return self.total_rows
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        if idx < 0:
+            idx += self.total_rows
+        if idx < 0 or idx >= self.total_rows:
+            raise IndexError(idx)
+
+        shard_idx = bisect.bisect_right(self._starts, idx) - 1
+        shard_start = self._starts[shard_idx]
+        row_idx = idx - shard_start
+        cache = self._load_shard(shard_idx)
+        return {
+            "input_ids": torch.from_numpy(cache["input_ids"][row_idx]),
+            "attention_mask": torch.from_numpy(cache["attention_mask"][row_idx]),
+            "labels": torch.from_numpy(cache["labels"][row_idx]),
+        }
+
+    def _load_shard(self, shard_idx: int) -> Dict[str, np.ndarray]:
+        if self._cache_index == shard_idx and self._cache is not None:
+            return self._cache
+
+        shard = self.shards[shard_idx]
+        cache = {
+            "input_ids": np.load(self.dataset_dir / shard["input_ids"], allow_pickle=False),
+            "attention_mask": np.load(self.dataset_dir / shard["attention_mask"], allow_pickle=False),
+            "labels": np.load(self.dataset_dir / shard["labels"], allow_pickle=False),
+        }
+        expected_shape = (int(shard["rows"]), self.max_length)
+        for key, array in cache.items():
+            if array.shape != expected_shape:
+                raise ValueError(
+                    f"Shard {shard_idx} {key} has shape {array.shape}, expected {expected_shape}"
+                )
+        self._cache_index = shard_idx
+        self._cache = cache
+        return cache
+
+
+class DatasetRangeView(Dataset):
+    """A contiguous range view over another dataset."""
+
+    preserve_order = True
+
+    def __init__(self, dataset: Dataset, start: int, end: int):
+        if start < 0 or end < start or end > len(dataset):
+            raise ValueError(f"Invalid dataset range [{start}, {end}) for length {len(dataset)}")
+        self.dataset = dataset
+        self.start = start
+        self.end = end
+
+    def __len__(self) -> int:
+        return self.end - self.start
+
+    def __getitem__(self, idx: int):
+        if idx < 0:
+            idx += len(self)
+        if idx < 0 or idx >= len(self):
+            raise IndexError(idx)
+        return self.dataset[self.start + idx]

snapshots/anifilebert-dapt512-long/config.json

@@ -0,0 +1,117 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "BertForTokenClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": null,
+  "classifier_dropout": null,
+  "dapt": {
+    "source": "/content/anifilebert-dapt256",
+    "corpus_sha256": "19603c2c6e9474c33e2374692a3d0f411ea88fc37811b2cbfdc8d0520809406c",
+    "epochs": 40,
+    "positions": 256,
+    "init": "random"
+  },
+  "dtype": "float32",
+  "eos_token_id": null,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 512,
+  "id2label": {
+    "0": "O",
+    "1": "B-TITLE_CHS",
+    "2": "I-TITLE_CHS",
+    "3": "B-TITLE_CHT",
+    "4": "I-TITLE_CHT",
+    "5": "B-TITLE_JPN",
+    "6": "I-TITLE_JPN",
+    "7": "B-TITLE_LATIN",
+    "8": "I-TITLE_LATIN",
+    "9": "B-TITLE_MIXED",
+    "10": "I-TITLE_MIXED",
+    "11": "B-PATH_TITLE_CHS",
+    "12": "I-PATH_TITLE_CHS",
+    "13": "B-PATH_TITLE_CHT",
+    "14": "I-PATH_TITLE_CHT",
+    "15": "B-PATH_TITLE_JPN",
+    "16": "I-PATH_TITLE_JPN",
+    "17": "B-PATH_TITLE_LATIN",
+    "18": "I-PATH_TITLE_LATIN",
+    "19": "B-PATH_TITLE_MIXED",
+    "20": "I-PATH_TITLE_MIXED",
+    "21": "B-PATH_SEASON",
+    "22": "I-PATH_SEASON",
+    "23": "B-SEASON",
+    "24": "I-SEASON",
+    "25": "B-EPISODE",
+    "26": "I-EPISODE",
+    "27": "B-SPECIAL",
+    "28": "I-SPECIAL",
+    "29": "B-GROUP",
+    "30": "I-GROUP",
+    "31": "B-RESOLUTION",
+    "32": "I-RESOLUTION",
+    "33": "B-SOURCE",
+    "34": "I-SOURCE",
+    "35": "B-TAG",
+    "36": "I-TAG"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 2048,
+  "is_decoder": false,
+  "label2id": {
+    "B-EPISODE": 25,
+    "B-GROUP": 29,
+    "B-PATH_SEASON": 21,
+    "B-PATH_TITLE_CHS": 11,
+    "B-PATH_TITLE_CHT": 13,
+    "B-PATH_TITLE_JPN": 15,
+    "B-PATH_TITLE_LATIN": 17,
+    "B-PATH_TITLE_MIXED": 19,
+    "B-RESOLUTION": 31,
+    "B-SEASON": 23,
+    "B-SOURCE": 33,
+    "B-SPECIAL": 27,
+    "B-TAG": 35,
+    "B-TITLE_CHS": 1,
+    "B-TITLE_CHT": 3,
+    "B-TITLE_JPN": 5,
+    "B-TITLE_LATIN": 7,
+    "B-TITLE_MIXED": 9,
+    "I-EPISODE": 26,
+    "I-GROUP": 30,
+    "I-PATH_SEASON": 22,
+    "I-PATH_TITLE_CHS": 12,
+    "I-PATH_TITLE_CHT": 14,
+    "I-PATH_TITLE_JPN": 16,
+    "I-PATH_TITLE_LATIN": 18,
+    "I-PATH_TITLE_MIXED": 20,
+    "I-RESOLUTION": 32,
+    "I-SEASON": 24,
+    "I-SOURCE": 34,
+    "I-SPECIAL": 28,
+    "I-TAG": 36,
+    "I-TITLE_CHS": 2,
+    "I-TITLE_CHT": 4,
+    "I-TITLE_JPN": 6,
+    "I-TITLE_LATIN": 8,
+    "I-TITLE_MIXED": 10,
+    "O": 0
+  },
+  "label_schema_version": 2,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 256,
+  "max_seq_length": 256,
+  "model_head": "linear",
+  "model_type": "bert",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 8,
+  "pad_token_id": 0,
+  "tie_word_embeddings": true,
+  "tokenizer_variant": "char",
+  "transformers_version": "5.16.1",
+  "type_vocab_size": 2,
+  "use_cache": false,
+  "vocab_size": 6199
+}

snapshots/anifilebert-dapt512-long/dapt.json

@@ -0,0 +1,324 @@
+{
+  "snapshot_in": "/content/anifilebert-dapt256",
+  "snapshot_in_hashes": {
+    "config.json": "e98b7fd61b147293fa29fa5be0c5cc3e7a9ecc94ee71fefd55c74145be9cb3aa",
+    "model.safetensors": "16a691527a483b4a9581aa75b08aa21415c77fc1654230b1738659349908a3db"
+  },
+  "architecture": {
+    "hidden": 512,
+    "intermediate": 2048,
+    "layers": 8,
+    "heads": 8,
+    "init": "random (no weight transfer; tiled init falsified earlier at 10-12%)"
+  },
+  "positions": 256,
+  "epochs": 40,
+  "batch": 128,
+  "lr": 0.0003,
+  "warmup": 0.05,
+  "mask_rate": 0.2,
+  "span_p": 0.3,
+  "max_span": 5,
+  "seed": 1,
+  "holdout_share": 0.01,
+  "holdout_rows": 1638,
+  "train_rows": 162253,
+  "corpus_sha256": "19603c2c6e9474c33e2374692a3d0f411ea88fc37811b2cbfdc8d0520809406c",
+  "corpus": {
+    "read": 205241,
+    "dropped_eval_query": 1907,
+    "dropped_ia_artifact": 37367,
+    "dropped_over_limit": 5,
+    "dropped_duplicate": 2071,
+    "dropped_empty": 0,
+    "per_source": {
+      "data/tier2/srrdb-v1.jsonl": 65208,
+      "data/tier2/archive-v1.jsonl": 23338,
+      "data/tier2/nyaa-v1.jsonl": 20940,
+      "data/tier2/sukebei-v1.jsonl": 51492,
+      "data/dmhy-unlabeled.jsonl": 2913,
+      "data/label-v2/fresh-real-holdout.jsonl": 0
+    },
+    "kept": 163891
+  },
+  "excluded_sets": [
+    "data/label-v2/fresh-204-gold.jsonl",
+    "data/label-v2/fresh-204.jsonl",
+    "data/fresh.jsonl",
+    "data/fresh2.jsonl",
+    "data/challenge.jsonl",
+    "data/public-guessit.jsonl",
+    "data/public-guessit-dev.jsonl",
+    "data/public-guessit-holdout.jsonl",
+    "data/public-guessit-holdout-part2.jsonl",
+    "data/label-v2/dev-review-500.jsonl",
+    "data/real-dev-v1/queries.jsonl",
+    "data/real-final-v1/queries.jsonl",
+    "data/claim-v1/candidates-v1.jsonl",
+    "data/claim-v1/candidates-draft-1.jsonl"
+  ],
+  "device": "cuda",
+  "gpu": "Tesla T4",
+  "versions": {
+    "torch": "2.11.0+cu128",
+    "transformers": "5.16.1"
+  },
+  "python": "3.13.15",
+  "steps": 50720,
+  "parameters_bert": 28526592,
+  "objective": "character-span MLM, 80/10/10, [MASK] extra row sliced off",
+  "amp": "fp16 autocast + GradScaler",
+  "history": [
+    {
+      "epoch": 0,
+      "holdout_mlm_loss": 8.736900679270427
+    },
+    {
+      "epoch": 1,
+      "train_mlm_loss": 4.375227061731958,
+      "holdout_mlm_loss": 3.082608746754828,
+      "elapsed_s": 473.22246381100007
+    },
+    {
+      "epoch": 2,
+      "train_mlm_loss": 2.921732526472314,
+      "holdout_mlm_loss": 2.3707259732961794,
+      "elapsed_s": 965.171059061
+    },
+    {
+      "epoch": 3,
+      "train_mlm_loss": 2.310178040141939,
+      "holdout_mlm_loss": 1.9282451339130369,
+      "elapsed_s": 1461.560635293
+    },
+    {
+      "epoch": 4,
+      "train_mlm_loss": 2.009391780531369,
+      "holdout_mlm_loss": 1.7396270345598372,
+      "elapsed_s": 1983.4991681769998
+    },
+    {
+      "epoch": 5,
+      "train_mlm_loss": 1.8412692695386026,
+      "holdout_mlm_loss": 1.6269481165695958,
+      "elapsed_s": 2502.328366302
+    },
+    {
+      "epoch": 6,
+      "train_mlm_loss": 1.7270084329019961,
+      "holdout_mlm_loss": 1.5293834144450085,
+      "elapsed_s": 3023.782586561
+    },
+    {
+      "epoch": 7,
+      "train_mlm_loss": 1.646504476807471,
+      "holdout_mlm_loss": 1.4373808990762915,
+      "elapsed_s": 3537.305681859
+    },
+    {
+      "epoch": 8,
+      "train_mlm_loss": 1.574756050335496,
+      "holdout_mlm_loss": 1.401929478790819,
+      "elapsed_s": 4057.726921014
+    },
+    {
+      "epoch": 9,
+      "train_mlm_loss": 1.5194406214196599,
+      "holdout_mlm_loss": 1.328548753494906,
+      "elapsed_s": 4579.3266502510005
+    },
+    {
+      "epoch": 10,
+      "train_mlm_loss": 1.4719956642257679,
+      "holdout_mlm_loss": 1.2935118025723173,
+      "elapsed_s": 5092.0404690880005
+    },
+    {
+      "epoch": 11,
+      "train_mlm_loss": 1.426325940277298,
+      "holdout_mlm_loss": 1.2353786466893069,
+      "elapsed_s": 5610.439997930001
+    },
+    {
+      "epoch": 12,
+      "train_mlm_loss": 1.3938762441230497,
+      "holdout_mlm_loss": 1.195163792495283,
+      "elapsed_s": 6126.902060184
+    },
+    {
+      "epoch": 13,
+      "train_mlm_loss": 1.3602659516154028,
+      "holdout_mlm_loss": 1.1963921446291002,
+      "elapsed_s": 6643.345326788
+    },
+    {
+      "epoch": 14,
+      "train_mlm_loss": 1.3310112461964791,
+      "holdout_mlm_loss": 1.1719167419391319,
+      "elapsed_s": 7158.663597382
+    },
+    {
+      "epoch": 15,
+      "train_mlm_loss": 1.3018222616203952,
+      "holdout_mlm_loss": 1.1406991097353352,
+      "elapsed_s": 7674.778165433
+    },
+    {
+      "epoch": 16,
+      "train_mlm_loss": 1.2804211497024782,
+      "holdout_mlm_loss": 1.1341703165380448,
+      "elapsed_s": 8191.362704859001
+    },
+    {
+      "epoch": 17,
+      "train_mlm_loss": 1.2533993123551648,
+      "holdout_mlm_loss": 1.0945481520208327,
+      "elapsed_s": 8710.747675615
+    },
+    {
+      "epoch": 18,
+      "train_mlm_loss": 1.2323334291812373,
+      "holdout_mlm_loss": 1.038608076350059,
+      "elapsed_s": 9241.942765345
+    },
+    {
+      "epoch": 19,
+      "train_mlm_loss": 1.2135629186682897,
+      "holdout_mlm_loss": 1.0817996912051977,
+      "elapsed_s": 9768.857448345001
+    },
+    {
+      "epoch": 20,
+      "train_mlm_loss": 1.1976666132264333,
+      "holdout_mlm_loss": 1.026019362100734,
+      "elapsed_s": 10301.676275611
+    },
+    {
+      "epoch": 21,
+      "train_mlm_loss": 1.1742801736299924,
+      "holdout_mlm_loss": 1.036750700323487,
+      "elapsed_s": 10833.644632479001
+    },
+    {
+      "epoch": 22,
+      "train_mlm_loss": 1.157978573714145,
+      "holdout_mlm_loss": 1.022209767153981,
+      "elapsed_s": 11365.032796672
+    },
+    {
+      "epoch": 23,
+      "train_mlm_loss": 1.1439975256141428,
+      "holdout_mlm_loss": 0.9994724594764347,
+      "elapsed_s": 11901.12091463
+    },
+    {
+      "epoch": 24,
+      "train_mlm_loss": 1.1271965087212223,
+      "holdout_mlm_loss": 0.9778515305234978,
+      "elapsed_s": 12434.125638841
+    },
+    {
+      "epoch": 25,
+      "train_mlm_loss": 1.1131970593323843,
+      "holdout_mlm_loss": 0.9848204346415498,
+      "elapsed_s": 12962.98398002
+    },
+    {
+      "epoch": 26,
+      "train_mlm_loss": 1.101351912277354,
+      "holdout_mlm_loss": 0.9536828525565998,
+      "elapsed_s": 13497.383910074
+    },
+    {
+      "epoch": 27,
+      "train_mlm_loss": 1.0843816055954443,
+      "holdout_mlm_loss": 0.9409382480619691,
+      "elapsed_s": 14031.078410321
+    },
+    {
+      "epoch": 28,
+      "train_mlm_loss": 1.0690194438872653,
+      "holdout_mlm_loss": 0.9394280088997875,
+      "elapsed_s": 14565.136020853
+    },
+    {
+      "epoch": 29,
+      "train_mlm_loss": 1.057727008963985,
+      "holdout_mlm_loss": 0.9545883247511924,
+      "elapsed_s": 15098.791554832
+    },
+    {
+      "epoch": 30,
+      "train_mlm_loss": 1.0468679916125367,
+      "holdout_mlm_loss": 0.8919381346898856,
+      "elapsed_s": 15628.84965083
+    },
+    {
+      "epoch": 31,
+      "train_mlm_loss": 1.0329651913432292,
+      "holdout_mlm_loss": 0.8894025552320837,
+      "elapsed_s": 16156.606742554
+    },
+    {
+      "epoch": 32,
+      "train_mlm_loss": 1.023009018379055,
+      "holdout_mlm_loss": 0.8942983575401185,
+      "elapsed_s": 16689.836699018
+    },
+    {
+      "epoch": 33,
+      "train_mlm_loss": 1.0094722742067903,
+      "holdout_mlm_loss": 0.9136225821200499,
+      "elapsed_s": 17226.209608491998
+    },
+    {
+      "epoch": 34,
+      "train_mlm_loss": 1.002932391332151,
+      "holdout_mlm_loss": 0.8861584491096973,
+      "elapsed_s": 17763.845154249
+    },
+    {
+      "epoch": 35,
+      "train_mlm_loss": 0.9899584314424533,
+      "holdout_mlm_loss": 0.8871160014580225,
+      "elapsed_s": 18294.783446789
+    },
+    {
+      "epoch": 36,
+      "train_mlm_loss": 0.9856679144811931,
+      "holdout_mlm_loss": 0.8825822870897437,
+      "elapsed_s": 18826.522195192
+    },
+    {
+      "epoch": 37,
+      "train_mlm_loss": 0.9752545805195528,
+      "holdout_mlm_loss": 0.8969957123114312,
+      "elapsed_s": 19356.763768114
+    },
+    {
+      "epoch": 38,
+      "train_mlm_loss": 0.967770243621775,
+      "holdout_mlm_loss": 0.8895354318563871,
+      "elapsed_s": 19890.734426236
+    },
+    {
+      "epoch": 39,
+      "train_mlm_loss": 0.9623078745716378,
+      "holdout_mlm_loss": 0.8633429595431722,
+      "elapsed_s": 20425.087323116
+    },
+    {
+      "epoch": 40,
+      "train_mlm_loss": 0.9588589362729611,
+      "holdout_mlm_loss": 0.8765054039867294,
+      "elapsed_s": 20956.778915133
+    }
+  ],
+  "export": {
+    "max_position_embeddings": 256,
+    "vocab_size": 6199,
+    "roundtrip_max_abs_diff": 0.0,
+    "model_sha256": "509125db5cc4bee9f3949b44e1c17f86b89406c8efee6a7376c39de8b3db7a0d",
+    "parameters_encoder": 28526080
+  }
+}

snapshots/anifilebert-dapt512-long/label_schema.json

@@ -0,0 +1,80 @@
+{
+  "version": 2,
+  "labels": [
+    "O",
+    "B-TITLE_CHS",
+    "I-TITLE_CHS",
+    "B-TITLE_CHT",
+    "I-TITLE_CHT",
+    "B-TITLE_JPN",
+    "I-TITLE_JPN",
+    "B-TITLE_LATIN",
+    "I-TITLE_LATIN",
+    "B-TITLE_MIXED",
+    "I-TITLE_MIXED",
+    "B-PATH_TITLE_CHS",
+    "I-PATH_TITLE_CHS",
+    "B-PATH_TITLE_CHT",
+    "I-PATH_TITLE_CHT",
+    "B-PATH_TITLE_JPN",
+    "I-PATH_TITLE_JPN",
+    "B-PATH_TITLE_LATIN",
+    "I-PATH_TITLE_LATIN",
+    "B-PATH_TITLE_MIXED",
+    "I-PATH_TITLE_MIXED",
+    "B-PATH_SEASON",
+    "I-PATH_SEASON",
+    "B-SEASON",
+    "I-SEASON",
+    "B-EPISODE",
+    "I-EPISODE",
+    "B-SPECIAL",
+    "I-SPECIAL",
+    "B-GROUP",
+    "I-GROUP",
+    "B-RESOLUTION",
+    "I-RESOLUTION",
+    "B-SOURCE",
+    "I-SOURCE",
+    "B-TAG",
+    "I-TAG"
+  ],
+  "title_entities": [
+    "TITLE_CHS",
+    "TITLE_CHT",
+    "TITLE_JPN",
+    "TITLE_LATIN",
+    "TITLE_MIXED",
+    "PATH_TITLE_CHS",
+    "PATH_TITLE_CHT",
+    "PATH_TITLE_JPN",
+    "PATH_TITLE_LATIN",
+    "PATH_TITLE_MIXED"
+  ],
+  "file_title_entities": [
+    "TITLE_CHS",
+    "TITLE_CHT",
+    "TITLE_JPN",
+    "TITLE_LATIN",
+    "TITLE_MIXED"
+  ],
+  "path_title_entities": [
+    "PATH_TITLE_CHS",
+    "PATH_TITLE_CHT",
+    "PATH_TITLE_JPN",
+    "PATH_TITLE_LATIN",
+    "PATH_TITLE_MIXED"
+  ],
+  "title_priority": [
+    "CHS",
+    "CHT",
+    "JPN",
+    "MIXED",
+    "LATIN"
+  ],
+  "notes": {
+    "PATH_SEASON": "Season value extracted from a directory/path segment. File-level SEASON wins when both are present.",
+    "TAG": "Non-key side tags such as 国漫, 日漫, 剧场版, Gekijouban, Movie, TV, and years.",
+    "TITLE_LATIN": "Latin-script titles, including English aliases and romaji."
+  }
+}

snapshots/anifilebert-dapt512-long/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:509125db5cc4bee9f3949b44e1c17f86b89406c8efee6a7376c39de8b3db7a0d
+size 114195812

snapshots/anifilebert-dapt512-long/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "anifilebert"
+version = "0.1.0"
+description = "Tiny BERT token-classification model and tooling for parsing anime release filenames."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+dependencies = [
+    "accelerate==1.13.0",
+    "datasets==4.8.5",
+    "numpy==2.4.5",
+    "onnx==1.21.0",
+    "onnxruntime==1.26.0",
+    "onnxscript==0.7.0",
+    "seqeval==1.2.2",
+    "tensorboard>=2.14.0",
+    "torch==2.13.0.dev20260601+cu132",
+    "transformers==5.8.1",
+]
+
+[project.urls]
+Repository = "https://huggingface.co/ModerRAS/AniFileBERT"
+
+[tool.uv]
+package = false
+environments = ["sys_platform == 'win32'"]
+
+[tool.uv.sources]
+torch = [
+    { index = "pytorch-cu132-nightly", marker = "platform_system == 'Windows'" },
+]
+
+[[tool.uv.index]]
+name = "pytorch-cu132-nightly"
+url = "https://download.pytorch.org/whl/nightly/cu132"
+explicit = true

snapshots/anifilebert-dapt512-long/requirements.txt

@@ -0,0 +1,12 @@
+--extra-index-url https://download.pytorch.org/whl/cu126
+
+accelerate==1.13.0
+datasets==4.8.5
+numpy==2.4.5
+onnx==1.21.0
+onnxruntime==1.26.0
+onnxscript==0.7.0
+seqeval==1.2.2
+tensorboard>=2.14.0
+torch==2.12.0+cu126
+transformers==5.8.1

snapshots/anifilebert-dapt512-long/tokenizer_config.json

@@ -0,0 +1,44 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "backend": "custom",
+  "cls_token": "[CLS]",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "tokenizer_class": "CharAnimeTokenizer",
+  "tokenizer_variant": "char",
+  "unk_token": "[UNK]"
+}

snapshots/anifilebert-dapt512-long/vocab.char.json

@@ -0,0 +1,6201 @@
+{
+  "[PAD]": 0,
+  "[UNK]": 1,
+  "[CLS]": 2,
+  "[SEP]": 3,
+  " ": 4,
+  "[": 5,
+  "]": 6,
+  "0": 7,
+  "a": 8,
+  "i": 9,
+  "o": 10,
+  "1": 11,
+  "e": 12,
+  "2": 13,
+  "A": 14,
+  "C": 15,
+  "n": 16,
+  "u": 17,
+  "s": 18,
+  "D": 19,
+  "t": 20,
+  "-": 21,
+  "B": 22,
+  "S": 23,
+  "r": 24,
+  "8": 25,
+  "P": 26,
+  "p": 27,
+  "4": 28,
+  "H": 29,
+  "V": 30,
+  "R": 31,
+  "k": 32,
+  "x": 33,
+  "_": 34,
+  "h": 35,
+  "E": 36,
+  "6": 37,
+  "M": 38,
+  "l": 39,
+  "m": 40,
+  "7": 41,
+  "F": 42,
+  "b": 43,
+  "G": 44,
+  "T": 45,
+  "L": 46,
+  "c": 47,
+  "5": 48,
+  "w": 49,
+  ".": 50,
+  "9": 51,
+  "I": 52,
+  "d": 53,
+  "N": 54,
+  "3": 55,
+  "(": 56,
+  "K": 57,
+  ")": 58,
+  "g": 59,
+  "y": 60,
+  "O": 61,
+  "W": 62,
+  "Y": 63,
+  "U": 64,
+  "z": 65,
+  "X": 66,
+  "J": 67,
+  "&": 68,
+  "!": 69,
+  "v": 70,
+  "f": 71,
+  "j": 72,
+  "第": 73,
+  "【": 74,
+  "】": 75,
+  "話": 76,
+  "Z": 77,
+  "の": 78,
+  "ー": 79,
+  "ン": 80,
+  "「": 81,
+  "」": 82,
+  "ア": 83,
+  ",": 84,
+  "幕": 85,
+  "字": 86,
+  "ル": 87,
+  "的": 88,
+  "イ": 89,
+  "ス": 90,
+  "！": 91,
+  "组": 92,
+  "ニ": 93,
+  "メ": 94,
+  "ラ": 95,
+  "Q": 96,
+  "女": 97,
+  "ト": 98,
+  "季": 99,
+  "い": 100,
+  "魔": 101,
+  "'": 102,
+  "リ": 103,
+  "之": 104,
+  "漫": 105,
+  "ド": 106,
+  "国": 107,
+  "ク": 108,
+  "ッ": 109,
+  "少": 110,
+  "日": 111,
+  "王": 112,
+  "神": 113,
+  "な": 114,
+  "ん": 115,
+  "人": 116,
+  "る": 117,
+  "小": 118,
+  "ジ": 119,
+  "レ": 120,
+  "タ": 121,
+  "と": 122,
+  "新": 123,
+  "た": 124,
+  "天": 125,
+  "简": 126,
+  "体": 127,
+  "・": 128,
+  "×": 129,
+  "大": 130,
+  "~": 131,
+  "话": 132,
+  "者": 133,
+  "は": 134,
+  "マ": 135,
+  "カ": 136,
+  "か": 137,
+  "光": 138,
+  "+": 139,
+  "世": 140,
+  "：": 141,
+  "ら": 142,
+  "集": 143,
+  "界": 144,
+  "ロ": 145,
+  "し": 146,
+  "版": 147,
+  "美": 148,
+  "キ": 149,
+  "语": 150,
+  "漏": 151,
+  "ズ": 152,
+  "勺": 153,
+  "子": 154,
+  "シ": 155,
+  "テ": 156,
+  "士": 157,
+  "デ": 158,
+  "り": 159,
+  "オ": 160,
+  "双": 161,
+  "生": 162,
+  "が": 163,
+  "＆": 164,
+  "れ": 165,
+  "コ": 166,
+  "ガ": 167,
+  "ィ": 168,
+  "二": 169,
+  "特": 170,
+  "星": 171,
+  "ャ": 172,
+  "ち": 173,
+  "プ": 174,
+  "に": 175,
+  "像": 176,
+  "法": 177,
+  "戦": 178,
+  "中": 179,
+  "一": 180,
+  "て": 181,
+  "ま": 182,
+  "／": 183,
+  "グ": 184,
+  "ブ": 185,
+  "#": 186,
+  "フ": 187,
+  "ュ": 188,
+  "☆": 189,
+  "モ": 190,
+  "っ": 191,
+  "作": 192,
+  "梦": 193,
+  "バ": 194,
+  "く": 195,
+  "さ": 196,
+  "ム": 197,
+  ";": 198,
+  "海": 199,
+  "う": 200,
+  "ダ": 201,
+  "～": 202,
+  "域": 203,
+  "チ": 204,
+  "空": 205,
+  "お": 206,
+  "ナ": 207,
+  "エ": 208,
+  "篇": 209,
+  "典": 210,
+  "q": 211,
+  "映": 212,
+  "我": 213,
+  "·": 214,
+  "物": 215,
+  "こ": 216,
+  "（": 217,
+  "龙": 218,
+  "異": 219,
+  "繁": 220,
+  "？": 221,
+  "猪": 222,
+  "三": 223,
+  "番": 224,
+  "夜": 225,
+  "）": 226,
+  "伝": 227,
+  "月": 228,
+  "超": 229,
+  "も": 230,
+  "組": 231,
+  "动": 232,
+  "年": 233,
+  "ノ": 234,
+  "を": 235,
+  "き": 236,
+  "@": 237,
+  "名": 238,
+  "影": 239,
+  "家": 240,
+  "高": 241,
+  "使": 242,
+  "あ": 243,
+  "不": 244,
+  "パ": 245,
+  "制": 246,
+  "で": 247,
+  "ョ": 248,
+  "斗": 249,
+  "ツ": 250,
+  "す": 251,
+  "学": 252,
+  "み": 253,
+  "ウ": 254,
+  "怪": 255,
+  "地": 256,
+  "死": 257,
+  "告": 258,
+  "忍": 259,
+  "ミ": 260,
+  "探": 261,
+  "ハ": 262,
+  "ボ": 263,
+  "南": 264,
+  "战": 265,
+  "火": 266,
+  "セ": 267,
+  "だ": 268,
+  "主": 269,
+  "え": 270,
+  "花": 271,
+  "よ": 272,
+  "ゴ": 273,
+  "异": 274,
+  "Ⅱ": 275,
+  "笔": 276,
+  "予": 277,
+  "サ": 278,
+  "上": 279,
+  "ゃ": 280,
+  "英": 281,
+  "啦": 282,
+  "柯": 283,
+  "蜡": 284,
+  "侦": 285,
+  "活": 286,
+  "語": 287,
+  "、": 288,
+  "雄": 289,
+  "珠": 290,
+  "事": 291,
+  "仙": 292,
+  "體": 293,
+  "哆": 294,
+  "万": 295,
+  "蓝": 296,
+  "め": 297,
+  "色": 298,
+  "つ": 299,
+  "想": 300,
+  "宝": 301,
+  "け": 302,
+  "与": 303,
+  "説": 304,
+  "場": 305,
+  "勇": 306,
+  "回": 307,
+  "犬": 308,
+  "本": 309,
+  "重": 310,
+  "妖": 311,
+  "最": 312,
+  "太": 313,
+  "偶": 314,
+  "ァ": 315,
+  "心": 316,
+  "宇": 317,
+  "传": 318,
+  "宙": 319,
+  "ヤ": 320,
+  "贼": 321,
+  "明": 322,
+  "ビ": 323,
+  "編": 324,
+  "四": 325,
+  "出": 326,
+  "ベ": 327,
+  "完": 328,
+  "ふ": 329,
+  "云": 330,
+  "ェ": 331,
+  "遊": 332,
+  "师": 333,
+  "来": 334,
+  "ゲ": 335,
+  "恋": 336,
+  "ヴ": 337,
+  "｢": 338,
+  "ソ": 339,
+  "｣": 340,
+  "道": 341,
+  "锛": 342,
+  "金": 343,
+  "そ": 344,
+  "ネ": 345,
+  "灵": 346,
+  "是": 347,
+  "わ": 348,
+  "风": 349,
+  "科": 350,
+  "行": 351,
+  "精": 352,
+  "機": 353,
+  "冒": 354,
+  "八": 355,
+  "成": 356,
+  "���": 357,
+  "ワ": 358,
+  "動": 359,
+  "白": 360,
+  "叉": 361,
+  "百": 362,
+  "限": 363,
+  "树": 364,
+  "会": 365,
+  "鬼": 366,
+  "记": 367,
+  "舞": 368,
+  "ザ": 369,
+  "樱": 370,
+  "黑": 371,
+  "ケ": 372,
+  "奇": 373,
+  "劇": 374,
+  "外": 375,
+  "ど": 376,
+  "愛": 377,
+  "目": 378,
+  "青": 379,
+  "じ": 380,
+  "次": 381,
+  "清": 382,
+  "时": 383,
+  "無": 384,
+  "期": 385,
+  "下": 386,
+  "夏": 387,
+  "了": 388,
+  "球": 389,
+  "ひ": 390,
+  "記": 391,
+  "校": 392,
+  "兽": 393,
+  "场": 394,
+  "妹": 395,
+  "ゼ": 396,
+  "城": 397,
+  "公": 398,
+  "彼": 399,
+  "ギ": 400,
+  "兄": 401,
+  "羊": 402,
+  "河": 403,
+  "ば": 404,
+  "冷": 405,
+  "手": 406,
+  "晨": 407,
+  "曦": 408,
+  "ろ": 409,
+  "爆": 410,
+  "男": 411,
+  "郎": 412,
+  "，": 413,
+  "隊": 414,
+  "教": 415,
+  "剧": 416,
+  "雪": 417,
+  "有": 418,
+  "游": 419,
+  "力": 420,
+  "前": 421,
+  "師": 422,
+  "Ⅲ": 423,
+  "へ": 424,
+  "面": 425,
+  "食": 426,
+  "狂": 427,
+  "。": 428,
+  "始": 429,
+  "せ": 430,
+  "狼": 431,
+  "可": 432,
+  "全": 433,
+  "都": 434,
+  "件": 435,
+  "族": 436,
+  "破": 437,
+  "武": 438,
+  "末": 439,
+  "补": 440,
+  "や": 441,
+  "在": 442,
+  "银": 443,
+  "决": 444,
+  "銀": 445,
+  "无": 446,
+  "ぎ": 447,
+  "京": 448,
+  "未": 449,
+  "ペ": 450,
+  "戰": 451,
+  "強": 452,
+  "園": 453,
+  "音": 454,
+  "和": 455,
+  "招": 456,
+  "卡": 457,
+  "妙": 458,
+  "文": 459,
+  "騎": 460,
+  "台": 461,
+  "猫": 462,
+  "丸": 463,
+  "七": 464,
+  "歌": 465,
+  "旅": 466,
+  "娘": 467,
+  "闘": 468,
+  "能": 469,
+  "弟": 470,
+  "★": 471,
+  "山": 472,
+  "黒": 473,
+  "ピ": 474,
+  "君": 475,
+  "爱": 476,
+  "章": 477,
+  "風": 478,
+  "戏": 479,
+  "斯": 480,
+  "血": 481,
+  "春": 482,
+  "銉": 483,
+  "部": 484,
+  "院": 485,
+  "學": 486,
+  "聖": 487,
+  "ょ": 488,
+  "五": 489,
+  "机": 490,
+  "真": 491,
+  "流": 492,
+  "改": 493,
+  "術": 494,
+  "巴": 495,
+  "乱": 496,
+  "東": 497,
+  "募": 498,
+  "険": 499,
+  "決": 500,
+  "画": 501,
+  "幻": 502,
+  "命": 503,
+  "拳": 504,
+  "救": 505,
+  "代": 506,
+  "間": 507,
+  "戯": 508,
+  "野": 509,
+  "自": 510,
+  "先": 511,
+  "石": 512,
+  "翻": 513,
+  "巻": 514,
+  "十": 515,
+  "迷": 516,
+  "路": 517,
+  "艦": 518,
+  "圣": 519,
+  "後": 520,
+  "剑": 521,
+  "市": 522,
+  "译": 523,
+  "紀": 524,
+  "纪": 525,
+  "暗": 526,
+  "北": 527,
+  "常": 528,
+  "時": 529,
+  "尾": 530,
+  "ご": 531,
+  "為": 532,
+  "ポ": 533,
+  "拉": 534,
+  "穹": 535,
+  "榫": 536,
+  "走": 537,
+  "踪": 538,
+  "ぶ": 539,
+  "千": 540,
+  "喜": 541,
+  "甜": 542,
+  "苍": 543,
+  "园": 544,
+  "所": 545,
+  "½": 546,
+  "安": 547,
+  "港": 548,
+  "撃": 549,
+  "电": 550,
+  "俺": 551,
+  "夢": 552,
+  "僅": 553,
+  "澳": 554,
+  "修": 555,
+  "矢": 556,
+  "室": 557,
+  "書": 558,
+  "赤": 559,
+  "區": 560,
+  "欑": 561,
+  "险": 562,
+  "合": 563,
+  "方": 564,
+  "様": 565,
+  "六": 566,
+  "变": 567,
+  "ォ": 568,
+  "灰": 569,
+  "姐": 570,
+  "里": 571,
+  "彔": 572,
+  "與": 573,
+  "ヒ": 574,
+  "鉄": 575,
+  "ゆ": 576,
+  "び": 577,
+  "実": 578,
+  "…": 579,
+  "殺": 580,
+  "逆": 581,
+  "ぐ": 582,
+  "元": 583,
+  "等": 584,
+  "秘": 585,
+  "内": 586,
+  "終": 587,
+  "嵌": 588,
+  "転": 589,
+  "到": 590,
+  "田": 591,
+  "姫": 592,
+  "僕": 593,
+  "雨": 594,
+  "孩": 595,
+  "草": 596,
+  "ず": 597,
+  "同": 598,
+  "再": 599,
+  "码": 600,
+  "開": 601,
+  "禁": 602,
+  "`": 603,
+  "原": 604,
+  "旋": 605,
+  "好": 606,
+  "脳": 607,
+  "涔": 608,
+  "水": 609,
+  "巨": 610,
+  "堕": 611,
+  "笑": 612,
+  "思": 613,
+  "独": 614,
+  "录": 615,
+  "配": 616,
+  "社": 617,
+  "灏": 618,
+  "情": 619,
+  "桃": 620,
+  "骑": 621,
+  "贝": 622,
+  "老": 623,
+  "櫻": 624,
+  "知": 625,
+  "言": 626,
+  "被": 627,
+  "身": 628,
+  "图": 629,
+  "挂": 630,
+  "杀": 631,
+  "軍": 632,
+  "約": 633,
+  "炎": 634,
+  "牙": 635,
+  "理": 636,
+  "ホ": 637,
+  "閾": 638,
+  "龍": 639,
+  "獣": 640,
+  "眼": 641,
+  "見": 642,
+  "Ⅰ": 643,
+  "む": 644,
+  "放": 645,
+  "派": 646,
+  "瓊": 647,
+  "ユ": 648,
+  "数": 649,
+  "戟": 650,
+  "后": 651,
+  "曲": 652,
+  "変": 653,
+  "器": 654,
+  "ヘ": 655,
+  "境": 656,
+  "鋼": 657,
+  "魂": 658,
+  "剣": 659,
+  "形": 660,
+  "街": 661,
+  "進": 662,
+  "恶": 663,
+  "落": 664,
+  "史": 665,
+  "咪": 666,
+  "相": 667,
+  "意": 668,
+  "平": 669,
+  "就": 670,
+  "克": 671,
+  "用": 672,
+  "博": 673,
+  "攻": 674,
+  "飛": 675,
+  "発": 676,
+  "貓": 677,
+  "玩": 678,
+  "比": 679,
+  "刀": 680,
+  "結": 681,
+  "要": 682,
+  "入": 683,
+  "车": 684,
+  "虫": 685,
+  "化": 686,
+  "九": 687,
+  "甲": 688,
+  "推": 689,
+  "育": 690,
+  "密": 691,
+  "马": 692,
+  "悪": 693,
+  "头": 694,
+  "電": 695,
+  "墓": 696,
+  "印": 697,
+  "ぬ": 698,
+  "Ⅴ": 699,
+  "红": 700,
+  "島": 701,
+  "你": 702,
+  "義": 703,
+  "ぼ": 704,
+  "轉": 705,
+  "ね": 706,
+  "罗": 707,
+  "装": 708,
+  "邦": 709,
+  "戲": 710,
+  "吧": 711,
+  "竜": 712,
+  "莺": 713,
+  "対": 714,
+  "長": 715,
+  "永": 716,
+  "疾": 717,
+  "べ": 718,
+  "劣": 719,
+  "悟": 720,
+  "　": 721,
+  "消": 722,
+  "ヨ": 723,
+  "通": 724,
+  "雷": 725,
+  "曹": 726,
+  "勝": 727,
+  "乌": 728,
+  "击": 729,
+  "果": 730,
+  "{": 731,
+  "線": 732,
+  "防": 733,
+  "德": 734,
+  "}": 735,
+  "ぞ": 736,
+  "哥": 737,
+  "长": 738,
+  "刃": 739,
+  "泣": 740,
+  "盗": 741,
+  "惑": 742,
+  "蹈": 743,
+  "冴": 744,
+  "気": 745,
+  "國": 746,
+  "斬": 747,
+  "门": 748,
+  "福": 749,
+  "絶": 750,
+  "爸": 751,
+  "げ": 752,
+  "假": 753,
+  "婚": 754,
+  "獄": 755,
+  "叶": 756,
+  "嫁": 757,
+  "萌": 758,
+  "宠": 759,
+  "线": 760,
+  "座": 761,
+  "飞": 762,
+  "江": 763,
+  "奴": 764,
+  "格": 765,
+  "戀": 766,
+  "尊": 767,
+  "味": 768,
+  "鲁": 769,
+  "失": 770,
+  "童": 771,
+  "当": 772,
+  "正": 773,
+  "今": 774,
+  "이": 775,
+  "声": 776,
+  "暴": 777,
+  "恐": 778,
+  "利": 779,
+  "号": 780,
+  "讨": 781,
+  "堂": 782,
+  "누": 783,
+  "야": 784,
+  "黄": 785,
+  "輪": 786,
+  "戝": 787,
+  "转": 788,
+  "宣": 789,
+  "律": 790,
+  "进": 791,
+  "彩": 792,
+  "盟": 793,
+  "激": 794,
+  "塔": 795,
+  "工": 796,
+  "间": 797,
+  "分": 798,
+  "古": 799,
+  "森": 800,
+  "汉": 801,
+  "宮": 802,
+  "守": 803,
+  "铁": 804,
+  "奈": 805,
+  "職": 806,
+  "’": 807,
+  "庭": 808,
+  "去": 809,
+  "切": 810,
+  "嬬": 811,
+  "Ⅳ": 812,
+  "幽": 813,
+  "陽": 814,
+  "猎": 815,
+  "敵": 816,
+  "危": 817,
+  "绵": 818,
+  "幸": 819,
+  "厌": 820,
+  "宗": 821,
+  "；": 822,
+  "儿": 823,
+  "初": 824,
+  "角": 825,
+  "罪": 826,
+  "念": 827,
+  "噬": 828,
+  "帝": 829,
+  "♭": 830,
+  "深": 831,
+  "反": 832,
+  "登": 833,
+  "快": 834,
+  "木": 835,
+  "望": 836,
+  "♪": 837,
+  "网": 838,
+  "鎴": 839,
+  "弱": 840,
+  "对": 841,
+  "庚": 842,
+  "看": 843,
+  "为": 844,
+  "波": 845,
+  "私": 846,
+  "极": 847,
+  "仮": 848,
+  "林": 849,
+  "屋": 850,
+  "別": 851,
+  "向": 852,
+  "ほ": 853,
+  "亚": 854,
+  "警": 855,
+  "兵": 856,
+  "母": 857,
+  "终": 858,
+  "信": 859,
+  "个": 860,
+  "極": 861,
+  "圈": 862,
+  "助": 863,
+  "干": 864,
+  "牌": 865,
+  "藏": 866,
+  "甘": 867,
+  "伊": 868,
+  "鬥": 869,
+  "ゾ": 870,
+  "徒": 871,
+  "√": 872,
+  "契": 873,
+  "湖": 874,
+  "运": 875,
+  "虎": 876,
+  ":": 877,
+  "送": 878,
+  "滅": 879,
+  "定": 880,
+  "跳": 881,
+  "狐": 882,
+  "遠": 883,
+  "交": 884,
+  "浪": 885,
+  "西": 886,
+  "羽": 887,
+  "翼": 888,
+  "丈": 889,
+  "涓": 890,
+  "《": 891,
+  "》": 892,
+  "傳": 893,
+  "咯": 894,
+  "馬": 895,
+  "運": 896,
+  "ざ": 897,
+  "达": 898,
+  "村": 899,
+  "说": 900,
+  "略": 901,
+  "孫": 902,
+  "莉": 903,
+  "姬": 904,
+  "加": 905,
+  "〜": 906,
+  "铛": 907,
+  "録": 908,
+  "劍": 909,
+  "烈": 910,
+  "紅": 911,
+  "视": 912,
+  "钉": 913,
+  "姆": 914,
+  "起": 915,
+  "邪": 916,
+  "皿": 917,
+  "至": 918,
+  "香": 919,
+  "争": 920,
+  "達": 921,
+  "娜": 922,
+  "队": 923,
+  "结": 924,
+  "銈": 925,
+  "殑": 926,
+  "追": 927,
+  "衛": 928,
+  "造": 929,
+  "來": 930,
+  "簿": 931,
+  "带": 932,
+  "立": 933,
+  "毛": 934,
+  "打": 935,
+  "岛": 936,
+  "解": 937,
+  "开": 938,
+  "突": 939,
+  "妮": 940,
+  "洛": 941,
+  "诸": 942,
+  "餐": 943,
+  "화": 944,
+  "联": 945,
+  "管": 946,
+  "闇": 947,
+  "点": 948,
+  "降": 949,
+  "業": 950,
+  "列": 951,
+  "那": 952,
+  "呼": 953,
+  "響": 954,
+  "復": 955,
+  "侠": 956,
+  "才": 957,
+  "棒": 958,
+  "片": 959,
+  "琪": 960,
+  "奥": 961,
+  "ぷ": 962,
+  "技": 963,
+  "『": 964,
+  "』": 965,
+  "弾": 966,
+  "术": 967,
+  "怖": 968,
+  "蒼": 969,
+  "鸣": 970,
+  "種": 971,
+  "寒": 972,
+  "鐨": 973,
+  "感": 974,
+  "熊": 975,
+  "荒": 976,
+  "ぁ": 977,
+  "사": 978,
+  "亜": 979,
+  "布": 980,
+  "尸": 981,
+  "脑": 982,
+  "內": 983,
+  "燃": 984,
+  "喰": 985,
+  "赛": 986,
+  "存": 987,
+  "祖": 988,
+  "摇": 989,
+  "见": 990,
+  "病": 991,
+  "酒": 992,
+  "凡": 993,
+  "挑": 994,
+  "虹": 995,
+  "競": 996,
+  "东": 997,
+  "葉": 998,
+  "阿": 999,
+  "粤": 1000,
+  "巫": 1001,
+  "豪": 1002,
+  "孤": 1003,
+  "陰": 1004,
+  "陣": 1005,
+  "惡": 1006,
+  "乐": 1007,
+  "尼": 1008,
+  "咲": 1009,
+  "ぱ": 1010,
+  "系": 1011,
+  "谜": 1012,
+  "譚": 1013,
+  "襲": 1014,
+  "靈": 1015,
+  "别": 1016,
+  "伍": 1017,
+  "良": 1018,
+  "歡": 1019,
+  "取": 1020,
+  "級": 1021,
+  "悲": 1022,
+  "妻": 1023,
+  "袭": 1024,
+  "帰": 1025,
+  "亡": 1026,
+  "药": 1027,
+  "會": 1028,
+  "熱": 1029,
+  "藍": 1030,
+  "賊": 1031,
+  "客": 1032,
+  "秦": 1033,
+  "将": 1034,
+  "謎": 1035,
+  "車": 1036,
+  "多": 1037,
+  "求": 1038,
+  "抱": 1039,
+  "纯": 1040,
+  "然": 1041,
+  "吞": 1042,
+  "瓒": 1043,
+  "锚": 1044,
+  "何": 1045,
+  "断": 1046,
+  "束": 1047,
+  "鍥": 1048,
+  "．": 1049,
+  "骨": 1050,
+  "祭": 1051,
+  "非": 1052,
+  "鏃": 1053,
+  "发": 1054,
+  "鳥": 1055,
+  "享": 1056,
+  "鍏": 1057,
+  "寄": 1058,
+  "Δ": 1059,
+  "聲": 1060,
+  "近": 1061,
+  "秋": 1062,
+  "民": 1063,
+  "川": 1064,
+  "们": 1065,
+  "銇": 1066,
+  "度": 1067,
+  "露": 1068,
+  "雲": 1069,
+  "驱": 1070,
+  "复": 1071,
+  "绝": 1072,
+  "歁": 1073,
+  "犲": 1074,
+  "书": 1075,
+  "素": 1076,
+  "幼": 1077,
+  "御": 1078,
+  "职": 1079,
+  "租": 1080,
+  "得": 1081,
+  "指": 1082,
+  "鍒": 1083,
+  "宅": 1084,
+  "欢": 1085,
+  "꞉": 1086,
+  "休": 1087,
+  "希": 1088,
+  "底": 1089,
+  "宿": 1090,
+  "噹": 1091,
+  "Ψ": 1092,
+  "－": 1093,
+  "宫": 1094,
+  "現": 1095,
+  "竹": 1096,
+  "拥": 1097,
+  "召": 1098,
+  "弐": 1099,
+  "醒": 1100,
+  "選": 1101,
+  "霸": 1102,
+  "封": 1103,
+  "辰": 1104,
+  "侵": 1105,
+  "政": 1106,
+  "借": 1107,
+  "ぃ": 1108,
+  "輝": 1109,
+  "倒": 1110,
+  "楽": 1111,
+  "吉": 1112,
+  "ゥ": 1113,
+  "兗": 1114,
+  "尚": 1115,
+  "偵": 1116,
+  "也": 1117,
+  "把": 1118,
+  "磁": 1119,
+  "叮": 1120,
+  "透": 1121,
+  "險": 1122,
+  "從": 1123,
+  "問": 1124,
+  "止": 1125,
+  "启": 1126,
+  "治": 1127,
+  "如": 1128,
+  "ぽ": 1129,
+  "榄": 1130,
+  "晚": 1131,
+  "샤": 1132,
+  "级": 1133,
+  "搞": 1134,
+  "庡": 1135,
+  "强": 1136,
+  "啊": 1137,
+  "共": 1138,
+  "铆": 1139,
+  "°": 1140,
+  "肉": 1141,
+  "卒": 1142,
+  "艺": 1143,
+  "医": 1144,
+  "玉": 1145,
+  "首": 1146,
+  "奏": 1147,
+  "―": 1148,
+  "頭": 1149,
+  "性": 1150,
+  "過": 1151,
+  "冰": 1152,
+  "捕": 1153,
+  "銃": 1154,
+  "優": 1155,
+  "尔": 1156,
+  "灼": 1157,
+  "館": 1158,
+  "ゅ": 1159,
+  "霊": 1160,
+  "◆": 1161,
+  "蛋": 1162,
+  "羅": 1163,
+  "员": 1164,
+  "半": 1165,
+  "鹰": 1166,
+  "萨": 1167,
+  "監": 1168,
+  "卫": 1169,
+  "什": 1170,
+  "é": 1171,
+  "演": 1172,
+  "負": 1173,
+  "秒": 1174,
+  "銆": 1175,
+  "关": 1176,
+  "轮": 1177,
+  "班": 1178,
+  "導": 1179,
+  "船": 1180,
+  "吹": 1181,
+  "牧": 1182,
+  "退": 1183,
+  "领": 1184,
+  "這": 1185,
+  "涙": 1186,
+  "络": 1187,
+  "店": 1188,
+  "玗": 1189,
+  "嵃": 1190,
+  "魯": 1191,
+  "ヌ": 1192,
+  "跡": 1193,
+  "兂": 1194,
+  "现": 1195,
+  "篮": 1196,
+  "橘": 1197,
+  "荘": 1198,
+  "丹": 1199,
+  "門": 1200,
+  "遮": 1201,
+  "莲": 1202,
+  "吸": 1203,
+  "某": 1204,
+  "朋": 1205,
+  "夫": 1206,
+  "志": 1207,
+  "皇": 1208,
+  "临": 1209,
+  "直": 1210,
+  "製": 1211,
+  "砂": 1212,
+  "塾": 1213,
+  "冠": 1214,
+  "鲸": 1215,
+  "铺": 1216,
+  "迎": 1217,
+  "々": 1218,
+  "过": 1219,
+  "夈": 1220,
+  "觉": 1221,
+  "願": 1222,
+  "們": 1223,
+  "除": 1224,
+  "镜": 1225,
+  "恒": 1226,
+  "嘘": 1227,
+  "說": 1228,
+  "式": 1229,
+  "歩": 1230,
+  "粉": 1231,
+  "叔": 1232,
+  "衣": 1233,
+  "総": 1234,
+  "唱": 1235,
+  "錄": 1236,
+  "酱": 1237,
+  "待": 1238,
+  "哦": 1239,
+  "晴": 1240,
+  "＋": 1241,
+  "父": 1242,
+  "阳": 1243,
+  "服": 1244,
+  "呪": 1245,
+  "而": 1246,
+  "鏄": 1247,
+  "華": 1248,
+  "２": 1249,
+  "刻": 1250,
+  "瀹": 1251,
+  "實": 1252,
+  "于": 1253,
+  "帳": 1254,
+  "以": 1255,
+  "压": 1256,
+  "壊": 1257,
+  "紒": 1258,
+  "架": 1259,
+  "勫": 1260,
+  "唤": 1261,
+  "孔": 1262,
+  "任": 1263,
+  "档": 1264,
+  "若": 1265,
+  "妈": 1266,
+  "閃": 1267,
+  "充": 1268,
+  "历": 1269,
+  "怒": 1270,
+  "儵": 1271,
+  "席": 1272,
+  "員": 1273,
+  "獸": 1274,
+  "憶": 1275,
+  "蘭": 1276,
+  "气": 1277,
+  "號": 1278,
+  "枪": 1279,
+  "町": 1280,
+  "談": 1281,
+  "短": 1282,
+  "乙": 1283,
+  "埋": 1284,
+  "泉": 1285,
+  "樺": 1286,
+  "诛": 1287,
+  "足": 1288,
+  "△": 1289,
+  "故": 1290,
+  "莱": 1291,
+  "辉": 1292,
+  "支": 1293,
+  "零": 1294,
+  "芙": 1295,
+  "執": 1296,
+  "役": 1297,
+  "曼": 1298,
+  "笛": 1299,
+  "逃": 1300,
+  "題": 1301,
+  "替": 1302,
+  "庫": 1303,
+  "淬": 1304,
+  "伴": 1305,
+  "彈": 1306,
+  "收": 1307,
+  "葬": 1308,
+  "只": 1309,
+  "溿": 1310,
+  "敌": 1311,
+  "米": 1312,
+  "速": 1313,
+  "喚": 1314,
+  "對": 1315,
+  "帐": 1316,
+  "舟": 1317,
+  "砕": 1318,
+  "鐵": 1319,
+  "观": 1320,
+  "鏈": 1321,
+  "灯": 1322,
+  "巧": 1323,
+  "祝": 1324,
+  "盾": 1325,
+  "缁": 1326,
+  "団": 1327,
+  "確": 1328,
+  "袨": 1329,
+  "關": 1330,
+  "越": 1331,
+  "嵐": 1332,
+  "企": 1333,
+  "叫": 1334,
+  "样": 1335,
+  "浣": 1336,
+  "织": 1337,
+  "型": 1338,
+  "漂": 1339,
+  "違": 1340,
+  "魚": 1341,
+  "镇": 1342,
+  "認": 1343,
+  "幹": 1344,
+  "錬": 1345,
+  "品": 1346,
+  "覚": 1347,
+  "普": 1348,
+  "鍩": 1349,
+  "戠": 1350,
+  "托": 1351,
+  "议": 1352,
+  "兔": 1353,
+  "講": 1354,
+  "局": 1355,
+  "變": 1356,
+  "她": 1357,
+  "���": 1358,
+  "個": 1359,
+  "朵": 1360,
+  "因": 1361,
+  "腹": 1362,
+  "點": 1363,
+  "由": 1364,
+  "崎": 1365,
+  "咼": 1366,
+  "曳": 1367,
+  "胞": 1368,
+  "満": 1369,
+  "戒": 1370,
+  "拿": 1371,
+  "糕": 1372,
+  "湯": 1373,
+  "桜": 1374,
+  "缘": 1375,
+  "鱼": 1376,
+  "於": 1377,
+  "司": 1378,
+  "智": 1379,
+  "忌": 1380,
+  "很": 1381,
+  "究": 1382,
+  "刚": 1383,
+  "誕": 1384,
+  "寺": 1385,
+  "嬪": 1386,
+  "著": 1387,
+  "釣": 1388,
+  "瀛": 1389,
+  "虚": 1390,
+  "殻": 1391,
+  "蓮": 1392,
+  "乾": 1393,
+  "佸": 1394,
+  "態": 1395,
+  "灌": 1396,
+  "脿": 1397,
+  "靠": 1398,
+  "樂": 1399,
+  "总": 1400,
+  "绻": 1401,
+  "仇": 1402,
+  "胜": 1403,
+  "謀": 1404,
+  "濂": 1405,
+  "混": 1406,
+  "寻": 1407,
+  "純": 1408,
+  "哈": 1409,
+  "仲": 1410,
+  "厜": 1411,
+  "蟲": 1412,
+  "照": 1413,
+  "着": 1414,
+  "营": 1415,
+  "樹": 1416,
+  "忆": 1417,
+  "験": 1418,
+  "远": 1419,
+  "么": 1420,
+  "誰": 1421,
+  "貴": 1422,
+  "細": 1423,
+  "傷": 1424,
+  "裏": 1425,
+  "懂": 1426,
+  "持": 1427,
+  "盖": 1428,
+  "ぇ": 1429,
+  "詩": 1430,
+  "伪": 1431,
+  "杯": 1432,
+  "氷": 1433,
+  "澶": 1434,
+  "歅": 1435,
+  "１": 1436,
+  "兰": 1437,
+  "娌": 1438,
+  "参": 1439,
+  "鐛": 1440,
+  "髪": 1441,
+  "续": 1442,
+  "晶": 1443,
+  "炼": 1444,
+  "熸": 1445,
+  "弹": 1446,
+  "油": 1447,
+  "絆": 1448,
+  "報": 1449,
+  "义": 1450,
+  "槦": 1451,
+  "秀": 1452,
+  "连": 1453,
+  "帖": 1454,
+  "灭": 1455,
+  "螺": 1456,
+  "频": 1457,
+  "奶": 1458,
+  "问": 1459,
+  "排": 1460,
+  "源": 1461,
+  "鐗": 1462,
+  "响": 1463,
+  "試": 1464,
+  "眠": 1465,
+  "谍": 1466,
+  "瑰": 1467,
+  "創": 1468,
+  "丽": 1469,
+  "刺": 1470,
+  "廻": 1471,
+  "處": 1472,
+  "节": 1473,
+  "基": 1474,
+  "呬": 1475,
+  "瓟": 1476,
+  "皮": 1477,
+  "昭": 1478,
+  "禄": 1479,
+  "急": 1480,
+  "鳴": 1481,
+  "团": 1482,
+  "两": 1483,
+  "其": 1484,
+  "”": 1485,
+  "騒": 1486,
+  "蝉": 1487,
+  "暁": 1488,
+  "雫": 1489,
+  "杰": 1490,
+  "馆": 1491,
+  "朝": 1492,
+  "销": 1493,
+  "则": 1494,
+  "察": 1495,
+  "づ": 1496,
+  "飯": 1497,
+  "還": 1498,
+  "ㄦ": 1499,
+  "口": 1500,
+  "从": 1501,
+  "鏡": 1502,
+  "%": 1503,
+  "哄": 1504,
+  "浦": 1505,
+  "珍": 1506,
+  "緋": 1507,
+  "喵": 1508,
+  "做": 1509,
+  "忘": 1510,
+  "约": 1511,
+  "散": 1512,
+  "瞳": 1513,
+  "单": 1514,
+  "索": 1515,
+  "保": 1516,
+  "谎": 1517,
+  "佐": 1518,
+  "雀": 1519,
+  "饭": 1520,
+  "撞": 1521,
+  "偽": 1522,
+  "坤": 1523,
+  "返": 1524,
+  "歋": 1525,
+  "威": 1526,
+  "亞": 1527,
+  "椋": 1528,
+  "傛": 1529,
+  "征": 1530,
+  "屍": 1531,
+  "必": 1532,
+  "值": 1533,
+  "息": 1534,
+  "承": 1535,
+  "脱": 1536,
+  "猿": 1537,
+  "纳": 1538,
+  "冥": 1539,
+  "刑": 1540,
+  "令": 1541,
+  "忔": 1542,
+  "搜": 1543,
+  "浜": 1544,
+  "晫": 1545,
+  "芥": 1546,
+  "尽": 1547,
+  "表": 1548,
+  "潔": 1549,
+  "哠": 1550,
+  "逮": 1551,
+  "ｘ": 1552,
+  "兒": 1553,
+  "松": 1554,
+  "稿": 1555,
+  "嬫": 1556,
+  "沙": 1557,
+  "獨": 1558,
+  "鏉": 1559,
+  "奪": 1560,
+  "寮": 1561,
+  "楀": 1562,
+  "富": 1563,
+  "炮": 1564,
+  "序": 1565,
+  "官": 1566,
+  "麻": 1567,
+  "苦": 1568,
+  "根": 1569,
+  "離": 1570,
+  "狩": 1571,
+  "群": 1572,
+  "犯": 1573,
+  "給": 1574,
+  "ぜ": 1575,
+  "诞": 1576,
+  "у": 1577,
+  "诲": 1578,
+  "堟": 1579,
+  "Ω": 1580,
+  "玄": 1581,
+  "菜": 1582,
+  "闻": 1583,
+  "计": 1584,
+  "絵": 1585,
+  "坂": 1586,
+  "他": 1587,
+  "残": 1588,
+  "房": 1589,
+  "卧": 1590,
+  "应": 1591,
+  "図": 1592,
+  "量": 1593,
+  "塞": 1594,
+  "创": 1595,
+  "柟": 1596,
+  "悠": 1597,
+  "齡": 1598,
+  "涢": 1599,
+  "鑰": 1600,
+  "欏": 1601,
+  "焰": 1602,
+  "谭": 1603,
+  "鯨": 1604,
+  "姊": 1605,
+  "爾": 1606,
+  "煩": 1607,
+  "鐑": 1608,
+  "欧": 1609,
+  "盜": 1610,
+  "糖": 1611,
+  "咒": 1612,
+  "紙": 1613,
+  "綔": 1614,
+  "祵": 1615,
+  "當": 1616,
+  "敗": 1617,
+  "◎": 1618,
+  "鐜": 1619,
+  "❤": 1620,
+  "樿": 1621,
+  "侀": 1622,
+  "烦": 1623,
+  "“": 1624,
+  "井": 1625,
+  "罠": 1626,
+  "狱": 1627,
+  "率": 1628,
+  "鸟": 1629,
+  "燈": 1630,
+  "吗": 1631,
+  "轨": 1632,
+  "洞": 1633,
+  "炽": 1634,
+  "琴": 1635,
+  "徹": 1636,
+  "親": 1637,
+  "冲": 1638,
+  "蜂": 1639,
+  "华": 1640,
+  "擊": 1641,
+  "胎": 1642,
+  "疑": 1643,
+  "编": 1644,
+  "麼": 1645,
+  "注": 1646,
+  "顔": 1647,
+  "魁": 1648,
+  "绘": 1649,
+  "忙": 1650,
+  "邂": 1651,
+  "逅": 1652,
+  "闖": 1653,
+  "种": 1654,
+  "策": 1655,
+  "谷": 1656,
+  "課": 1657,
+  "迴": 1658,
+  "剁": 1659,
+  "热": 1660,
+  "藤": 1661,
+  "划": 1662,
+  "屁": 1663,
+  "厅": 1664,
+  "斿": 1665,
+  "閲": 1666,
+  "欲": 1667,
+  "昏": 1668,
+  "護": 1669,
+  "獵": 1670,
+  "懐": 1671,
+  "類": 1672,
+  "將": 1673,
+  "熺": 1674,
+  "骞": 1675,
+  "兘": 1676,
+  "住": 1677,
+  "闪": 1678,
+  "誘": 1679,
+  "鬱": 1680,
+  "裂": 1681,
+  "受": 1682,
+  "槑": 1683,
+  "乃": 1684,
+  "ヲ": 1685,
+  "颂": 1686,
+  "吃": 1687,
+  "酷": 1688,
+  "练": 1689,
+  "考": 1690,
+  "橋": 1691,
+  "唯": 1692,
+  "坛": 1693,
+  "計": 1694,
+  "Ａ": 1695,
+  "壞": 1696,
+  "천": 1697,
+  "소": 1698,
+  "○": 1699,
+  "占": 1700,
+  "让": 1701,
+  "料": 1702,
+  "沧": 1703,
+  "接": 1704,
+  "蜜": 1705,
+  "丁": 1706,
+  "猛": 1707,
+  "库": 1708,
+  "俏": 1709,
+  "蛛": 1710,
+  "咏": 1711,
+  "狙": 1712,
+  "諜": 1713,
+  "鏅": 1714,
+  "凪": 1715,
+  "业": 1716,
+  "難": 1717,
+  "檬": 1718,
+  "毒": 1719,
+  "听": 1720,
+  "逐": 1721,
+  "聞": 1722,
+  "璃": 1723,
+  "鐢": 1724,
+  "･": 1725,
+  "ñ": 1726,
+  "洣": 1727,
+  "丮": 1728,
+  "麗": 1729,
+  "惧": 1730,
+  "贵": 1731,
+  "植": 1732,
+  "蜘": 1733,
+  "昆": 1734,
+  "＜": 1735,
+  "＞": 1736,
+  "続": 1737,
+  "帽": 1738,
+  "旀": 1739,
+  "硶": 1740,
+  "辛": 1741,
+  "曟": 1742,
+  "拾": 1743,
+  "녀": 1744,
+  "티": 1745,
+  "依": 1746,
+  "伐": 1747,
+  "找": 1748,
+  "營": 1749,
+  "肌": 1750,
+  "売": 1751,
+  "歍": 1752,
+  "甦": 1753,
+  "네": 1754,
+  "雙": 1755,
+  "議": 1756,
+  "题": 1757,
+  "氣": 1758,
+  "楂": 1759,
+  "候": 1760,
+  "摩": 1761,
+  "領": 1762,
+  "萊": 1763,
+  "♡": 1764,
+  "宰": 1765,
+  "鐩": 1766,
+  "杞": 1767,
+  "勾": 1768,
+  "婆": 1769,
+  "Ⅵ": 1770,
+  "憂": 1771,
+  "负": 1772,
+  "站": 1773,
+  "姩": 1774,
+  "揪": 1775,
+  "洋": 1776,
+  "景": 1777,
+  "浠": 1778,
+  "温": 1779,
+  "蟹": 1780,
+  "連": 1781,
+  "庄": 1782,
+  "廊": 1783,
+  "欳": 1784,
+  "夋": 1785,
+  "滄": 1786,
+  "頌": 1787,
+  "偢": 1788,
+  "獻": 1789,
+  "愿": 1790,
+  "殿": 1791,
+  "土": 1792,
+  "振": 1793,
+  "迫": 1794,
+  "渊": 1795,
+  "箱": 1796,
+  "似": 1797,
+  "烧": 1798,
+  "搖": 1799,
+  "—": 1800,
+  "护": 1801,
+  "楄": 1802,
+  "賭": 1803,
+  "駆": 1804,
+  "横": 1805,
+  "茅": 1806,
+  "算": 1807,
+  "夕": 1808,
+  "袣": 1809,
+  "擅": 1810,
+  "佺": 1811,
+  "迹": 1812,
+  "泽": 1813,
+  "練": 1814,
+  "遇": 1815,
+  "够": 1816,
+  "鋒": 1817,
+  "賽": 1818,
+  "状": 1819,
+  "観": 1820,
+  "彻": 1821,
+  "團": 1822,
+  "殊": 1823,
+  "梅": 1824,
+  "卜": 1825,
+  "扮": 1826,
+  "瀵": 1827,
+  "绁": 1828,
+  "豚": 1829,
+  "鷹": 1830,
+  "柠": 1831,
+  "寿": 1832,
+  "匠": 1833,
+  "芽": 1834,
+  "則": 1835,
+  "関": 1836,
+  "ต": 1837,
+  "น": 1838,
+  "ท": 1839,
+  "่": 1840,
+  "弄": 1841,
+  "滿": 1842,
+  "往": 1843,
+  "拓": 1844,
+  "訓": 1845,
+  "锋": 1846,
+  "赫": 1847,
+  "慬": 1848,
+  "陸": 1849,
+  "氏": 1850,
+  "อ": 1851,
+  "ี": 1852,
+  "畫": 1853,
+  "壁": 1854,
+  "涼": 1855,
+  "臨": 1856,
+  "仕": 1857,
+  "栫": 1858,
+  "亲": 1859,
+  "囧": 1860,
+  "预": 1861,
+  "惨": 1862,
+  "轴": 1863,
+  "冬": 1864,
+  "歲": 1865,
+  "刊": 1866,
+  "鍔": 1867,
+  "鎮": 1868,
+  "娴": 1869,
+  "粍": 1870,
+  "久": 1871,
+  "步": 1872,
+  "訪": 1873,
+  "赝": 1874,
+  "翔": 1875,
+  "汽": 1876,
+  "鼠": 1877,
+  "¡": 1878,
+  "錯": 1879,
+  "岁": 1880,
+  "誤": 1881,
+  "驯": 1882,
+  "恰": 1883,
+  "栈": 1884,
+  "兼": 1885,
+  "沈": 1886,
+  "仁": 1887,
+  "满": 1888,
+  "鬪": 1889,
+  "黃": 1890,
+  "提": 1891,
+  "射": 1892,
+  "紵": 1893,
+  "驅": 1894,
+  "懈": 1895,
+  "崩": 1896,
+  "拍": 1897,
+  "具": 1898,
+  "協": 1899,
+  "┍": 1900,
+  "掉": 1901,
+  "瞬": 1902,
+  "阴": 1903,
+  "鍙": 1904,
+  "右": 1905,
+  "焔": 1906,
+  "怣": 1907,
+  "泳": 1908,
+  "標": 1909,
+  "棩": 1910,
+  "换": 1911,
+  "筋": 1912,
+  "蕾": 1913,
+  "嫌": 1914,
+  "礼": 1915,
+  "誓": 1916,
+  "习": 1917,
+  "党": 1918,
+  "胖": 1919,
+  "佹": 1920,
+  "遭": 1921,
+  "杜": 1922,
+  "縛": 1923,
+  "罐": 1924,
+  "伏": 1925,
+  "灄": 1926,
+  "儚": 1927,
+  "渚": 1928,
+  "〈": 1929,
+  "〉": 1930,
+  "狗": 1931,
+  "袠": 1932,
+  "養": 1933,
+  "鐧": 1934,
+  "裡": 1935,
+  "辨": 1936,
+  "示": 1937,
+  "案": 1938,
+  "嫳": 1939,
+  "居": 1940,
+  "包": 1941,
+  "逢": 1942,
+  "滚": 1943,
+  "哀": 1944,
+  "糊": 1945,
+  "更": 1946,
+  "璐": 1947,
+  "鐖": 1948,
+  "低": 1949,
+  "戮": 1950,
+  "補": 1951,
+  "铃": 1952,
+  "択": 1953,
+  "煌": 1954,
+  "廢": 1955,
+  "坏": 1956,
+  "弦": 1957,
+  "骸": 1958,
+  "瓙": 1959,
+  "輩": 1960,
+  "标": 1961,
+  "圆": 1962,
+  "珊": 1963,
+  "瑚": 1964,
+  "讐": 1965,
+  "虛": 1966,
+  "绯": 1967,
+  "屈": 1968,
+  "曜": 1969,
+  "军": 1970,
+  "跨": 1971,
+  "板": 1972,
+  "肩": 1973,
+  "聽": 1974,
+  "陷": 1975,
+  "６": 1976,
+  "闷": 1977,
+  "ぺ": 1978,
+  "菓": 1979,
+  "伤": 1980,
+  "供": 1981,
+  "稲": 1982,
+  "搭": 1983,
+  "庢": 1984,
+  "姉": 1985,
+  "跑": 1986,
+  "増": 1987,
+  "伃": 1988,
+  "亂": 1989,
+  "慘": 1990,
+  "但": 1991,
+  "爷": 1992,
+  "續": 1993,
+  "耳": 1994,
+  "钻": 1995,
+  "鎧": 1996,
+  "条": 1997,
+  "伒": 1998,
+  "億": 1999,
+  "铠": 2000,
+  "周": 2001,
+  "给": 2002,
+  "械": 2003,
+  "选": 2004,
+  "弁": 2005,
+  "倉": 2006,
+  "詠": 2007,
+  "´": 2008,
+  "愮": 2009,
+  "瓶": 2010,
+  "雅": 2011,
+  "單": 2012,
+  "袋": 2013,
+  "勯": 2014,
+  "鍐": 2015,
+  "珨": 2016,
+  "瓦": 2017,
+  "眾": 2018,
+  "發": 2019,
+  "舰": 2020,
+  "养": 2021,
+  "各": 2022,
+  "塵": 2023,
+  "壽": 2024,
+  "袪": 2025,
+  "檔": 2026,
+  "╃": 2027,
+  "諾": 2028,
+  "鍓": 2029,
+  "鍖": 2030,
+  "惊": 2031,
+  "苏": 2032,
+  "尖": 2033,
+  "边": 2034,
+  "遺": 2035,
+  "戸": 2036,
+  "广": 2037,
+  "吻": 2038,
+  "桔": 2039,
+  "梗": 2040,
+  "５": 2041,
+  "垷": 2042,
+  "麒": 2043,
+  "麟": 2044,
+  "陀": 2045,
+  "習": 2046,
+  "写": 2047,
+  "討": 2048,
+  "碧": 2049,
+  "勬": 2050,
+  "榛": 2051,
+  "姑": 2052,
+  "娅": 2053,
+  "僧": 2054,
+  "哇": 2055,
+  "踏": 2056,
+  "旦": 2057,
+  "儶": 2058,
+  "哲": 2059,
+  "⁉": 2060,
+  "袦": 2061,
+  "播": 2062,
+  "易": 2063,
+  "抄": 2064,
+  "升": 2065,
+  "節": 2066,
+  "伙": 2067,
+  "勪": 2068,
+  "ó": 2069,
+  "勮": 2070,
+  "傜": 2071,
+  "辣": 2072,
+  "搬": 2073,
+  "継": 2074,
+  "准": 2075,
+  "円": 2076,
+  "证": 2077,
+  "嬢": 2078,
+  "腐": 2079,
+  "付": 2080,
+  "薇": 2081,
+  "眷": 2082,
+  "畜": 2083,
+  "爵": 2084,
+  "便": 2085,
+  "庨": 2086,
+  "鍦": 2087,
+  "梾": 2088,
+  "脚": 2089,
+  "途": 2090,
+  "驰": 2091,
+  "黎": 2092,
+  "迪": 2093,
+  "革": 2094,
+  "慎": 2095,
+  "染": 2096,
+  "頃": 2097,
+  "鹅": 2098,
+  "賢": 2099,
+  "插": 2100,
+  "早": 2101,
+  "鎭": 2102,
+  "冨": 2103,
+  "闆": 2104,
+  "尋": 2105,
+  "鵑": 2106,
+  "箷": 2107,
+  "控": 2108,
+  "蛇": 2109,
+  "吾": 2110,
+  "溅": 2111,
+  "没": 2112,
+  "呆": 2113,
+  "吀": 2114,
+  "引": 2115,
+  "厨": 2116,
+  "傑": 2117,
+  "豆": 2118,
+  "ö": 2119,
+  "锦": 2120,
+  "袧": 2121,
+  "又": 2122,
+  "统": 2123,
+  "紶": 2124,
+  "嬩": 2125,
+  "嶈": 2126,
+  "展": 2127,
+  "屬": 2128,
+  "否": 2129,
+  "烏": 2130,
+  "♯": 2131,
+  "и": 2132,
+  "左": 2133,
+  "鈥": 2134,
+  "鎷": 2135,
+  "敓": 2136,
+  "藥": 2137,
+  "┖": 2138,
+  "姣": 2139,
+  "拔": 2140,
+  "娃": 2141,
+  "般": 2142,
+  "遗": 2143,
+  "婕": 2144,
+  "預": 2145,
+  "折": 2146,
+  "概": 2147,
+  "差": 2148,
+  "怕": 2149,
+  "谁": 2150,
+  "模": 2151,
+  "蝶": 2152,
+  "溫": 2153,
+  "害": 2154,
+  "椼": 2155,
+  "夺": 2156,
+  "潜": 2157,
+  "蔵": 2158,
+  "泡": 2159,
+  "→": 2160,
+  "｜": 2161,
+  "凍": 2162,
+  "의": 2163,
+  "覇": 2164,
+  "涚": 2165,
+  "难": 2166,
+  "兆": 2167,
+  "位": 2168,
+  "頂": 2169,
+  "陆": 2170,
+  "雾": 2171,
+  "肝": 2172,
+  "抜": 2173,
+  "辽": 2174,
+  "ぴ": 2175,
+  "岩": 2176,
+  "紗": 2177,
+  "墍": 2178,
+  "珂": 2179,
+  "湅": 2180,
+  "獲": 2181,
+  "樣": 2182,
+  "乎": 2183,
+  "鑸": 2184,
+  "绑": 2185,
+  "离": 2186,
+  "悆": 2187,
+  "呮": 2188,
+  "悎": 2189,
+  "诗": 2190,
+  "疯": 2191,
+  "摵": 2192,
+  "祫": 2193,
+  "緊": 2194,
+  "際": 2195,
+  " ": 2196,
+  "耀": 2197,
+  "澜": 2198,
+  "溯": 2199,
+  "視": 2200,
+  "衍": 2201,
+  "炶": 2202,
+  "†": 2203,
+  "岚": 2204,
+  "鍋": 2205,
+  "沢": 2206,
+  "钱": 2207,
+  "柉": 2208,
+  "犻": 2209,
+  "邁": 2210,
+  "凶": 2211,
+  "滑": 2212,
+  "斩": 2213,
+  "投": 2214,
+  "=": 2215,
+  "堀": 2216,
+  "畅": 2217,
+  "ヱ": 2218,
+  "勉": 2219,
+  "呴": 2220,
+  "係": 2221,
+  "纱": 2222,
+  "咖": 2223,
+  "障": 2224,
+  "腿": 2225,
+  "勭": 2226,
+  "摸": 2227,
+  "沉": 2228,
+  "癒": 2229,
+  "糞": 2230,
+  "緣": 2231,
+  "缇": 2232,
+  "網": 2233,
+  "务": 2234,
+  "谈": 2235,
+  "择": 2236,
+  "弓": 2237,
+  "绲": 2238,
+  "札": 2239,
+  "唄": 2240,
+  "赐": 2241,
+  "欴": 2242,
+  "堬": 2243,
+  "７": 2244,
+  "Ζ": 2245,
+  "鄰": 2246,
+  "瑗": 2247,
+  "椿": 2248,
+  "鍘": 2249,
+  "織": 2250,
+  "默": 2251,
+  "寶": 2252,
+  "隨": 2253,
+  "撿": 2254,
+  "查": 2255,
+  "试": 2256,
+  "症": 2257,
+  "归": 2258,
+  "处": 2259,
+  "哉": 2260,
+  "収": 2261,
+  "衝": 2262,
+  "辈": 2263,
+  "納": 2264,
+  "背": 2265,
+  "簮": 2266,
+  "隠": 2267,
+  "偣": 2268,
+  "衰": 2269,
+  "容": 2270,
+  "端": 2271,
+  "微": 2272,
+  "枫": 2273,
+  "悼": 2274,
+  "仔": 2275,
+  "╁": 2276,
+  "呭": 2277,
+  "昂": 2278,
+  "胆": 2279,
+  "旧": 2280,
+  "忧": 2281,
+  "研": 2282,
+  "霧": 2283,
+  "讲": 2284,
+  "牛": 2285,
+  "核": 2286,
+  "μ": 2287,
+  "茶": 2288,
+  "乗": 2289,
+  "＊": 2290,
+  "嶅": 2291,
+  "丝": 2292,
+  "捉": 2293,
+  "棺": 2294,
+  "穿": 2295,
+  "丘": 2296,
+  "毁": 2297,
+  "宴": 2298,
+  "奖": 2299,
+  "整": 2300,
+  "艇": 2301,
+  "叛": 2302,
+  "準": 2303,
+  "窟": 2304,
+  "段": 2305,
+  "艾": 2306,
+  "弥": 2307,
+  "厄": 2308,
+  "絕": 2309,
+  "槸": 2310,
+  "沒": 2311,
+  "隱": 2312,
+  "夥": 2313,
+  "扭": 2314,
+  "紫": 2315,
+  "雏": 2316,
+  "静": 2317,
+  "痛": 2318,
+  "晖": 2319,
+  "軌": 2320,
+  "符": 2321,
+  "黙": 2322,
+  "震": 2323,
+  "拟": 2324,
+  "⁄": 2325,
+  "鑽": 2326,
+  "囬": 2327,
+  "凰": 2328,
+  "淵": 2329,
+  "侊": 2330,
+  "奔": 2331,
+  "捏": 2332,
+  "佬": 2333,
+  "报": 2334,
+  "介": 2335,
+  "呂": 2336,
+  "祈": 2337,
+  "敾": 2338,
+  "袖": 2339,
+  "塚": 2340,
+  "败": 2341,
+  "伽": 2342,
+  "悬": 2343,
+  "潰": 2344,
+  "午": 2345,
+  "嗎": 2346,
+  "摆": 2347,
+  "濡": 2348,
+  "烤": 2349,
+  "玛": 2350,
+  "泊": 2351,
+  "適": 2352,
+  "爺": 2353,
+  "适": 2354,
+  "掌": 2355,
+  "毎": 2356,
+  "缩": 2357,
+  "災": 2358,
+  "с": 2359,
+  "钢": 2360,
+  "扎": 2361,
+  "朱": 2362,
+  "検": 2363,
+  "蒂": 2364,
+  "区": 2365,
+  "潮": 2366,
+  "伓": 2367,
+  "壒": 2368,
+  "斾": 2369,
+  "健": 2370,
+  "笺": 2371,
+  "–": 2372,
+  "蘇": 2373,
+  "还": 2374,
+  "鐙": 2375,
+  "挨": 2376,
+  "碍": 2377,
+  "鍝": 2378,
+  "舵": 2379,
+  "︽": 2380,
+  "瓢": 2381,
+  "哃": 2382,
+  "隶": 2383,
+  "癖": 2384,
+  "庶": 2385,
+  "緒": 2386,
+  "郷": 2387,
+  "憑": 2388,
+  "憧": 2389,
+  "經": 2390,
+  "峰": 2391,
+  "撲": 2392,
+  "鍊": 2393,
+  "抗": 2394,
+  "航": 2395,
+  "媽": 2396,
+  "嘆": 2397,
+  "凯": 2398,
+  "②": 2399,
+  "构": 2400,
+  "焼": 2401,
+  "挙": 2402,
+  "栖": 2403,
+  "煶": 2404,
+  "參": 2405,
+  "届": 2406,
+  "功": 2407,
+  "興": 2408,
+  "調": 2409,
+  "培": 2410,
+  "盡": 2411,
+  "鹿": 2412,
+  "悩": 2413,
+  "翠": 2414,
+  "裁": 2415,
+  "辞": 2416,
+  "卷": 2417,
+  "犵": 2418,
+  "鞠": 2419,
+  "仆": 2420,
+  "櫧": 2421,
+  "애": 2422,
+  "니": 2423,
+  "제": 2424,
+  "閒": 2425,
+  "農": 2426,
+  "渣": 2427,
+  "戶": 2428,
+  "統": 2429,
+  "炲": 2430,
+  "艂": 2431,
+  "鍗": 2432,
+  "‧": 2433,
+  "浴": 2434,
+  "泥": 2435,
+  "绔": 2436,
+  "飘": 2437,
+  "绶": 2438,
+  "聚": 2439,
+  "实": 2440,
+  "程": 2441,
+  "庵": 2442,
+  "張": 2443,
+  "熟": 2444,
+  "魅": 2445,
+  "忛": 2446,
+  "曠": 2447,
+  "骄": 2448,
+  "^": 2449,
+  "槌": 2450,
+  "祦": 2451,
+  "‼": 2452,
+  "坑": 2453,
+  "宽": 2454,
+  "笁": 2455,
+  "厭": 2456,
+  "怎": 2457,
+  "設": 2458,
+  "稻": 2459,
+  "贸": 2460,
+  "擁": 2461,
+  "鎺": 2462,
+  "貳": 2463,
+  "屻": 2464,
+  "邊": 2465,
+  "粵": 2466,
+  "況": 2467,
+  "淋": 2468,
+  "钟": 2469,
+  "涂": 2470,
+  "鸦": 2471,
+  "驚": 2472,
+  "豹": 2473,
+  "＃": 2474,
+  "蟬": 2475,
+  "燂": 2476,
+  "偗": 2477,
+  "嶃": 2478,
+  "塑": 2479,
+  "偦": 2480,
+  "偝": 2481,
+  "崱": 2482,
+  "池": 2483,
+  "勒": 2484,
+  "©": 2485,
+  "僚": 2486,
+  "卞": 2487,
+  "赖": 2488,
+  "扉": 2489,
+  "傲": 2490,
+  "您": 2491,
+  "煤": 2492,
+  "及": 2493,
+  "涗": 2494,
+  "堝": 2495,
+  "愁": 2496,
+  "豬": 2497,
+  "覺": 2498,
+  "療": 2499,
+  "憎": 2500,
+  "鑑": 2501,
+  "骚": 2502,
+  "象": 2503,
+  "楝": 2504,
+  "卓": 2505,
+  "擬": 2506,
+  "睡": 2507,
+  "蹲": 2508,
+  "糟": 2509,
+  "贰": 2510,
+  "阔": 2511,
+  "卖": 2512,
+  "３": 2513,
+  "贈": 2514,
+  "戻": 2515,
+  "飼": 2516,
+  "駄": 2517,
+  "畳": 2518,
+  "脙": 2519,
+  "类": 2520,
+  "數": 2521,
+  "即": 2522,
+  "势": 2523,
+  "濆": 2524,
+  "枕": 2525,
+  "滾": 2526,
+  "凤": 2527,
+  "纸": 2528,
+  "阱": 2529,
+  "须": 2530,
+  "浮": 2531,
+  "授": 2532,
+  "侣": 2533,
+  "请": 2534,
+  "歄": 2535,
+  "堢": 2536,
+  "笉": 2537,
+  "祓": 2538,
+  "籠": 2539,
+  "遙": 2540,
+  "鸠": 2541,
+  "楱": 2542,
+  "壬": 2543,
+  "隸": 2544,
+  "恩": 2545,
+  "哪": 2546,
+  "亮": 2547,
+  "霉": 2548,
+  "畤": 2549,
+  "爛": 2550,
+  "葱": 2551,
+  "诱": 2552,
+  "懒": 2553,
+  "讀": 2554,
+  "脅": 2555,
+  "Ｖ": 2556,
+  "庞": 2557,
+  "效": 2558,
+  "鍕": 2559,
+  "经": 2560,
+  "留": 2561,
+  "鐚": 2562,
+  "隷": 2563,
+  "坊": 2564,
+  "芯": 2565,
+  "蒐": 2566,
+  "委": 2567,
+  "어": 2568,
+  "碎": 2569,
+  "驗": 2570,
+  "姏": 2571,
+  "犳": 2572,
+  "帇": 2573,
+  "鍚": 2574,
+  "噸": 2575,
+  "娲": 2576,
+  "嬮": 2577,
+  "岄": 2578,
+  "称": 2579,
+  "捡": 2580,
+  "Ⅶ": 2581,
+  "嶇": 2582,
+  "困": 2583,
+  "鴨": 2584,
+  "课": 2585,
+  "窝": 2586,
+  "陵": 2587,
+  "玲": 2588,
+  "操": 2589,
+  "茜": 2590,
+  "捨": 2591,
+  "慢": 2592,
+  "缚": 2593,
+  "催": 2594,
+  "歐": 2595,
+  "栄": 2596,
+  "套": 2597,
+  "猩": 2598,
+  "歳": 2599,
+  "鍵": 2600,
+  "砲": 2601,
+  "己": 2602,
+  "偤": 2603,
+  "兴": 2604,
+  "湘": 2605,
+  "致": 2606,
+  "╀": 2607,
+  "í": 2608,
+  "囪": 2609,
+  "廣": 2610,
+  "俄": 2611,
+  "属": 2612,
+  "莫": 2613,
+  "笘": 2614,
+  "验": 2615,
+  "論": 2616,
+  "譯": 2617,
+  "愚": 2618,
+  "郁": 2619,
+  "炸": 2620,
+  "商": 2621,
+  "啲": 2622,
+  "總": 2623,
+  "瓧": 2624,
+  "備": 2625,
+  "贴": 2626,
+  "磩": 2627,
+  "笼": 2628,
+  "袙": 2629,
+  "ū": 2630,
+  "楠": 2631,
+  "柴": 2632,
+  "崇": 2633,
+  "些": 2634,
+  "漠": 2635,
+  "置": 2636,
+  "骇": 2637,
+  "簹": 2638,
+  "冪": 2639,
+  "‐": 2640,
+  "傘": 2641,
+  "跟": 2642,
+  "偷": 2643,
+  "诺": 2644,
+  "曾": 2645,
+  "楼": 2646,
+  "碰": 2647,
+  "洗": 2648,
+  "户": 2649,
+  "钘": 2650,
+  "込": 2651,
+  "顶": 2652,
+  "楔": 2653,
+  "融": 2654,
+  "値": 2655,
+  "殖": 2656,
+  "憩": 2657,
+  "е": 2658,
+  "µ": 2659,
+  "繪": 2660,
+  "″": 2661,
+  "判": 2662,
+  "薔": 2663,
+  "琉": 2664,
+  "ㄧ": 2665,
+  "杩": 2666,
+  "闈": 2667,
+  "刔": 2668,
+  "距": 2669,
+  "貝": 2670,
+  "盃": 2671,
+  "触": 2672,
+  "玻": 2673,
+  "孙": 2674,
+  "柑": 2675,
+  "煮": 2676,
+  "薩": 2677,
+  "殭": 2678,
+  "捜": 2679,
+  "瀞": 2680,
+  "减": 2681,
+  "鈽": 2682,
+  "•": 2683,
+  "桑": 2684,
+  "穴": 2685,
+  " ": 2686,
+  "飙": 2687,
+  "泪": 2688,
+  "柔": 2689,
+  "á": 2690,
+  "隐": 2691,
+  "＄": 2692,
+  "虽": 2693,
+  "停": 2694,
+  "麥": 2695,
+  "测": 2696,
+  "沌": 2697,
+  "淘": 2698,
+  "匙": 2699,
+  "盛": 2700,
+  "掛": 2701,
+  "褰": 2702,
+  "妄": 2703,
+  "檚": 2704,
+  "词": 2705,
+  "菲": 2706,
+  "咆": 2707,
+  "伎": 2708,
+  "尻": 2709,
+  "喧": 2710,
+  "剃": 2711,
+  "夛": 2712,
+  "囩": 2713,
+  "劫": 2714,
+  "児": 2715,
+  "␣": 2716,
+  "均": 2717,
+  "?": 2718,
+  "啡": 2719,
+  "隻": 2720,
+  "편": 2721,
+  "拷": 2722,
+  "妳": 2723,
+  "昼": 2724,
+  "绿": 2725,
+  "链": 2726,
+  "湼": 2727,
+  "¿": 2728,
+  "谱": 2729,
+  "忓": 2730,
+  "屼": 2731,
+  "嚜": 2732,
+  "暒": 2733,
+  "瑪": 2734,
+  "偆": 2735,
+  "裤": 2736,
+  "鹤": 2737,
+  "蜻": 2738,
+  "鸡": 2739,
+  "附": 2740,
+  "肢": 2741,
+  "琥": 2742,
+  "珀": 2743,
+  "烙": 2744,
+  "婦": 2745,
+  "继": 2746,
+  "卵": 2747,
+  "薄": 2748,
+  "几": 2749,
+  "繰": 2750,
+  "扑": 2751,
+  "尤": 2752,
+  "履": 2753,
+  "한": 2754,
+  "완": 2755,
+  "逛": 2756,
+  "慄": 2757,
+  "胸": 2758,
+  "穗": 2759,
+  "环": 2760,
+  "姝": 2761,
+  "寰": 2762,
+  "庣": 2763,
+  "绱": 2764,
+  "莎": 2765,
+  "训": 2766,
+  "州": 2767,
+  "诡": 2768,
+  "瀬": 2769,
+  "洸": 2770,
+  "哮": 2771,
+  "讚": 2772,
+  "紞": 2773,
+  "К": 2774,
+  "敱": 2775,
+  "丶": 2776,
+  "惠": 2777,
+  "賀": 2778,
+  "綺": 2779,
+  "剋": 2780,
+  "溺": 2781,
+  "兩": 2782,
+  "側": 2783,
+  "鎵": 2784,
+  "伯": 2785,
+  "读": 2786,
+  "姜": 2787,
+  "导": 2788,
+  "斁": 2789,
+  "羞": 2790,
+  "倛": 2791,
+  "務": 2792,
+  "蕉": 2793,
+  "专": 2794,
+  "缥": 2795,
+  "缈": 2796,
+  "随": 2797,
+  "献": 2798,
+  "蠅": 2799,
+  "茸": 2800,
+  "処": 2801,
+  "囚": 2802,
+  "椂": 2803,
+  "逼": 2804,
+  "縁": 2805,
+  "拐": 2806,
+  "歂": 2807,
+  "漆": 2808,
+  "幡": 2809,
+  "桌": 2810,
+  "曇": 2811,
+  "須": 2812,
+  "証": 2813,
+  "谨": 2814,
+  "仓": 2815,
+  "ヂ": 2816,
+  "р": 2817,
+  "я": 2818,
+  "з": 2819,
+  "奉": 2820,
+  "더": 2821,
+  "결": 2822,
+  "援": 2823,
+  "弒": 2824,
+  "奧": 2825,
+  "努": 2826,
+  "椴": 2827,
+  "傚": 2828,
+  "捣": 2829,
+  "裝": 2830,
+  "绮": 2831,
+  "綻": 2832,
+  "彷": 2833,
+  "蛉": 2834,
+  "尘": 2835,
+  "壮": 2836,
+  "旗": 2837,
+  "質": 2838,
+  "査": 2839,
+  "萬": 2840,
+  "铏": 2841,
+  "鉱": 2842,
+  "①": 2843,
+  "鈴": 2844,
+  "妇": 2845,
+  "喂": 2846,
+  "葵": 2847,
+  "魍": 2848,
+  "鷲": 2849,
+  "津": 2850,
+  "ㆍ": 2851,
+  "ä": 2852,
+  "聆": 2853,
+  "隔": 2854,
+  "국": 2855,
+  "빙": 2856,
+  "扯": 2857,
+  "娣": 2858,
+  "歷": 2859,
+  "踊": 2860,
+  "產": 2861,
+  "锯": 2862,
+  "À": 2863,
+  "託": 2864,
+  "績": 2865,
+  "康": 2866,
+  "鍣": 2867,
+  "噗": 2868,
+  "撒": 2869,
+  "嗜": 2870,
+  "齊": 2871,
+  "避": 2872,
+  "娿": 2873,
+  "聯": 2874,
+  "喊": 2875,
+  "答": 2876,
+  "此": 2877,
+  "却": 2878,
+  "溂": 2879,
+  "垁": 2880,
+  "轻": 2881,
+  "麵": 2882,
+  "饶": 2883,
+  "喪": 2884,
+  "仏": 2885,
+  "汚": 2886,
+  "蜥": 2887,
+  "蜴": 2888,
+  "棰": 2889,
+  "ㄩ": 2890,
+  "移": 2891,
+  "懶": 2892,
+  "廏": 2893,
+  "許": 2894,
+  "磪": 2895,
+  "蛮": 2896,
+  "婢": 2897,
+  "湌": 2898,
+  "矒": 2899,
+  "檪": 2900,
+  "隇": 2901,
+  "塈": 2902,
+  "遣": 2903,
+  "Ｄ": 2904,
+  "Ｔ": 2905,
+  "､": 2906,
+  "洁": 2907,
+  "碼": 2908,
+  "识": 2909,
+  "♥": 2910,
+  "澄": 2911,
+  "涅": 2912,
+  "颜": 2913,
+  "旂": 2914,
+  "簨": 2915,
+  "拜": 2916,
+  "簡": 2917,
+  "懡": 2918,
+  "檺": 2919,
+  "寸": 2920,
+  "绌": 2921,
+  "屽": 2922,
+  "粖": 2923,
+  "栦": 2924,
+  "該": 2925,
+  "換": 2926,
+  "膽": 2927,
+  "黨": 2928,
+  "舊": 2929,
+  "卻": 2930,
+  "妃": 2931,
+  "懸": 2932,
+  "識": 2933,
+  "谋": 2934,
+  "柳": 2935,
+  "按": 2936,
+  "挿": 2937,
+  "躍": 2938,
+  "拯": 2939,
+  "鋸": 2940,
+  "删": 2941,
+  "欼": 2942,
+  "菊": 2943,
+  "魎": 2944,
+  "鎖": 2945,
+  "澗": 2946,
+  "杖": 2947,
+  "閮": 2948,
+  "鳳": 2949,
+  "顧": 2950,
+  "樻": 2951,
+  "猴": 2952,
+  "濠": 2953,
+  "阻": 2954,
+  "輔": 2955,
+  "憜": 2956,
+  "兓": 2957,
+  "戈": 2958,
+  "雖": 2959,
+  "��": 2960,
+  "优": 2961,
+  "墝": 2962,
+  "丟": 2963,
+  "抽": 2964,
+  "尟": 2965,
+  "緑": 2966,
+  "镖": 2967,
+  "桂": 2968,
+  "堛": 2969,
+  "墜": 2970,
+  "訣": 2971,
+  "辑": 2972,
+  "讓": 2973,
+  "腕": 2974,
+  "拖": 2975,
+  "偊": 2976,
+  "湥": 2977,
+  "ⅵ": 2978,
+  "峂": 2979,
+  "胄": 2980,
+  "哛": 2981,
+  "俗": 2982,
+  "亭": 2983,
+  "婭": 2984,
+  "壱": 2985,
+  "膏": 2986,
+  "å": 2987,
+  "曙": 2988,
+  "巌": 2989,
+  "姿": 2990,
+  "雛": 2991,
+  "凛": 2992,
+  "ō": 2993,
+  "遲": 2994,
+  "渡": 2995,
+  "鍑": 2996,
+  "忥": 2997,
+  "鏂": 2998,
+  "橀": 2999,
+  "㈠": 3000,
+  "′": 3001,
+  "或": 3002,
+  "媇": 3003,
+  "央": 3004,
+  "鞋": 3005,
+  "●": 3006,
+  "拶": 3007,
+  "憬": 3008,
+  "访": 3009,
+  "辭": 3010,
+  "氱": 3011,
+  "賞": 3012,
+  "鏽": 3013,
+  "償": 3014,
+  "贾": 3015,
+  "埍": 3016,
+  "棬": 3017,
+  "毚": 3018,
+  "掑": 3019,
+  "悕": 3020,
+  "誇": 3021,
+  "敷": 3022,
+  "熾": 3023,
+  "暖": 3024,
+  "楓": 3025,
+  "環": 3026,
+  "憾": 3027,
+  "买": 3028,
+  "论": 3029,
+  "闂": 3030,
+  "腑": 3031,
+  "灞": 3032,
+  "墨": 3033,
+  "暑": 3034,
+  "诅": 3035,
+  "鐪": 3036,
+  "儔": 3037,
+  "堡": 3038,
+  "鐒": 3039,
+  "繚": 3040,
+  "棋": 3041,
+  "眈": 3042,
+  "柱": 3043,
+  "鎲": 3044,
+  "ф": 3045,
+  "買": 3046,
+  "悔": 3047,
+  "哭": 3048,
+  "帕": 3049,
+  "乘": 3050,
+  "蓋": 3051,
+  "胶": 3052,
+  "週": 3053,
+  "貼": 3054,
+  "牲": 3055,
+  "阪": 3056,
+  "净": 3057,
+  "纷": 3058,
+  "贤": 3059,
+  "熼": 3060,
+  "宸": 3061,
+  "藉": 3062,
+  "鏁": 3063,
+  "句": 3064,
+  "醜": 3065,
+  "逝": 3066,
+  "众": 3067,
+  "絲": 3068,
+  "调": 3069,
+  "咕": 3070,
+  "维": 3071,
+  "訊": 3072,
+  "质": 3073,
+  "戴": 3074,
+  "闯": 3075,
+  "馁": 3076,
+  "产": 3077,
+  "滈": 3078,
+  "祽": 3079,
+  "咺": 3080,
+  "紳": 3081,
+  "册": 3082,
+  "虐": 3083,
+  "廳": 3084,
+  "呢": 3085,
+  "兇": 3086,
+  "舌": 3087,
+  "吠": 3088,
+  "à": 3089,
+  "垂": 3090,
+  "鐣": 3091,
+  "垬": 3092,
+  "湪": 3093,
+  "ぉ": 3094,
+  "蹇": 3095,
+  "請": 3096,
+  "材": 3097,
+  "帮": 3098,
+  "建": 3099,
+  "層": 3100,
+  "唇": 3101,
+  "矇": 3102,
+  "仺": 3103,
+  "汗": 3104,
+  "互": 3105,
+  "靦": 3106,
+  "腆": 3107,
+  "凱": 3108,
+  "頼": 3109,
+  "炭": 3110,
+  "誠": 3111,
+  "竞": 3112,
+  "窮": 3113,
+  "灉": 3114,
+  "匹": 3115,
+  "Ｏ": 3116,
+  "蛙": 3117,
+  "欒": 3118,
+  "糸": 3119,
+  "恵": 3120,
+  "傻": 3121,
+  "岐": 3122,
+  "痕": 3123,
+  "崛": 3124,
+  "蟻": 3125,
+  "絢": 3126,
+  "∀": 3127,
+  "囝": 3128,
+  "暮": 3129,
+  "夊": 3130,
+  "梯": 3131,
+  "è": 3132,
+  "皵": 3133,
+  "﹀": 3134,
+  "浗": 3135,
+  "绡": 3136,
+  "誼": 3137,
+  "栗": 3138,
+  "张": 3139,
+  "囊": 3140,
+  "固": 3141,
+  "寂": 3142,
+  "邻": 3143,
+  "诀": 3144,
+  "块": 3145,
+  "嗚": 3146,
+  "揺": 3147,
+  "綾": 3148,
+  "脸": 3149,
+  "盒": 3150,
+  "掘": 3151,
+  "洓": 3152,
+  "箣": 3153,
+  "迈": 3154,
+  "栧": 3155,
+  "僵": 3156,
+  "③": 3157,
+  "蝎": 3158,
+  "４": 3159,
+  "澧": 3160,
+  "Ⅹ": 3161,
+  "嘩": 3162,
+  "蒲": 3163,
+  "昔": 3164,
+  "Ｆ": 3165,
+  "副": 3166,
+  "错": 3167,
+  "胁": 3168,
+  "备": 3169,
+  "雑": 3170,
+  "誉": 3171,
+  "昴": 3172,
+  "芝": 3173,
+  "圖": 3174,
+  "擾": 3175,
+  "도": 3176,
+  "撮": 3177,
+  "寝": 3178,
+  "脫": 3179,
+  "畬": 3180,
+  "祕": 3181,
+  "丑": 3182,
+  "﹁": 3183,
+  "摑": 3184,
+  "佷": 3185,
+  "嘴": 3186,
+  "嗶": 3187,
+  "踢": 3188,
+  "蠢": 3189,
+  "恼": 3190,
+  "℃": 3191,
+  "尯": 3192,
+  "瑟": 3193,
+  "峡": 3194,
+  "剪": 3195,
+  "娇": 3196,
+  "股": 3197,
+  "薫": 3198,
+  "咰": 3199,
+  "赏": 3200,
+  "侍": 3201,
+  "冈": 3202,
+  "嚫": 3203,
+  "贩": 3204,
+  "剛": 3205,
+  "蕩": 3206,
+  "巡": 3207,
+  "昌": 3208,
+  "嬌": 3209,
+  "瘽": 3210,
+  "墿": 3211,
+  "儖": 3212,
+  "掓": 3213,
+  "槬": 3214,
+  "忠": 3215,
+  "欠": 3216,
+  "暇": 3217,
+  "産": 3218,
+  "鮮": 3219,
+  "覆": 3220,
+  "寲": 3221,
+  "診": 3222,
+  "鐘": 3223,
+  "愤": 3224,
+  "惰": 3225,
+  "亀": 3226,
+  "刘": 3227,
+  "０": 3228,
+  "铳": 3229,
+  "邸": 3230,
+  "犧": 3231,
+  "湴": 3232,
+  "赌": 3233,
+  "沖": 3234,
+  "両": 3235,
+  "愉": 3236,
+  "※": 3237,
+  "惱": 3238,
+  "滴": 3239,
+  "呯": 3240,
+  "楦": 3241,
+  "鸿": 3242,
+  "垫": 3243,
+  "渤": 3244,
+  "貫": 3245,
+  "俱": 3246,
+  "薰": 3247,
+  "毀": 3248,
+  "笂": 3249,
+  "仯": 3250,
+  "岸": 3251,
+  "寵": 3252,
+  "涘": 3253,
+  "嗐": 3254,
+  "鈾": 3255,
+  "猐": 3256,
+  "楃": 3257,
+  "紧": 3258,
+  "瓜": 3259,
+  "羡": 3260,
+  "紹": 3261,
+  "娉": 3262,
+  "拂": 3263,
+  "佛": 3264,
+  "液": 3265,
+  "頑": 3266,
+  "稀": 3267,
+  "晓": 3268,
+  "濞": 3269,
+  "濊": 3270,
+  "钃": 3271,
+  "ｆ": 3272,
+  "淽": 3273,
+  "â": 3274,
+  "挖": 3275,
+  "欺": 3276,
+  "帶": 3277,
+  "禦": 3278,
+  "睛": 3279,
+  "掕": 3280,
+  "氭": 3281,
+  "濅": 3282,
+  "挡": 3283,
+  "淇": 3284,
+  "斻": 3285,
+  "昇": 3286,
+  "润": 3287,
+  "仰": 3288,
+  "閉": 3289,
+  "煙": 3290,
+  "蒸": 3291,
+  "囨": 3292,
+  "洲": 3293,
+  "頓": 3294,
+  "窓": 3295,
+  "怠": 3296,
+  "祥": 3297,
+  "荻": 3298,
+  "坪": 3299,
+  "痴": 3300,
+  "擇": 3301,
+  "장": 3302,
+  "판": 3303,
+  "绽": 3304,
+  "皆": 3305,
+  "掟": 3306,
+  "恨": 3307,
+  "壇": 3308,
+  "硬": 3309,
+  "递": 3310,
+  "ú": 3311,
+  "颁": 3312,
+  "綋": 3313,
+  "ч": 3314,
+  "庝": 3315,
+  "箟": 3316,
+  "璇": 3317,
+  "嬭": 3318,
+  "伸": 3319,
+  "駅": 3320,
+  "炴": 3321,
+  "佳": 3322,
+  "陛": 3323,
+  "彲": 3324,
+  "読": 3325,
+  "综": 3326,
+  "幇": 3327,
+  "帥": 3328,
+  "堤": 3329,
+  "斷": 3330,
+  "柚": 3331,
+  "割": 3332,
+  "绂": 3333,
+  "戍": 3334,
+  "燎": 3335,
+  "構": 3336,
+  "慧": 3337,
+  "愬": 3338,
+  "倍": 3339,
+  "扇": 3340,
+  "骷": 3341,
+  "ｇ": 3342,
+  "崉": 3343,
+  "槍": 3344,
+  "芸": 3345,
+  "蒙": 3346,
+  "鑱": 3347,
+  "余": 3348,
+  "嚎": 3349,
+  "綍": 3350,
+  "靴": 3351,
+  "滆": 3352,
+  "潐": 3353,
+  "螃": 3354,
+  "咃": 3355,
+  "窻": 3356,
+  "鍨": 3357,
+  "溇": 3358,
+  "檽": 3359,
+  "爪": 3360,
+  "细": 3361,
+  "吐": 3362,
+  "Ｗ": 3363,
+  "Ⅷ": 3364,
+  "督": 3365,
+  "糫": 3366,
+  "迦": 3367,
+  "ē": 3368,
+  "绅": 3369,
+  "轟": 3370,
+  "姮": 3371,
+  "醉": 3372,
+  "偅": 3373,
+  "顾": 3374,
+  "澤": 3375,
+  "応": 3376,
+  "髮": 3377,
+  "逸": 3378,
+  "欽": 3379,
+  "蘑": 3380,
+  "啪": 3381,
+  "夌": 3382,
+  "臋": 3383,
+  "缺": 3384,
+  "荤": 3385,
+  "粠": 3386,
+  "洿": 3387,
+  "嶄": 3388,
+  "掔": 3389,
+  "瑕": 3390,
+  "鏋": 3391,
+  "纏": 3392,
+  "毫": 3393,
+  "姳": 3394,
+  "淑": 3395,
+  "遥": 3396,
+  "煎": 3397,
+  "匣": 3398,
+  "紡": 3399,
+  "废": 3400,
+  "蹄": 3401,
+  "垃": 3402,
+  "圾": 3403,
+  "閿": 3404,
+  "湡": 3405,
+  "愪": 3406,
+  "刹": 3407,
+  "應": 3408,
+  "鬧": 3409,
+  "謊": 3410,
+  "慶": 3411,
+  "漢": 3412,
+  "焉": 3413,
+  "钓": 3414,
+  "悗": 3415,
+  "髅": 3416,
+  "龟": 3417,
+  "伀": 3418,
+  "従": 3419,
+  "泰": 3420,
+  "岡": 3421,
+  "暂": 3422,
+  "李": 3423,
+  "斧": 3424,
+  "盷": 3425,
+  "皯": 3426,
+  "贡": 3427,
+  "鎿": 3428,
+  "簜": 3429,
+  "Ⅺ": 3430,
+  "滝": 3431,
+  "鯉": 3432,
+  "狸": 3433,
+  "噢": 3434,
+  "澡": 3435,
+  "弗": 3436,
+  "疆": 3437,
+  "岳": 3438,
+  "轩": 3439,
+  "아": 3440,
+  "堅": 3441,
+  "宏": 3442,
+  "綘": 3443,
+  "椤": 3444,
+  "娑": 3445,
+  "谩": 3446,
+  "檻": 3447,
+  "缤": 3448,
+  "鐞": 3449,
+  "埌": 3450,
+  "垮": 3451,
+  "潃": 3452,
+  "弻": 3453,
+  "鎸": 3454,
+  "洖": 3455,
+  "娆": 3456,
+  "姘": 3457,
+  "票": 3458,
+  "倞": 3459,
+  "忎": 3460,
+  "枃": 3461,
+  "氦": 3462,
+  "嬰": 3463,
+  "抢": 3464,
+  "綠": 3465,
+  "縫": 3466,
+  "仱": 3467,
+  "戙": 3468,
+  "臂": 3469,
+  "悶": 3470,
+  "瑛": 3471,
+  "赘": 3472,
+  "婿": 3473,
+  "輕": 3474,
+  "抚": 3475,
+  "渴": 3476,
+  "娶": 3477,
+  "瑾": 3478,
+  "樋": 3479,
+  "晩": 3480,
+  "簯": 3481,
+  "戜": 3482,
+  "徨": 3483,
+  "贺": 3484,
+  "Ｇ": 3485,
+  "階": 3486,
+  "凸": 3487,
+  "廟": 3488,
+  "暉": 3489,
+  "傭": 3490,
+  "爭": 3491,
+  "稚": 3492,
+  "沼": 3493,
+  "鄉": 3494,
+  "翰": 3495,
+  "善": 3496,
+  "夠": 3497,
+  "泧": 3498,
+  "瓨": 3499,
+  "循": 3500,
+  "歴": 3501,
+  "瑞": 3502,
+  "郊": 3503,
+  "采": 3504,
+  "紐": 3505,
+  "権": 3506,
+  "罚": 3507,
+  "麦": 3508,
+  "貨": 3509,
+  "狭": 3510,
+  "晃": 3511,
+  "墅": 3512,
+  "袥": 3513,
+  "Φ": 3514,
+  "裙": 3515,
+  "鑷": 3516,
+  "矛": 3517,
+  "菇": 3518,
+  "顿": 3519,
+  "喷": 3520,
+  "緱": 3521,
+  "涎": 3522,
+  "闹": 3523,
+  "趣": 3524,
+  "э": 3525,
+  "鐤": 3526,
+  "绾": 3527,
+  "篯": 3528,
+  "掍": 3529,
+  "╂": 3530,
+  "濮": 3531,
+  "採": 3532,
+  "儀": 3533,
+  "廷": 3534,
+  "伄": 3535,
+  "畾": 3536,
+  "費": 3537,
+  "繋": 3538,
+  "ㄣ": 3539,
+  "賣": 3540,
+  "暟": 3541,
+  "剎": 3542,
+  "檸": 3543,
+  "繩": 3544,
+  "嫄": 3545,
+  "鈬": 3546,
+  "憡": 3547,
+  "瘦": 3548,
+  "烟": 3549,
+  "沐": 3550,
+  "乡": 3551,
+  "狀": 3552,
+  "蹂": 3553,
+  "悓": 3554,
+  "诉": 3555,
+  "府": 3556,
+  "碗": 3557,
+  "檼": 3558,
+  "荣": 3559,
+  "啟": 3560,
+  "觸": 3561,
+  "娓": 3562,
+  "侯": 3563,
+  "评": 3564,
+  "譜": 3565,
+  "♀": 3566,
+  "歀": 3567,
+  "堥": 3568,
+  "鑹": 3569,
+  "ω": 3570,
+  "馭": 3571,
+  "駕": 3572,
+  "傅": 3573,
+  "繘": 3574,
+  "掋": 3575,
+  "偓": 3576,
+  "谣": 3577,
+  "翁": 3578,
+  "摊": 3579,
+  "獅": 3580,
+  "埂": 3581,
+  "惢": 3582,
+  "鑾": 3583,
+  "楹": 3584,
+  "繼": 3585,
+  "廚": 3586,
+  "伞": 3587,
+  "亰": 3588,
+  "侶": 3589,
+  "锈": 3590,
+  "劧": 3591,
+  "禍": 3592,
+  "￠": 3593,
+  "弸": 3594,
+  "苺": 3595,
+  "畢": 3596,
+  "鐓": 3597,
+  "岭": 3598,
+  "嫾": 3599,
+  "喔": 3600,
+  "Ｓ": 3601,
+  "゛": 3602,
+  "描": 3603,
+  "歯": 3604,
+  "偍": 3605,
+  "偨": 3606,
+  "Ⅸ": 3607,
+  "奮": 3608,
+  "遂": 3609,
+  "*": 3610,
+  "帅": 3611,
+  "‥": 3612,
+  "嗛": 3613,
+  "肆": 3614,
+  "谕": 3615,
+  "袛": 3616,
+  "袗": 3617,
+  "ｎ": 3618,
+  "懺": 3619,
+  "溜": 3620,
+  "複": 3621,
+  "극": 3622,
+  "대": 3623,
+  "芹": 3624,
+  "傾": 3625,
+  "泛": 3626,
+  "态": 3627,
+  "呀": 3628,
+  "顯": 3629,
+  "岀": 3630,
+  "鑻": 3631,
+  "璧": 3632,
+  "賜": 3633,
+  "尗": 3634,
+  "箙": 3635,
+  "榉": 3636,
+  "帹": 3637,
+  "嗙": 3638,
+  "〃": 3639,
+  "柜": 3640,
+  "鼴": 3641,
+  "栥": 3642,
+  "禪": 3643,
+  "雜": 3644,
+  "櫃": 3645,
+  "檯": 3646,
+  "蹺": 3647,
+  "桿": 3648,
+  "倠": 3649,
+  "姓": 3650,
+  "吵": 3651,
+  "慕": 3652,
+  "箭": 3653,
+  "抓": 3654,
+  "吶": 3655,
+  "霜": 3656,
+  "滩": 3657,
+  "酬": 3658,
+  "躪": 3659,
+  "舔": 3660,
+  "棉": 3661,
+  "閰": 3662,
+  "蔚": 3663,
+  "脡": 3664,
+  "珮": 3665,
+  "呐": 3666,
+  "傢": 3667,
+  "资": 3668,
+  "墠": 3669,
+  "穆": 3670,
+  "凹": 3671,
+  "姗": 3672,
+  "儹": 3673,
+  "徘": 3674,
+  "徊": 3675,
+  "懷": 3676,
+  "另": 3677,
+  "弃": 3678,
+  "欰": 3679,
+  "崈": 3680,
+  "僱": 3681,
+  "押": 3682,
+  "枊": 3683,
+  "牸": 3684,
+  "搐": 3685,
+  "碨": 3686,
+  "竺": 3687,
+  "罰": 3688,
+  "勢": 3689,
+  "粌": 3690,
+  "剦": 3691,
+  "籟": 3692,
+  "睙": 3693,
+  "浂": 3694,
+  "彙": 3695,
+  "愈": 3696,
+  "證": 3697,
+  "θ": 3698,
+  "堣": 3699,
+  "敳": 3700,
+  "窔": 3701,
+  "垉": 3702,
+  "囷": 3703,
+  "厤": 3704,
+  "媛": 3705,
+  "牠": 3706,
+  "揚": 3707,
+  "汁": 3708,
+  "閸": 3709,
+  "瓑": 3710,
+  "皽": 3711,
+  "剚": 3712,
+  "搧": 3713,
+  "憺": 3714,
+  "墽": 3715,
+  "闁": 3716,
+  "枓": 3717,
+  "簩": 3718,
+  "嵉": 3719,
+  "悐": 3720,
+  "嗕": 3721,
+  "鐭": 3722,
+  "氨": 3723,
+  "ｅ": 3724,
+  "櫠": 3725,
+  "圧": 3726,
+  "斎": 3727,
+  "噴": 3728,
+  "巣": 3729,
+  "甸": 3730,
+  "绎": 3731,
+  "窗": 3732,
+  "隣": 3733,
+  "囃": 3734,
+  "蛾": 3735,
+  "凄": 3736,
+  "握": 3737,
+  "Θ": 3738,
+  "谐": 3739,
+  "鈼": 3740,
+  "嬧": 3741,
+  "棆": 3742,
+  "稷": 3743,
+  "鹏": 3744,
+  "哗": 3745,
+  "〇": 3746,
+  "淨": 3747,
+  "捐": 3748,
+  "齑": 3749,
+  "堧": 3750,
+  "嫟": 3751,
+  "毵": 3752,
+  "敼": 3753,
+  "棟": 3754,
+  "佩": 3755,
+  "倫": 3756,
+  "하": 3757,
+  "마": 3758,
+  "리": 3759,
+  "라": 3760,
+  "綱": 3761,
+  "枚": 3762,
+  "讯": 3763,
+  "鑺": 3764,
+  "ª": 3765,
+  "効": 3766,
+  "廃": 3767,
+  "巾": 3768,
+  "芒": 3769,
+  "滨": 3770,
+  "焦": 3771,
+  "橙": 3772,
+  "啸": 3773,
+  "蜀": 3774,
+  "矜": 3775,
+  "阵": 3776,
+  "哎": 3777,
+  "莊": 3778,
+  "输": 3779,
+  "欿": 3780,
+  "訶": 3781,
+  "歖": 3782,
+  "欣": 3783,
+  "针": 3784,
+  "帯": 3785,
+  "歸": 3786,
+  "竭": 3787,
+  "顕": 3788,
+  "规": 3789,
+  "伦": 3790,
+  "嘗": 3791,
+  "榮": 3792,
+  "渋": 3793,
+  "鴉": 3794,
+  "臺": 3795,
+  "湳": 3796,
+  "搁": 3797,
+  "涌": 3798,
+  "硝": 3799,
+  "８": 3800,
+  "９": 3801,
+  "贄": 3802,
+  "彦": 3803,
+  "偛": 3804,
+  "搷": 3805,
+  "ヶ": 3806,
+  "洪": 3807,
+  "妯": 3808,
+  "洟": 3809,
+  "坐": 3810,
+  "抹": 3811,
+  "浅": 3812,
+  "显": 3813,
+  "狮": 3814,
+  "肥": 3815,
+  "擦": 3816,
+  "歪": 3817,
+  "铸": 3818,
+  "α": 3819,
+  "执": 3820,
+  "棲": 3821,
+  "責": 3822,
+  "Ｂ": 3823,
+  "摤": 3824,
+  "彛": 3825,
+  "咬": 3826,
+  "祟": 3827,
+  "壹": 3828,
+  "惩": 3829,
+  "［": 3830,
+  "］": 3831,
+  "維": 3832,
+  "鎗": 3833,
+  "炬": 3834,
+  "跃": 3835,
+  "広": 3836,
+  "甯": 3837,
+  "隆": 3838,
+  "怨": 3839,
+  "╄": 3840,
+  "х": 3841,
+  "ｄ": 3842,
+  "嗗": 3843,
+  "朗": 3844,
+  "瓪": 3845,
+  "酥": 3846,
+  "璜": 3847,
+  "积": 3848,
+  "仿": 3849,
+  "庛": 3850,
+  "翅": 3851,
+  "漁": 3852,
+  "坠": 3853,
+  "阁": 3854,
+  "芳": 3855,
+  "浄": 3856,
+  "湿": 3857,
+  "爽": 3858,
+  "価": 3859,
+  "俑": 3860,
+  "殜": 3861,
+  "涛": 3862,
+  "劲": 3863,
+  "际": 3864,
+  "渦": 3865,
+  "測": 3866,
+  "免": 3867,
+  "裕": 3868,
+  "舎": 3869,
+  "峕": 3870,
+  "審": 3871,
+  "臣": 3872,
+  "摄": 3873,
+  "盘": 3874,
+  "湾": 3875,
+  "$": 3876,
+  "崖": 3877,
+  "偡": 3878,
+  "诚": 3879,
+  "薪": 3880,
+  "枯": 3881,
+  "赴": 3882,
+  "亿": 3883,
+  "肖": 3884,
+  "㊙": 3885,
+  "峠": 3886,
+  "獮": 3887,
+  "기": 3888,
+  "나": 3889,
+  "비": 3890,
+  "庆": 3891,
+  "閫": 3892,
+  "ǎ": 3893,
+  "宂": 3894,
+  "鹃": 3895,
+  "鎼": 3896,
+  "欐": 3897,
+  "婄": 3898,
+  "釜": 3899,
+  "熷": 3900,
+  "﹂": 3901,
+  "担": 3902,
+  "笀": 3903,
+  "绊": 3904,
+  "耐": 3905,
+  "扫": 3906,
+  "锅": 3907,
+  "锁": 3908,
+  "驾": 3909,
+  "斋": 3910,
+  "盤": 3911,
+  "媺": 3912,
+  "鑼": 3913,
+  "柊": 3914,
+  "憐": 3915,
+  "杏": 3916,
+  "县": 3917,
+  "葡": 3918,
+  "鼓": 3919,
+  "颠": 3920,
+  "規": 3921,
+  "ヅ": 3922,
+  "慌": 3923,
+  "鳩": 3924,
+  "怜": 3925,
+  "臓": 3926,
+  "猟": 3927,
+  "財": 3928,
+  "드": 3929,
+  "黖": 3930,
+  "瑭": 3931,
+  "珷": 3932,
+  "婊": 3933,
+  "啺": 3934,
+  "辱": 3935,
+  "购": 3936,
+  "增": 3937,
+  "铜": 3938,
+  "徽": 3939,
+  "严": 3940,
+  "Ｅ": 3941,
+  "衆": 3942,
+  "哟": 3943,
+  "污": 3944,
+  "Ｎ": 3945,
+  "ぅ": 3946,
+  "蜃": 3947,
+  "勿": 3948,
+  "謝": 3949,
+  "㈡": 3950,
+  "匪": 3951,
+  "磯": 3952,
+  "Á": 3953,
+  "É": 3954,
+  "遍": 3955,
+  "시": 3956,
+  "는": 3957,
+  "음": 3958,
+  "카": 3959,
+  "인": 3960,
+  "詞": 3961,
+  "货": 3962,
+  "饰": 3963,
+  "膰": 3964,
+  "膮": 3965,
+  "嶆": 3966,
+  "烘": 3967,
+  "戞": 3968,
+  "偀": 3969,
+  "婂": 3970,
+  "譲": 3971,
+  "畝": 3972,
+  "嚐": 3973,
+  "酸": 3974,
+  "榻": 3975,
+  "躲": 3976,
+  "汇": 3977,
+  "亸": 3978,
+  "层": 3979,
+  "冦": 3980,
+  "纹": 3981,
+  "矝": 3982,
+  "撼": 3983,
+  "埃": 3984,
+  "胡": 3985,
+  "烬": 3986,
+  "鞎": 3987,
+  "勲": 3988,
+  "薯": 3989,
+  "締": 3990,
+  "絮": 3991,
+  "灾": 3992,
+  "噩": 3993,
+  "吊": 3994,
+  "彗": 3995,
+  "慟": 3996,
+  "睇": 3997,
+  "认": 3998,
+  "吓": 3999,
+  "祷": 4000,
+  "怀": 4001,
+  "鴿": 4002,
+  "‖": 4003,
+  "鵺": 4004,
+  "裸": 4005,
+  "損": 4006,
+  "潚": 4007,
+  "牢": 4008,
+  "慈": 4009,
+  "漬": 4010,
+  "丼": 4011,
+  "坦": 4012,
+  "恥": 4013,
+  "累": 4014,
+  "皬": 4015,
+  "绳": 4016,
+  "駒": 4017,
+  "燒": 4018,
+  "拌": 4019,
+  "蛹": 4020,
+  "噂": 4021,
+  "栨": 4022,
+  "痪": 4023,
+  "∬": 4024,
+  "寓": 4025,
+  "锣": 4026,
+  "舒": 4027,
+  "检": 4028,
+  "碑": 4029,
+  "苹": 4030,
+  "榎": 4031,
+  "蛍": 4032,
+  "荷": 4033,
+  "贖": 4034,
+  "惹": 4035,
+  "脈": 4036,
+  "砦": 4037,
+  "薬": 4038,
+  "乳": 4039,
+  "飾": 4040,
+  "軽": 4041,
+  "遅": 4042,
+  "卑": 4043,
+  "疲": 4044,
+  "鶴": 4045,
+  "辺": 4046,
+  "叢": 4047,
+  "财": 4048,
+  "豊": 4049,
+  "叹": 4050,
+  "署": 4051,
+  "袞": 4052,
+  "Ｒ": 4053,
+  "ã": 4054,
+  "毬": 4055,
+  "​": 4056,
+  "淫": 4057,
+  "貪": 4058,
+  "牡": 4059,
+  "隼": 4060,
+  "陶": 4061,
+  "舍": 4062,
+  "审": 4063,
+  "绪": 4064,
+  "丢": 4065,
+  "椒": 4066,
+  "钂": 4067,
+  "劳": 4068,
+  "霞": 4069,
+  "鈪": 4070,
+  "仪": 4071,
+  "勩": 4072,
+  "涩": 4073,
+  "牵": 4074,
+  "汪": 4075,
+  "杉": 4076,
+  "蓓": 4077,
+  "扣": 4078,
+  "含": 4079,
+  "燕": 4080,
+  "楚": 4081,
+  "歓": 4082,
+  "办": 4083,
+  "嘛": 4084,
+  "钧": 4085,
+  "鸽": 4086,
+  "蚁": 4087,
+  "減": 4088,
+  "壳": 4089,
+  "偿": 4090,
+  "惜": 4091,
+  "稼": 4092,
+  "詰": 4093,
+  "④": 4094,
+  "圿": 4095,
+  "畑": 4096,
+  "並": 4097,
+  "券": 4098,
+  "惚": 4099,
+  "窯": 4100,
+  "盯": 4101,
+  "泲": 4102,
+  "省": 4103,
+  "墙": 4104,
+  "坚": 4105,
+  "骰": 4106,
+  "秤": 4107,
+  "紋": 4108,
+  "綿": 4109,
+  "虜": 4110,
+  "迅": 4111,
+  "奋": 4112,
+  "纽": 4113,
+  "敢": 4114,
+  "揭": 4115,
+  "菌": 4116,
+  "囲": 4117,
+  "鳞": 4118,
+  "齐": 4119,
+  "墟": 4120,
+  "酋": 4121,
+  "价": 4122,
+  "掃": 4123,
+  "袡": 4124,
+  "槽": 4125,
+  "茉": 4126,
+  "賴": 4127,
+  "瓣": 4128,
+  "를": 4129,
+  "성": 4130,
+  "락": 4131,
+  "루": 4132,
+  "구": 4133,
+  "모": 4134,
+  "정": 4135,
+  "지": 4136,
+  "鎽": 4137,
+  "淚": 4138,
+  "縄": 4139,
+  "拼": 4140,
+  "囦": 4141,
+  "粦": 4142,
+  "ü": 4143,
+  "緳": 4144,
+  "鎶": 4145,
+  "尝": 4146,
+  "绉": 4147,
+  "暱": 4148,
+  "婁": 4149,
+  "秺": 4150,
+  "㈣": 4151,
+  "璀": 4152,
+  "皝": 4153,
+  "嘳": 4154,
+  "搶": 4155,
+  "鍛": 4156,
+  "婃": 4157,
+  "竊": 4158,
+  "萤": 4159,
+  "份": 4160,
+  "兜": 4161,
+  "亱": 4162,
+  "仒": 4163,
+  "仾": 4164,
+  "瑠": 4165,
+  "煄": 4166,
+  "挥": 4167,
+  "庙": 4168,
+  "欻": 4169,
+  "穂": 4170,
+  "熻": 4171,
+  "猍": 4172,
+  "矿": 4173,
+  "軸": 4174,
+  "每": 4175,
+  "陪": 4176,
+  "邀": 4177,
+  "葛": 4178,
+  "蹟": 4179,
+  "猜": 4180,
+  "資": 4181,
+  "縮": 4182,
+  "桐": 4183,
+  "鸭": 4184,
+  "盔": 4185,
+  "涯": 4186,
+  "苗": 4187,
+  "谢": 4188,
+  "邮": 4189,
+  "畔": 4190,
+  "穢": 4191,
+  "潫": 4192,
+  "粘": 4193,
+  "鐔": 4194,
+  "唺": 4195,
+  "棷": 4196,
+  "钥": 4197,
+  "床": 4198,
+  "酔": 4199,
+  "詛": 4200,
+  "髭": 4201,
+  "搏": 4202,
+  "仗": 4203,
+  "耍": 4204,
+  "伢": 4205,
+  "厕": 4206,
+  "貘": 4207,
+  "凌": 4208,
+  "贯": 4209,
+  "梁": 4210,
+  "銅": 4211,
+  "賛": 4212,
+  "权": 4213,
+  "餃": 4214,
+  "挟": 4215,
+  "围": 4216,
+  "柿": 4217,
+  "疗": 4218,
+  "忋": 4219,
+  "炪": 4220,
+  "儕": 4221,
+  "据": 4222,
+  "俠": 4223,
+  "茧": 4224,
+  "穷": 4225,
+  "貞": 4226,
+  "ç": 4227,
+  "鮒": 4228,
+  "喱": 4229,
+  "둑": 4230,
+  "─": 4231,
+  "繫": 4232,
+  "疊": 4233,
+  "肋": 4234,
+  "姻": 4235,
+  "거": 4236,
+  "속": 4237,
+  "련": 4238,
+  "래": 4239,
+  "에": 4240,
+  "바": 4241,
+  "반": 4242,
+  "부": 4243,
+  "鎯": 4244,
+  "恭": 4245,
+  "赢": 4246,
+  "驴": 4247,
+  "鼹": 4248,
+  "币": 4249,
+  "撳": 4250,
+  "閬": 4251,
+  "辩": 4252,
+  "闃": 4253,
+  "檃": 4254,
+  "艣": 4255,
+  "轰": 4256,
+  "蔷": 4257,
+  "敬": 4258,
+  "韩": 4259,
+  "ㄥ": 4260,
+  "旇": 4261,
+  "鐮": 4262,
+  "喅": 4263,
+  "呰": 4264,
+  "乚": 4265,
+  "熶": 4266,
+  "梋": 4267,
+  "嗭": 4268,
+  "紓": 4269,
+  "鑲": 4270,
+  "埗": 4271,
+  "垢": 4272,
+  "软": 4273,
+  "泦": 4274,
+  "误": 4275,
+  "厔": 4276,
+  "鍟": 4277,
+  "丧": 4278,
+  "鎰": 4279,
+  "婅": 4280,
+  "举": 4281,
+  "堆": 4282,
+  "暥": 4283,
+  "臆": 4284,
+  "剥": 4285,
+  "仸": 4286,
+  "伅": 4287,
+  "芬": 4288,
+  "柏": 4289,
+  "乔": 4290,
+  "鼻": 4291,
+  "厉": 4292,
+  "禮": 4293,
+  "捧": 4294,
+  "弩": 4295,
+  "措": 4296,
+  "宁": 4297,
+  "悄": 4298,
+  "梨": 4299,
+  "肚": 4300,
+  "戽": 4301,
+  "浆": 4302,
+  "讃": 4303,
+  "溢": 4304,
+  "夸": 4305,
+  "潛": 4306,
+  "針": 4307,
+  "芭": 4308,
+  "键": 4309,
+  "函": 4310,
+  "粗": 4311,
+  "欶": 4312,
+  "添": 4313,
+  "愨": 4314,
+  "槄": 4315,
+  "暙": 4316,
+  "咚": 4317,
+  "霍": 4318,
+  "飲": 4319,
+  "倶": 4320,
+  "饼": 4321,
+  "膀": 4322,
+  "蹦": 4323,
+  "患": 4324,
+  "殘": 4325,
+  "搲": 4326,
+  "孝": 4327,
+  "勤": 4328,
+  "聴": 4329,
+  "挽": 4330,
+  "疫": 4331,
+  "耶": 4332,
+  "孵": 4333,
+  "殉": 4334,
+  "⁈": 4335,
+  "绀": 4336,
+  "騙": 4337,
+  "払": 4338,
+  "項": 4339,
+  "레": 4340,
+  "동": 4341,
+  "噜": 4342,
+  "紺": 4343,
+  "粴": 4344,
+  "醋": 4345,
+  "绕": 4346,
+  "窥": 4347,
+  "填": 4348,
+  "责": 4349,
+  "橱": 4350,
+  "甩": 4351,
+  "售": 4352,
+  "缝": 4353,
+  "溶": 4354,
+  "揮": 4355,
+  "臭": 4356,
+  "设": 4357,
+  "获": 4358,
+  "玷": 4359,
+  "幫": 4360,
+  "Ｃ": 4361,
+  "徳": 4362,
+  "圏": 4363,
+  "諦": 4364,
+  "晦": 4365,
+  "倾": 4366,
+  "竟": 4367,
+  "熬": 4368,
+  "拒": 4369,
+  "単": 4370,
+  "鏖": 4371,
+  "顏": 4372,
+  "蔽": 4373,
+  "綐": 4374,
+  "儍": 4375,
+  "瀑": 4376,
+  "吼": 4377,
+  "毗": 4378,
+  "掳": 4379,
+  "农": 4380,
+  "氧": 4381,
+  "鉴": 4382,
+  "汐": 4383,
+  "捷": 4384,
+  "蟠": 4385,
+  "确": 4386,
+  "监": 4387,
+  "褋": 4388,
+  "褌": 4389,
+  "驟": 4390,
+  "茹": 4391,
+  "ø": 4392,
+  "밀": 4393,
+  "窃": 4394,
+  "桥": 4395,
+  "奕": 4396,
+  "淡": 4397,
+  "蠻": 4398,
+  "撇": 4399,
+  "초": 4400,
+  "월": 4401,
+  "울": 4402,
+  "홍": 4403,
+  "봉": 4404,
+  "계": 4405,
+  "고": 4406,
+  "함": 4407,
+  "운": 4408,
+  "을": 4409,
+  "竴": 4410,
+  "瑜": 4411,
+  "蓬": 4412,
+  "嘎": 4413,
+  "屾": 4414,
+  "垜": 4415,
+  "讳": 4416,
+  "绫": 4417,
+  "翱": 4418,
+  "眉": 4419,
+  "慨": 4420,
+  "枟": 4421,
+  "竷": 4422,
+  "悏": 4423,
+  "濉": 4424,
+  "欎": 4425,
+  "瘑": 4426,
+  "櫓": 4427,
+  "寫": 4428,
+  "ㄤ": 4429,
+  "欓": 4430,
+  "潤": 4431,
+  "绛": 4432,
+  "秴": 4433,
+  "慮": 4434,
+  "佽": 4435,
+  "闄": 4436,
+  "櫖": 4437,
+  "仌": 4438,
+  "撱": 4439,
+  "詮": 4440,
+  "渐": 4441,
+  "疼": 4442,
+  "仛": 4443,
+  "慰": 4444,
+  "厂": 4445,
+  "倗": 4446,
+  "獳": 4447,
+  "籌": 4448,
+  "籏": 4449,
+  "籄": 4450,
+  "籘": 4451,
+  "籗": 4452,
+  "籙": 4453,
+  "偒": 4454,
+  "寤": 4455,
+  "伨": 4456,
+  "綸": 4457,
+  "仐": 4458,
+  "劒": 4459,
+  "牬": 4460,
+  "┕": 4461,
+  "暘": 4462,
+  "忐": 4463,
+  "忑": 4464,
+  "兹": 4465,
+  "靜": 4466,
+  "痉": 4467,
+  "浼": 4468,
+  "挎": 4469,
+  "愭": 4470,
+  "萧": 4471,
+  "凭": 4472,
+  "赞": 4473,
+  "旃": 4474,
+  "敂": 4475,
+  "勶": 4476,
+  "巋": 4477,
+  "怯": 4478,
+  "鑳": 4479,
+  "谊": 4480,
+  "郵": 4481,
+  "签": 4482,
+  "虾": 4483,
+  "Ｐ": 4484,
+  "瞄": 4485,
+  "膳": 4486,
+  "輸": 4487,
+  "棄": 4488,
+  "馳": 4489,
+  "绍": 4490,
+  "犀": 4491,
+  "愕": 4492,
+  "妬": 4493,
+  "赶": 4494,
+  "萝": 4495,
+  "鎌": 4496,
+  "厛": 4497,
+  "娈": 4498,
+  "埜": 4499,
+  "硸": 4500,
+  "爞": 4501,
+  "摜": 4502,
+  "＠": 4503,
+  "敤": 4504,
+  "厳": 4505,
+  "蛤": 4506,
+  "亴": 4507,
+  "≒": 4508,
+  "筝": 4509,
+  "綜": 4510,
+  "歊": 4511,
+  "羁": 4512,
+  "飢": 4513,
+  "壺": 4514,
+  "缶": 4515,
+  "析": 4516,
+  "乏": 4517,
+  "餅": 4518,
+  "昧": 4519,
+  "繭": 4520,
+  "経": 4521,
+  "刈": 4522,
+  "崚": 4523,
+  "粯": 4524,
+  "埆": 4525,
+  "垰": 4526,
+  "築": 4527,
+  "摘": 4528,
+  "ò": 4529,
+  "揃": 4530,
+  "坡": 4531,
+  "腦": 4532,
+  "藩": 4533,
+  "錢": 4534,
+  "蟇": 4535,
+  "艶": 4536,
+  "薙": 4537,
+  "毘": 4538,
+  "頬": 4539,
+  "萄": 4540,
+  "塗": 4541,
+  "燦": 4542,
+  "笨": 4543,
+  "巅": 4544,
+  "氛": 4545,
+  "扰": 4546,
+  "斥": 4547,
+  "嚏": 4548,
+  "项": 4549,
+  "黏": 4550,
+  "许": 4551,
+  "袱": 4552,
+  "炖": 4553,
+  "锃": 4554,
+  "壶": 4555,
+  "桶": 4556,
+  "椅": 4557,
+  "艰": 4558,
+  "荞": 4559,
+  "汰": 4560,
+  "淳": 4561,
+  "粒": 4562,
+  "瑙": 4563,
+  "鹵": 4564,
+  "拭": 4565,
+  "饗": 4566,
+  "汝": 4567,
+  "壷": 4568,
+  "狛": 4569,
+  "施": 4570,
+  "゜": 4571,
+  "偉": 4572,
+  "塘": 4573,
+  "渉": 4574,
+  "勧": 4575,
+  "∞": 4576,
+  "髄": 4577,
+  "抉": 4578,
+  "秩": 4579,
+  "順": 4580,
+  "皑": 4581,
+  "焚": 4582,
+  "纵": 4583,
+  "祸": 4584,
+  "嬉": 4585,
+  "哩": 4586,
+  "弑": 4587,
+  "丛": 4588,
+  "柩": 4589,
+  "脉": 4590,
+  "卿": 4591,
+  "⅙": 4592,
+  "拙": 4593,
+  "β": 4594,
+  "鼬": 4595,
+  "狠": 4596,
+  "炉": 4597,
+  "Д": 4598,
+  "А": 4599,
+  "н": 4600,
+  "圭": 4601,
+  "歉": 4602,
+  "汤": 4603,
+  "矶": 4604,
+  "顺": 4605,
+  "筆": 4606,
+  "霹": 4607,
+  "撕": 4608,
+  "竪": 4609,
+  "樽": 4610,
+  "纭": 4611,
+  "矮": 4612,
+  "鄙": 4613,
+  "钴": 4614,
+  "夹": 4615,
+  "毕": 4616,
+  "蜗": 4617,
+  "烹": 4618,
+  "饪": 4619,
+  "董": 4620,
+  "绷": 4621,
+  "膜": 4622,
+  "르": 4623,
+  "디": 4624,
+  "厘": 4625,
+  "♂": 4626,
+  "蝕": 4627,
+  "崭": 4628,
+  "貌": 4629,
+  "帆": 4630,
+  "涟": 4631,
+  "漪": 4632,
+  "鷺": 4633,
+  "ß": 4634,
+  "逊": 4635,
+  "揍": 4636,
+  "玫": 4637,
+  "斑": 4638,
+  "다": 4639,
+  "Ｈ": 4640,
+  "Ｙ": 4641,
+  "竿": 4642,
+  "涉": 4643,
+  "茄": 4644,
+  "筹": 4645,
+  "辆": 4646,
+  "睽": 4647,
+  "Ø": 4648,
+  "嗒": 4649,
+  "龄": 4650,
+  "스": 4651,
+  "보": 4652,
+  "魑": 4653,
+  "喝": 4654,
+  "槙": 4655,
+  "叙": 4656,
+  "옥": 4657,
+  "외": 4658,
+  "剤": 4659,
+  "钀": 4660,
+  "臉": 4661,
+  "몽": 4662,
+  "환": 4663,
+  "패": 4664,
+  "검": 4665,
+  "전": 4666,
+  "히": 4667,
+  "추": 4668,
+  "격": 4669,
+  "명": 4670,
+  "슬": 4671,
+  "자": 4672,
+  "산": 4673,
+  "로": 4674,
+  "가": 4675,
+  "崙": 4676,
+  "闲": 4677,
+  "阶": 4678,
+  "披": 4679,
+  "鍜": 4680,
+  "綖": 4681,
+  "冩": 4682,
+  "棌": 4683,
+  "т": 4684,
+  "ê": 4685,
+  "袝": 4686,
+  "彶": 4687,
+  "艳": 4688,
+  "颈": 4689,
+  "紬": 4690,
+  "惃": 4691,
+  "紑": 4692,
+  "冭": 4693,
+  "緹": 4694,
+  "埄": 4695,
+  "繎": 4696,
+  "簳": 4697,
+  "瞾": 4698,
+  "禲": 4699,
+  "惂": 4700,
+  "鎬": 4701,
+  "禌": 4702,
+  "厠": 4703,
+  "炵": 4704,
+  "璢": 4705,
+  "湀": 4706,
+  "囯": 4707,
+  "浉": 4708,
+  "唴": 4709,
+  "盆": 4710,
+  "儑": 4711,
+  "楅": 4712,
+  "饱": 4713,
+  "袂": 4714,
+  "扶": 4715,
+  "炒": 4716,
+  "亼": 4717,
+  "猼": 4718,
+  "它": 4719,
+  "鸥": 4720,
+  "滃": 4721,
+  "陈": 4722,
+  "棘": 4723,
+  "榜": 4724,
+  "烛": 4725,
+  "荡": 4726,
+  "凉": 4727,
+  "梵": 4728,
+  "禅": 4729,
+  "廡": 4730,
+  "脆": 4731,
+  "鳄": 4732,
+  "箹": 4733,
+  "胃": 4734,
+  "虑": 4735,
+  "嗣": 4736,
+  "幌": 4737,
+  "粰": 4738,
+  "悧": 4739,
+  "缂": 4740,
+  "﹩": 4741,
+  "脏": 4742,
+  "罩": 4743,
+  "篝": 4744,
+  "評": 4745,
+  "醫": 4746,
+  "携": 4747,
+  "氫": 4748,
+  "饲": 4749,
+  "鹦": 4750,
+  "鹉": 4751,
+  "∽": 4752,
+  "婴": 4753,
+  "惉": 4754,
+  "湢": 4755,
+  "褐": 4756,
+  "锵": 4757,
+  "洩": 4758,
+  "嘉": 4759,
+  "餌": 4760,
+  "咎": 4761,
+  "滸": 4762,
+  "浒": 4763,
+  "乀": 4764,
+  "顽": 4765,
+  "蚊": 4766,
+  "桧": 4767,
+  "喇": 4768,
+  "叭": 4769,
+  "併": 4770,
+  "┿": 4771,
+  "筏": 4772,
+  "咦": 4773,
+  "渭": 4774,
+  "餓": 4775,
+  "擂": 4776,
+  "梢": 4777,
+  "枝": 4778,
+  "貸": 4779,
+  "鮫": 4780,
+  "傀": 4781,
+  "儡": 4782,
+  "覧": 4783,
+  "労": 4784,
+  "哨": 4785,
+  "翳": 4786,
+  "劉": 4787,
+  "詑": 4788,
+  "貧": 4789,
+  "聡": 4790,
+  "％": 4791,
+  "藪": 4792,
+  "仄": 4793,
+  "冊": 4794,
+  "垣": 4795,
+  "謹": 4796,
+  "莓": 4797,
+  "妨": 4798,
+  "啾": 4799,
+  "Ｘ": 4800,
+  "硫": 4801,
+  "鈔": 4802,
+  "塊": 4803,
+  "斜": 4804,
+  "蝴": 4805,
+  "飄": 4806,
+  "眞": 4807,
+  "湗": 4808,
+  "倓": 4809,
+  "鏇": 4810,
+  "埐": 4811,
+  "錆": 4812,
+  "磔": 4813,
+  "贷": 4814,
+  "款": 4815,
+  "悦": 4816,
+  "烫": 4817,
+  "笋": 4818,
+  "齿": 4819,
+  "痒": 4820,
+  "帘": 4821,
+  "蜓": 4822,
+  "銭": 4823,
+  "絡": 4824,
+  "謃": 4825,
+  "梓": 4826,
+  "沫": 4827,
+  "祀": 4828,
+  "滋": 4829,
+  "褒": 4830,
+  "腸": 4831,
+  "囁": 4832,
+  "戬": 4833,
+  "殇": 4834,
+  "剩": 4835,
+  "谅": 4836,
+  "狡": 4837,
+  "猾": 4838,
+  "并": 4839,
+  "延": 4840,
+  "諸": 4841,
+  "茱": 4842,
+  "®": 4843,
+  "烂": 4844,
+  "誌": 4845,
+  "凝": 4846,
+  "拝": 4847,
+  "隅": 4848,
+  "嶐": 4849,
+  "袴": 4850,
+  "粋": 4851,
+  "犠": 4852,
+  "幾": 4853,
+  "隙": 4854,
+  "饮": 4855,
+  "朔": 4856,
+  "枢": 4857,
+  "亦": 4858,
+  "魄": 4859,
+  "挫": 4860,
+  "抵": 4861,
+  "卟": 4862,
+  "琳": 4863,
+  "费": 4864,
+  "殲": 4865,
+  "閻": 4866,
+  "斉": 4867,
+  "乖": 4868,
+  "埼": 4869,
+  "尿": 4870,
+  "膵": 4871,
+  "営": 4872,
+  "筒": 4873,
+  "唸": 4874,
+  "犹": 4875,
+  "遷": 4876,
+  "忽": 4877,
+  "煉": 4878,
+  "壍": 4879,
+  "赎": 4880,
+  "褪": 4881,
+  "偔": 4882,
+  "儜": 4883,
+  "儊": 4884,
+  "赚": 4885,
+  "框": 4886,
+  "炁": 4887,
+  "勃": 4888,
+  "鳗": 4889,
+  "孽": 4890,
+  "雳": 4891,
+  "螢": 4892,
+  "霄": 4893,
+  "蠱": 4894,
+  "攪": 4895,
+  "漩": 4896,
+  "涡": 4897,
+  "刨": 4898,
+  "攀": 4899,
+  "腋": 4900,
+  "伟": 4901,
+  "熔": 4902,
+  "痣": 4903,
+  "需": 4904,
+  "剂": 4905,
+  "錠": 4906,
+  "铤": 4907,
+  "益": 4908,
+  "柄": 4909,
+  "脩": 4910,
+  "恢": 4911,
+  "茫": 4912,
+  "漸": 4913,
+  "트": 4914,
+  "丨": 4915,
+  "謁": 4916,
+  "鮎": 4917,
+  "凧": 4918,
+  "眸": 4919,
+  "堇": 4920,
+  "赁": 4921,
+  "哔": 4922,
+  "석": 4923,
+  "푸": 4924,
+  "潘": 4925,
+  "蝋": 4926,
+  "騨": 4927,
+  "撫": 4928,
+  "礫": 4929,
+  "顎": 4930,
+  "憤": 4931,
+  "Е": 4932,
+  "ぢ": 4933,
+  "珱": 4934,
+  "筷": 4935,
+  "Ö": 4936,
+  "亨": 4937,
+  "菈": 4938,
+  "郎": 4939,
+  "褲": 4940,
+  "상": 4941,
+  "미": 4942,
+  "코": 4943,
+  "령": 4944,
+  "혼": 4945,
+  "묘": 4946,
+  "들": 4947,
+  "즈": 4948,
+  "각": 4949,
+  "데": 4950,
+  "향": 4951,
+  "해": 4952,
+  "嚭": 4953,
+  "蛀": 4954,
+  "鈹": 4955,
+  "溌": 4956,
+  "瑅": 4957,
+  "脠": 4958,
+  "²": 4959,
+  "崑": 4960,
+  "晱": 4961,
+  "姞": 4962,
+  "铇": 4963,
+  "戣": 4964,
+  "弴": 4965,
+  "垚": 4966,
+  "鐐": 4967,
+  "渶": 4968,
+  "橝": 4969,
+  "艅": 4970,
+  "º": 4971,
+  "亾": 4972,
+  "粓": 4973,
+  "癸": 4974,
+  "楋": 4975,
+  "彂": 4976,
+  "噺": 4977,
+  "劚": 4978,
+  "彉": 4979,
+  "韬": 4980,
+  "櫒": 4981,
+  "湁": 4982,
+  "寘": 4983,
+  "堜": 4984,
+  "簬": 4985,
+  "繕": 4986,
+  "憳": 4987,
+  "墦": 4988,
+  "笌": 4989,
+  "矙": 4990,
+  "廬": 4991,
+  "愯": 4992,
+  "啗": 4993,
+  "嚮": 4994,
+  "︼": 4995,
+  "繃": 4996,
+  "氳": 4997,
+  "挋": 4998,
+  "櫥": 4999,
+  "忕": 5000,
+  "鏆": 5001,
+  "楗": 5002,
+  "璁": 5003,
+  "┒": 5004,
+  "莽": 5005,
+  "頁": 5006,
+  "吟": 5007,
+  "袍": 5008,
+  "糠": 5009,
+  "茂": 5010,
+  "拘": 5011,
+  "疏": 5012,
+  "笹": 5013,
+  "蝗": 5014,
+  "ц": 5015,
+  "閴": 5016,
+  "牨": 5017,
+  "冮": 5018,
+  "苞": 5019,
+  "槒": 5020,
+  "簵": 5021,
+  "揣": 5022,
+  "焆": 5023,
+  "玖": 5024,
+  "鲨": 5025,
+  "唐": 5026,
+  "闀": 5027,
+  "叧": 5028,
+  "晣": 5029,
+  "鐡": 5030,
+  "硅": 5031,
+  "缃": 5032,
+  "氶": 5033,
+  "楸": 5034,
+  "杂": 5035,
+  "盐": 5036,
+  "夷": 5037,
+  "烽": 5038,
+  "琼": 5039,
+  "浩": 5040,
+  "阗": 5041,
+  "钮": 5042,
+  "驶": 5043,
+  "ʼ": 5044,
+  "拡": 5045,
+  "颯": 5046,
+  "墰": 5047,
+  "儏": 5048,
+  "紮": 5049,
+  "搱": 5050,
+  "钑": 5051,
+  "╅": 5052,
+  "妫": 5053,
+  "粨": 5054,
+  "暀": 5055,
+  "Ｉ": 5056,
+  "誂": 5057,
+  "馒": 5058,
+  "嘻": 5059,
+  "茬": 5060,
+  "敇": 5061,
+  "摝": 5062,
+  "櫘": 5063,
+  "刷": 5064,
+  "饿": 5065,
+  "铚": 5066,
+  "狅": 5067,
+  "遁": 5068,
+  "梟": 5069,
+  "帷": 5070,
+  "嫉": 5071,
+  "琦": 5072,
+  "孴": 5073,
+  "峀": 5074,
+  "蝌": 5075,
+  "蚪": 5076,
+  "庐": 5077,
+  "荧": 5078,
+  "励": 5079,
+  "懲": 5080,
+  "泟": 5081,
+  "帿": 5082,
+  "侽": 5083,
+  "苑": 5084,
+  "鈞": 5085,
+  "闭": 5086,
+  "肱": 5087,
+  "垾": 5088,
+  "喬": 5089,
+  "钦": 5090,
+  "躯": 5091,
+  "枷": 5092,
+  "胧": 5093,
+  "沃": 5094,
+  "糧": 5095,
+  "浸": 5096,
+  "笐": 5097,
+  "孲": 5098,
+  "宭": 5099,
+  "孏": 5100,
+  "麺": 5101,
+  "鶏": 5102,
+  "棚": 5103,
+  "菖": 5104,
+  "鯛": 5105,
+  "⑤": 5106,
+  "⑥": 5107,
+  "炊": 5108,
+  "株": 5109,
+  "＾": 5110,
+  "兎": 5111,
+  "萩": 5112,
+  "抅": 5113,
+  "仑": 5114,
+  "盲": 5115,
+  "哖": 5116,
+  "蛟": 5117,
+  "鸵": 5118,
+  "盼": 5119,
+  "袜": 5120,
+  "例": 5121,
+  "Ｕ": 5122,
+  "岬": 5123,
+  "稱": 5124,
+  "梭": 5125,
+  "盧": 5126,
+  "蹤": 5127,
+  "價": 5128,
+  "瘋": 5129,
+  "蝦": 5130,
+  "鈷": 5131,
+  "铅": 5132,
+  "태": 5133,
+  "투": 5134,
+  "藝": 5135,
+  "鈍": 5136,
+  "牱": 5137,
+  "耻": 5138,
+  "夙": 5139,
+  "肴": 5140,
+  "啥": 5141,
+  "犰": 5142,
+  "狳": 5143,
+  "锤": 5144,
+  "飕": 5145,
+  "碌": 5146,
+  "浓": 5147,
+  "嗡": 5148,
+  "订": 5149,
+  "橄": 5150,
+  "楞": 5151,
+  "荏": 5152,
+  "辿": 5153,
+  "祠": 5154,
+  "擲": 5155,
+  "済": 5156,
+  "喫": 5157,
+  "箏": 5158,
+  "峙": 5159,
+  "渓": 5160,
+  "翌": 5161,
+  "籈": 5162,
+  "閣": 5163,
+  "絃": 5164,
+  "蒔": 5165,
+  "蝠": 5166,
+  "锏": 5167,
+  "拢": 5168,
+  "瞎": 5169,
+  "筵": 5170,
+  "肯": 5171,
+  "囉": 5172,
+  "叩": 5173,
+  "串": 5174,
+  "陳": 5175,
+  "攫": 5176,
+  "啓": 5177,
+  "肺": 5178,
+  "腺": 5179,
+  "坝": 5180,
+  "Ｍ": 5181,
+  "磷": 5182,
+  "鼎": 5183,
+  "蛊": 5184,
+  "珑": 5185,
+  "籁": 5186,
+  "瞰": 5187,
+  "較": 5188,
+  "棿": 5189,
+  "蹴": 5190,
+  "県": 5191,
+  "磐": 5192,
+  "濃": 5193,
+  "睦": 5194,
+  "殴": 5195,
+  "螂": 5196,
+  "陨": 5197,
+  "螫": 5198,
+  "偪": 5199,
+  "眺": 5200,
+  "呑": 5201,
+  "渾": 5202,
+  "閑": 5203,
+  "磨": 5204,
+  "捲": 5205,
+  "爐": 5206,
+  "憲": 5207,
+  "暦": 5208,
+  "冢": 5209,
+  "醍": 5210,
+  "醐": 5211,
+  "镰": 5212,
+  "勅": 5213,
+  "颱": 5214,
+  "妆": 5215,
+  "乒": 5216,
+  "乓": 5217,
+  "吕": 5218,
+  "綴": 5219,
+  "载": 5220,
+  "а": 5221,
+  "л": 5222,
+  "о": 5223,
+  "№": 5224,
+  "跺": 5225,
+  "煡": 5226,
+  "壗": 5227,
+  "昨": 5228,
+  "鲛": 5229,
+  "蛰": 5230,
+  "膠": 5231,
+  "歇": 5232,
+  "働": 5233,
+  "叡": 5234,
+  "鉂": 5235,
+  "巳": 5236,
+  "杨": 5237,
+  "蠍": 5238,
+  "裔": 5239,
+  "挺": 5240,
+  "籃": 5241,
+  "積": 5242,
+  "缰": 5243,
+  "跌": 5244,
+  "熏": 5245,
+  "吒": 5246,
+  "粮": 5247,
+  "伺": 5248,
+  "该": 5249,
+  "氓": 5250,
+  "琅": 5251,
+  "狄": 5252,
+  "蟆": 5253,
+  "曰": 5254,
+  "霆": 5255,
+  "倔": 5256,
+  "苛": 5257,
+  "鳶": 5258,
+  "喽": 5259,
+  "既": 5260,
+  "氤": 5261,
+  "氲": 5262,
+  "丰": 5263,
+  "虞": 5264,
+  "ゝ": 5265,
+  "訳": 5266,
+  "且": 5267,
+  "魉": 5268,
+  "堪": 5269,
+  "濫": 5270,
+  "瀕": 5271,
+  "哬": 5272,
+  "泄": 5273,
+  "岗": 5274,
+  "獏": 5275,
+  "攒": 5276,
+  "婶": 5277,
+  "톤": 5278,
+  "嘭": 5279,
+  "◉": 5280,
+  "谴": 5281,
+  "袟": 5282,
+  "袩": 5283,
+  "侑": 5284,
+  "宍": 5285,
+  "飓": 5286,
+  "尉": 5287,
+  "掠": 5288,
+  "簗": 5289,
+  "瘟": 5290,
+  "Ｌ": 5291,
+  "弯": 5292,
+  "膛": 5293,
+  "悍": 5294,
+  "咸": 5295,
+  "寧": 5296,
+  "萎": 5297,
+  "缪": 5298,
+  "蚂": 5299,
+  "Ú": 5300,
+  "矩": 5301,
+  "页": 5302,
+  "额": 5303,
+  "搅": 5304,
+  "损": 5305,
+  "瞭": 5306,
+  "谲": 5307,
+  "绸": 5308,
+  "饺": 5309,
+  "濯": 5310,
+  "ส": 5311,
+  "้": 5312,
+  "โ": 5313,
+  "õ": 5314,
+  "여": 5315,
+  "형": 5316,
+  "유": 5317,
+  "와": 5318,
+  "랑": 5319,
+  "타": 5320,
+  "억": 5321,
+  "경": 5322,
+  "약": 5323,
+  "연": 5324,
+  "ì": 5325,
+  "碟": 5326,
+  "惯": 5327,
+  "悖": 5328,
+  "慷": 5329,
+  "斐": 5330,
+  "藻": 5331,
+  "嘟": 5332,
+  "铀": 5333,
+  "穩": 5334,
+  "趟": 5335,
+  "В": 5336,
+  "Ц": 5337,
+  "毯": 5338,
+  "貯": 5339,
+  "冻": 5340,
+  "穫": 5341,
+  "−": 5342,
+  "雇": 5343,
+  "＝": 5344,
+  "敦": 5345,
+  "Ä": 5346,
+  "违": 5347,
+  "暫": 5348,
+  "傍": 5349,
+  "屑": 5350,
+  "乢": 5351,
+  "燭": 5352,
+  "谚": 5353,
+  "嫩": 5354,
+  "穏": 5355,
+  "饅": 5356,
+  "嶋": 5357,
+  "刎": 5358,
+  "煬": 5359,
+  "况": 5360,
+  "溪": 5361,
+  "谛": 5362,
+  "鹳": 5363,
+  "厢": 5364,
+  "爬": 5365,
+  "幅": 5366,
+  "특": 5367,
+  "영": 5368,
+  "토": 5369,
+  "곡": 5370,
+  "념": 5371,
+  "셋": 5372,
+  "쇼": 5373,
+  "되": 5374,
+  "순": 5375,
+  "간": 5376,
+  "최": 5377,
+  "후": 5378,
+  "통": 5379,
+  "승": 5380,
+  "픔": 5381,
+  "흔": 5382,
+  "꽃": 5383,
+  "심": 5384,
+  "요": 5385,
+  "당": 5386,
+  "람": 5387,
+  "륵": 5388,
+  "오": 5389,
+  "용": 5390,
+  "린": 5391,
+  "철": 5392,
+  "쇄": 5393,
+  "잔": 5394,
+  "파": 5395,
+  "몸": 5396,
+  "으": 5397,
+  "빛": 5398,
+  "별": 5399,
+  "짝": 5400,
+  "생": 5401,
+  "중": 5402,
+  "칸": 5403,
+  "질": 5404,
+  "없": 5405,
+  "망": 5406,
+  "둠": 5407,
+  "내": 5408,
+  "일": 5409,
+  "쿠": 5410,
+  "조": 5411,
+  "않": 5412,
+  "誅": 5413,
+  "櫙": 5414,
+  "珜": 5415,
+  "窉": 5416,
+  "儷": 5417,
+  "♫": 5418,
+  "彡": 5419,
+  "糬": 5420,
+  "咋": 5421,
+  "橲": 5422,
+  "弽": 5423,
+  "櫉": 5424,
+  "╋": 5425,
+  "棭": 5426,
+  "璨": 5427,
+  "锝": 5428,
+  "湻": 5429,
+  "嵅": 5430,
+  "楁": 5431,
+  "埦": 5432,
+  "ù": 5433,
+  "橭": 5434,
+  "檋": 5435,
+  "櫭": 5436,
+  "ヽ": 5437,
+  "檌": 5438,
+  "艢": 5439,
+  "潞": 5440,
+  "瞧": 5441,
+  "愰": 5442,
+  "橈": 5443,
+  "壈": 5444,
+  "︿": 5445,
+  "琛": 5446,
+  "铔": 5447,
+  "幓": 5448,
+  "綇": 5449,
+  "曞": 5450,
+  "瓩": 5451,
+  "垏": 5452,
+  "揩": 5453,
+  "壘": 5454,
+  "僝": 5455,
+  "笣": 5456,
+  "杈": 5457,
+  "摱": 5458,
+  "噧": 5459,
+  "ㄨ": 5460,
+  "毊": 5461,
+  "槱": 5462,
+  "崥": 5463,
+  "埇": 5464,
+  "熀": 5465,
+  "惤": 5466,
+  "噷": 5467,
+  "獊": 5468,
+  "綉": 5469,
+  "帴": 5470,
+  "紝": 5471,
+  "叏": 5472,
+  "鍎": 5473,
+  "啀": 5474,
+  "皢": 5475,
+  "籡": 5476,
+  "啋": 5477,
+  "闅": 5478,
+  "嬶": 5479,
+  "拻": 5480,
+  "儨": 5481,
+  "宕": 5482,
+  "簝": 5483,
+  "樇": 5484,
+  "濇": 5485,
+  "湜": 5486,
+  "亹": 5487,
+  "朷": 5488,
+  "磋": 5489,
+  "獌": 5490,
+  "姱": 5491,
+  "婏": 5492,
+  "垎": 5493,
+  "乑": 5494,
+  "痌": 5495,
+  "竾": 5496,
+  "枩": 5497,
+  "儴": 5498,
+  "劋": 5499,
+  "湶": 5500,
+  "垐": 5501,
+  "冿": 5502,
+  "敹": 5503,
+  "厓": 5504,
+  "筣": 5505,
+  "埛": 5506,
+  "仩": 5507,
+  "卯": 5508,
+  "湰": 5509,
+  "逗": 5510,
+  "耗": 5511,
+  "辫": 5512,
+  "盂": 5513,
+  "忚": 5514,
+  "澘": 5515,
+  "纰": 5516,
+  "棈": 5517,
+  "憠": 5518,
+  "櫚": 5519,
+  "潏": 5520,
+  "輾": 5521,
+  "載": 5522,
+  "跤": 5523,
+  "囡": 5524,
+  "恁": 5525,
+  "暝": 5526,
+  "佇": 5527,
+  "欱": 5528,
+  "嚒": 5529,
+  "彮": 5530,
+  "遐": 5531,
+  "疙": 5532,
+  "瘩": 5533,
+  "♨": 5534,
+  "皫": 5535,
+  "嫏": 5536,
+  "惕": 5537,
+  "擒": 5538,
+  "腾": 5539,
+  "崽": 5540,
+  "旷": 5541,
+  "账": 5542,
+  "粪": 5543,
+  "礁": 5544,
+  "猬": 5545,
+  "荆": 5546,
+  "羔": 5547,
+  "秉": 5548,
+  "衫": 5549,
+  "骁": 5550,
+  "豁": 5551,
+  "涧": 5552,
+  "渝": 5553,
+  "砸": 5554,
+  "奬": 5555,
+  "肠": 5556,
+  "凑": 5557,
+  "晒": 5558,
+  "绰": 5559,
+  "埴": 5560,
+  "濁": 5561,
+  "癩": 5562,
+  "掗": 5563,
+  "碷": 5564,
+  "甫": 5565,
+  "槺": 5566,
+  "畧": 5567,
+  "潗": 5568,
+  "奭": 5569,
+  "漖": 5570,
+  "晥": 5571,
+  "崪": 5572,
+  "禫": 5573,
+  "櫤": 5574,
+  "吔": 5575,
+  "紦": 5576,
+  "拰": 5577,
+  "煭": 5578,
+  "绗": 5579,
+  "剰": 5580,
+  "炰": 5581,
+  "胯": 5582,
+  "嗘": 5583,
+  "煟": 5584,
+  "胰": 5585,
+  "œ": 5586,
+  "購": 5587,
+  "ｰ": 5588,
+  "熴": 5589,
+  "协": 5590,
+  "阅": 5591,
+  "酌": 5592,
+  "榇": 5593,
+  "箖": 5594,
+  "嬨": 5595,
+  "柇": 5596,
+  "悊": 5597,
+  "抬": 5598,
+  "晰": 5599,
+  "穬": 5600,
+  "畽": 5601,
+  "⚔": 5602,
+  "️": 5603,
+  "爍": 5604,
+  "弊": 5605,
+  "髏": 5606,
+  "炫": 5607,
+  "佑": 5608,
+  "鲜": 5609,
+  "壓": 5610,
+  "烁": 5611,
+  "坍": 5612,
+  "锥": 5613,
+  "轭": 5614,
+  "禽": 5615,
+  "鎾": 5616,
+  "岃": 5617,
+  "垍": 5618,
+  "匽": 5619,
+  "慉": 5620,
+  "屉": 5621,
+  "儺": 5622,
+  "⓪": 5623,
+  "陋": 5624,
+  "脇": 5625,
+  "倝": 5626,
+  "嘷": 5627,
+  "榊": 5628,
+  "骏": 5629,
+  "鲤": 5630,
+  "毽": 5631,
+  "咩": 5632,
+  "舖": 5633,
+  "掴": 5634,
+  "儯": 5635,
+  "璙": 5636,
+  "倱": 5637,
+  "韭": 5638,
+  "诶": 5639,
+  "廉": 5640,
+  "轍": 5641,
+  "筈": 5642,
+  "櫌": 5643,
+  "洘": 5644,
+  "丗": 5645,
+  "湧": 5646,
+  "倪": 5647,
+  "權": 5648,
+  "宜": 5649,
+  "麾": 5650,
+  "耕": 5651,
+  "剔": 5652,
+  "胚": 5653,
+  "澹": 5654,
+  "倰": 5655,
+  "亪": 5656,
+  "媉": 5657,
+  "懼": 5658,
+  "棍": 5659,
+  "倢": 5660,
+  "砞": 5661,
+  "绐": 5662,
+  "儐": 5663,
+  "涖": 5664,
+  "儛": 5665,
+  "礭": 5666,
+  "韻": 5667,
+  "鞜": 5668,
+  "宻": 5669,
+  "宺": 5670,
+  "孍": 5671,
+  "㈱": 5672,
+  "澪": 5673,
+  "＼": 5674,
+  "◇": 5675,
+  "篭": 5676,
+  "È": 5677,
+  "饜": 5678,
+  "绒": 5679,
+  "剗": 5680,
+  "扱": 5681,
+  "撤": 5682,
+  "磺": 5683,
+  "哼": 5684,
+  "矗": 5685,
+  "骼": 5686,
+  "攝": 5687,
+  "敲": 5688,
+  "侖": 5689,
+  "龐": 5690,
+  "掩": 5691,
+  "賈": 5692,
+  "蘋": 5693,
+  "雞": 5694,
+  "獎": 5695,
+  "嚴": 5696,
+  "幣": 5697,
+  "缄": 5698,
+  "溃": 5699,
+  "炙": 5700,
+  "唠": 5701,
+  "叨": 5702,
+  "犸": 5703,
+  "皂": 5704,
+  "秸": 5705,
+  "扬": 5706,
+  "蓑": 5707,
+  "锻": 5708,
+  "獭": 5709,
+  "杆": 5710,
+  "鲭": 5711,
+  "吖": 5712,
+  "瞒": 5713,
+  "滓": 5714,
+  "鱗": 5715,
+  "燔": 5716,
+  "逡": 5717,
+  "椰": 5718,
+  "弘": 5719,
+  "夾": 5720,
+  "丞": 5721,
+  "螞": 5722,
+  "匡": 5723,
+  "諏": 5724,
+  "駿": 5725,
+  "萍": 5726,
+  "释": 5727,
+  "屏": 5728,
+  "刽": 5729,
+  "述": 5730,
+  "掷": 5731,
+  "蘊": 5732,
+  "匿": 5733,
+  "颤": 5734,
+  "枭": 5735,
+  "霁": 5736,
+  "饒": 5737,
+  "恕": 5738,
+  "溝": 5739,
+  "礙": 5740,
+  "掀": 5741,
+  "囮": 5742,
+  "漱": 5743,
+  "椎": 5744,
+  "稍": 5745,
+  "楊": 5746,
+  "潼": 5747,
+  "殷": 5748,
+  "妲": 5749,
+  "槐": 5750,
+  "赂": 5751,
+  "蚕": 5752,
+  "ｖ": 5753,
+  "ｓ": 5754,
+  "挤": 5755,
+  "弈": 5756,
+  "纤": 5757,
+  "脂": 5758,
+  "荑": 5759,
+  "饕": 5760,
+  "餮": 5761,
+  "阙": 5762,
+  "毅": 5763,
+  "税": 5764,
+  "醇": 5765,
+  "㈢": 5766,
+  "犱": 5767,
+  "栽": 5768,
+  "寡": 5769,
+  "蟑": 5770,
+  "踩": 5771,
+  "跷": 5772,
+  "桀": 5773,
+  "骜": 5774,
+  "鞘": 5775,
+  "槃": 5776,
+  "饥": 5777,
+  "熙": 5778,
+  "较": 5779,
+  "︺": 5780,
+  "曘": 5781,
+  "偂": 5782,
+  "骤": 5783,
+  "阋": 5784,
+  "鸳": 5785,
+  "鸯": 5786,
+  "掻": 5787,
+  "噛": 5788,
+  "笠": 5789,
+  "諧": 5790,
+  "謔": 5791,
+  "瀨": 5792,
+  "聳": 5793,
+  "窺": 5794,
+  "窩": 5795,
+  "勘": 5796,
+  "摂": 5797,
+  "芦": 5798,
+  "鋭": 5799,
+  "絹": 5800,
+  "弔": 5801,
+  "鍬": 5802,
+  "刪": 5803,
+  "燉": 5804,
+  "嘣": 5805,
+  "爲": 5806,
+  "拨": 5807,
+  "遼": 5808,
+  "斃": 5809,
+  "晝": 5810,
+  "顛": 5811,
+  "擴": 5812,
+  "渗": 5813,
+  "嵬": 5814,
+  "挵": 5815,
+  "嵒": 5816,
+  "粸": 5817,
+  "幆": 5818,
+  "姭": 5819,
+  "綊": 5820,
+  "嵈": 5821,
+  "О": 5822,
+  "爹": 5823,
+  "魇": 5824,
+  "娼": 5825,
+  "叆": 5826,
+  "宀": 5827,
+  "殣": 5828,
+  "≈": 5829,
+  "扩": 5830,
+  "諍": 5831,
+  "昡": 5832,
+  "尹": 5833,
+  "辅": 5834,
+  "巷": 5835,
+  "喋": 5836,
+  "滲": 5837,
+  "鬆": 5838,
+  "碁": 5839,
+  "篱": 5840,
+  "禹": 5841,
+  "軒": 5842,
+  "轅": 5843,
+  "懵": 5844,
+  "棠": 5845,
+  "儣": 5846,
+  "糾": 5847,
+  "紛": 5848,
+  "蚀": 5849,
+  "亘": 5850,
+  "腊": 5851,
+  "锡": 5852,
+  "橡": 5853,
+  "韁": 5854,
+  "穣": 5855,
+  "蔬": 5856,
+  "驭": 5857,
+  "哑": 5858,
+  "览": 5859,
+  "瞑": 5860,
+  "雕": 5861,
+  "聊": 5862,
+  "藕": 5863,
+  "嗯": 5864,
+  "赠": 5865,
+  "朦": 5866,
+  "醮": 5867,
+  "饵": 5868,
+  "莹": 5869,
+  "敛": 5870,
+  "隕": 5871,
+  "凋": 5872,
+  "屠": 5873,
+  "衷": 5874,
+  "亏": 5875,
+  "嫣": 5876,
+  "衅": 5877,
+  "扁": 5878,
+  "鹊": 5879,
+  "辗": 5880,
+  "迟": 5881,
+  "墩": 5882,
+  "兮": 5883,
+  "螳": 5884,
+  "俯": 5885,
+  "譽": 5886,
+  "敘": 5887,
+  "驕": 5888,
+  "厚": 5889,
+  "遞": 5890,
+  "朽": 5891,
+  "彫": 5892,
+  "苒": 5893,
+  "尴": 5894,
+  "尬": 5895,
+  "陌": 5896,
+  "讶": 5897,
+  "彀": 5898,
+  "氾": 5899,
+  "徴": 5900,
+  "洄": 5901,
+  "驹": 5902,
+  "荊": 5903,
+  "赋": 5904,
+  "羚": 5905,
+  "宪": 5906,
+  "敕": 5907,
+  "楕": 5908,
+  "濱": 5909,
+  "遜": 5910,
+  "侧": 5911,
+  "餘": 5912,
+  "盪": 5913,
+  "漾": 5914,
+  "絽": 5915,
+  "曉": 5916,
+  "寢": 5917,
+  "诊": 5918,
+  "汹": 5919,
+  "详": 5920,
+  "估": 5921,
+  "诹": 5922,
+  "隧": 5923,
+  "缓": 5924,
+  "铐": 5925,
+  "劾": 5926,
+  "諱": 5927,
+  "堺": 5928,
+  "舗": 5929,
+  "́": 5930,
+  "◞": 5931,
+  "౪": 5932,
+  "◟": 5933,
+  "‵": 5934,
+  "挣": 5935,
+  "锌": 5936,
+  "褘": 5937,
+  "衼": 5938,
+  "ｉ": 5939,
+  "販": 5940,
+  "促": 5941,
+  "÷": 5942,
+  "箋": 5943,
+  "聪": 5944,
+  "鍍": 5945,
+  "姥": 5946,
+  "蕪": 5947,
+  "尺": 5948,
+  "牺": 5949,
+  "圃": 5950,
+  "咧": 5951,
+  "仅": 5952,
+  "涤": 5953,
+  "嘲": 5954,
+  "獠": 5955,
+  "旺": 5956,
+  "縦": 5957,
+  "蕭": 5958,
+  "據": 5959,
+  "薛": 5960,
+  "辜": 5961,
+  "债": 5962,
+  "慑": 5963,
+  "拦": 5964,
+  "谬": 5965,
+  "氢": 5966,
+  "₂": 5967,
+  "疤": 5968,
+  "彰": 5969,
+  "酎": 5970,
+  "粧": 5971,
+  "瀾": 5972,
+  "縊": 5973,
+  "゚": 5974,
+  "蚤": 5975,
+  "荐": 5976,
+  "蹭": 5977,
+  "芋": 5978,
+  "扔": 5979,
+  "腌": 5980,
+  "拆": 5981,
+  "เ": 5982,
+  "า": 5983,
+  "ง": 5984,
+  "ู": 5985,
+  "ถ": 5986,
+  "ว": 5987,
+  "ย": 5988,
+  "ฮ": 5989,
+  "ค": 5990,
+  "ุ": 5991,
+  "ะ": 5992,
+  "귀": 5993,
+  "탑": 5994,
+  "습": 5995,
+  "치": 5996,
+  "크": 5997,
+  "새": 5998,
+  "벌": 5999,
+  "위": 6000,
+  "글": 6001,
+  "러": 6002,
+  "브": 6003,
+  "백": 6004,
+  "축": 6005,
+  "신": 6006,
+  "옛": 6007,
+  "발": 6008,
+  "렌": 6009,
+  "강": 6010,
+  "력": 6011,
+  "혜": 6012,
+  "알": 6013,
+  "수": 6014,
+  "찰": 6015,
+  "샐": 6016,
+  "잡": 6017,
+  "샴": 6018,
+  "델": 6019,
+  "회": 6020,
+  "찾": 6021,
+  "뷰": 6022,
+  "행": 6023,
+  "복": 6024,
+  "무": 6025,
+  "호": 6026,
+  "합": 6027,
+  "날": 6028,
+  "개": 6029,
+  "탐": 6030,
+  "단": 6031,
+  "돌": 6032,
+  "엄": 6033,
+  "셜": 6034,
+  "록": 6035,
+  "은": 6036,
+  "표": 6037,
+  "菩": 6038,
+  "酢": 6039,
+  "醬": 6040,
+  "顆": 6041,
+  "颶": 6042,
+  "胤": 6043,
+  "焗": 6044,
+  "鉛": 6045,
+  "嶽": 6046,
+  "咽": 6047,
+  "篠": 6048,
+  "躙": 6049,
+  "腭": 6050,
+  "筥": 6051,
+  "啤": 6052,
+  "堵": 6053,
+  "←": 6054,
+  "鵜": 6055,
+  "茨": 6056,
+  "硯": 6057,
+  "眇": 6058,
+  "瞼": 6059,
+  "茵": 6060,
+  "囀": 6061,
+  "嘯": 6062,
+  "曝": 6063,
+  "洼": 6064,
+  "俐": 6065,
+  "條": 6066,
+  "嚙": 6067,
+  "逻": 6068,
+  "霾": 6069,
+  "仍": 6070,
+  "鞄": 6071,
+  "∴": 6072,
+  "瞌": 6073,
+  "Н": 6074,
+  "Т": 6075,
+  "Ь": 6076,
+  "М": 6077,
+  "С": 6078,
+  "Я": 6079,
+  "錶": 6080,
+  "腳": 6081,
+  "觀": 6082,
+  "攬": 6083,
+  "搗": 6084,
+  "鵝": 6085,
+  "遨": 6086,
+  "黍": 6087,
+  "滞": 6088,
+  "涕": 6089,
+  "紘": 6090,
+  "锭": 6091,
+  "秧": 6092,
+  "匂": 6093,
+  "蔓": 6094,
+  "缠": 6095,
+  "嗝": 6096,
+  "挪": 6097,
+  "噶": 6098,
+  "闵": 6099,
+  "檎": 6100,
+  "櫛": 6101,
+  "Å": 6102,
+  "忒": 6103,
+  "朹": 6104,
+  "飽": 6105,
+  "騷": 6106,
+  "闊": 6107,
+  "囂": 6108,
+  "覿": 6109,
+  "輿": 6110,
+  "鉥": 6111,
+  "粹": 6112,
+  "觐": 6113,
+  "渔": 6114,
+  "濑": 6115,
+  "彝": 6116,
+  "屿": 6117,
+  "骋": 6118,
+  "汀": 6119,
+  "哺": 6120,
+  "駈": 6121,
+  "樅": 6122,
+  "麓": 6123,
+  "鉇": 6124,
+  "諠": 6125,
+  "嶺": 6126,
+  "雉": 6127,
+  "宵": 6128,
+  "截": 6129,
+  "簷": 6130,
+  "廁": 6131,
+  "嚇": 6132,
+  "膚": 6133,
+  "撓": 6134,
+  "俵": 6135,
+  "賄": 6136,
+  "賂": 6137,
+  "珈": 6138,
+  "琲": 6139,
+  "‘": 6140,
+  "骗": 6141,
+  "逞": 6142,
+  "漲": 6143,
+  "媚": 6144,
+  "ﾎ": 6145,
+  "ﾟ": 6146,
+  "酉": 6147,
+  "槿": 6148,
+  "馴": 6149,
+  "遡": 6150,
+  "鬨": 6151,
+  "拮": 6152,
+  "慣": 6153,
+  "榦": 6154,
+  "詄": 6155,
+  "躁": 6156,
+  "飈": 6157,
+  "阬": 6158,
+  "泀": 6159,
+  "踖": 6160,
+  "吝": 6161,
+  "靂": 6162,
+  "簾": 6163,
+  "贫": 6164,
+  "毙": 6165,
+  "頚": 6166,
+  "箪": 6167,
+  "忤": 6168,
+  "驷": 6169,
+  "庸": 6170,
+  "缭": 6171,
+  "彌": 6172,
+  "樓": 6173,
+  "扼": 6174,
+  "鉢": 6175,
+  "漣": 6176,
+  "濤": 6177,
+  "⑨": 6178,
+  "⑧": 6179,
+  "呉": 6180,
+  "⑩": 6181,
+  "⑦": 6182,
+  "飴": 6183,
+  "└": 6184,
+  "»": 6185,
+  "▒": 6186,
+  "╩": 6187,
+  "╨": 6188,
+  "╔": 6189,
+  "篷": 6190,
+  "嘿": 6191,
+  "唷": 6192,
+  "圓": 6193,
+  "痩": 6194,
+  "嗤": 6195,
+  "裹": 6196,
+  "徙": 6197,
+  "窖": 6198
+}

snapshots/anifilebert-dapt512-long/vocab.json

@@ -0,0 +1,6201 @@
+{
+  "[PAD]": 0,
+  "[UNK]": 1,
+  "[CLS]": 2,
+  "[SEP]": 3,
+  " ": 4,
+  "[": 5,
+  "]": 6,
+  "0": 7,
+  "a": 8,
+  "i": 9,
+  "o": 10,
+  "1": 11,
+  "e": 12,
+  "2": 13,
+  "A": 14,
+  "C": 15,
+  "n": 16,
+  "u": 17,
+  "s": 18,
+  "D": 19,
+  "t": 20,
+  "-": 21,
+  "B": 22,
+  "S": 23,
+  "r": 24,
+  "8": 25,
+  "P": 26,
+  "p": 27,
+  "4": 28,
+  "H": 29,
+  "V": 30,
+  "R": 31,
+  "k": 32,
+  "x": 33,
+  "_": 34,
+  "h": 35,
+  "E": 36,
+  "6": 37,
+  "M": 38,
+  "l": 39,
+  "m": 40,
+  "7": 41,
+  "F": 42,
+  "b": 43,
+  "G": 44,
+  "T": 45,
+  "L": 46,
+  "c": 47,
+  "5": 48,
+  "w": 49,
+  ".": 50,
+  "9": 51,
+  "I": 52,
+  "d": 53,
+  "N": 54,
+  "3": 55,
+  "(": 56,
+  "K": 57,
+  ")": 58,
+  "g": 59,
+  "y": 60,
+  "O": 61,
+  "W": 62,
+  "Y": 63,
+  "U": 64,
+  "z": 65,
+  "X": 66,
+  "J": 67,
+  "&": 68,
+  "!": 69,
+  "v": 70,
+  "f": 71,
+  "j": 72,
+  "第": 73,
+  "【": 74,
+  "】": 75,
+  "話": 76,
+  "Z": 77,
+  "の": 78,
+  "ー": 79,
+  "ン": 80,
+  "「": 81,
+  "」": 82,
+  "ア": 83,
+  ",": 84,
+  "幕": 85,
+  "字": 86,
+  "ル": 87,
+  "的": 88,
+  "イ": 89,
+  "ス": 90,
+  "！": 91,
+  "组": 92,
+  "ニ": 93,
+  "メ": 94,
+  "ラ": 95,
+  "Q": 96,
+  "女": 97,
+  "ト": 98,
+  "季": 99,
+  "い": 100,
+  "魔": 101,
+  "'": 102,
+  "リ": 103,
+  "之": 104,
+  "漫": 105,
+  "ド": 106,
+  "国": 107,
+  "ク": 108,
+  "ッ": 109,
+  "少": 110,
+  "日": 111,
+  "王": 112,
+  "神": 113,
+  "な": 114,
+  "ん": 115,
+  "人": 116,
+  "る": 117,
+  "小": 118,
+  "ジ": 119,
+  "レ": 120,
+  "タ": 121,
+  "と": 122,
+  "新": 123,
+  "た": 124,
+  "天": 125,
+  "简": 126,
+  "体": 127,
+  "・": 128,
+  "×": 129,
+  "大": 130,
+  "~": 131,
+  "话": 132,
+  "者": 133,
+  "は": 134,
+  "マ": 135,
+  "カ": 136,
+  "か": 137,
+  "光": 138,
+  "+": 139,
+  "世": 140,
+  "：": 141,
+  "ら": 142,
+  "集": 143,
+  "界": 144,
+  "ロ": 145,
+  "し": 146,
+  "版": 147,
+  "美": 148,
+  "キ": 149,
+  "语": 150,
+  "漏": 151,
+  "ズ": 152,
+  "勺": 153,
+  "子": 154,
+  "シ": 155,
+  "テ": 156,
+  "士": 157,
+  "デ": 158,
+  "り": 159,
+  "オ": 160,
+  "双": 161,
+  "生": 162,
+  "が": 163,
+  "＆": 164,
+  "れ": 165,
+  "コ": 166,
+  "ガ": 167,
+  "ィ": 168,
+  "二": 169,
+  "特": 170,
+  "星": 171,
+  "ャ": 172,
+  "ち": 173,
+  "プ": 174,
+  "に": 175,
+  "像": 176,
+  "法": 177,
+  "戦": 178,
+  "中": 179,
+  "一": 180,
+  "て": 181,
+  "ま": 182,
+  "／": 183,
+  "グ": 184,
+  "ブ": 185,
+  "#": 186,
+  "フ": 187,
+  "ュ": 188,
+  "☆": 189,
+  "モ": 190,
+  "っ": 191,
+  "作": 192,
+  "梦": 193,
+  "バ": 194,
+  "く": 195,
+  "さ": 196,
+  "ム": 197,
+  ";": 198,
+  "海": 199,
+  "う": 200,
+  "ダ": 201,
+  "～": 202,
+  "域": 203,
+  "チ": 204,
+  "空": 205,
+  "お": 206,
+  "ナ": 207,
+  "エ": 208,
+  "篇": 209,
+  "典": 210,
+  "q": 211,
+  "映": 212,
+  "我": 213,
+  "·": 214,
+  "物": 215,
+  "こ": 216,
+  "（": 217,
+  "龙": 218,
+  "異": 219,
+  "繁": 220,
+  "？": 221,
+  "猪": 222,
+  "三": 223,
+  "番": 224,
+  "夜": 225,
+  "）": 226,
+  "伝": 227,
+  "月": 228,
+  "超": 229,
+  "も": 230,
+  "組": 231,
+  "动": 232,
+  "年": 233,
+  "ノ": 234,
+  "を": 235,
+  "き": 236,
+  "@": 237,
+  "名": 238,
+  "影": 239,
+  "家": 240,
+  "高": 241,
+  "使": 242,
+  "あ": 243,
+  "不": 244,
+  "パ": 245,
+  "制": 246,
+  "で": 247,
+  "ョ": 248,
+  "斗": 249,
+  "ツ": 250,
+  "す": 251,
+  "学": 252,
+  "み": 253,
+  "ウ": 254,
+  "怪": 255,
+  "地": 256,
+  "死": 257,
+  "告": 258,
+  "忍": 259,
+  "ミ": 260,
+  "探": 261,
+  "ハ": 262,
+  "ボ": 263,
+  "南": 264,
+  "战": 265,
+  "火": 266,
+  "セ": 267,
+  "だ": 268,
+  "主": 269,
+  "え": 270,
+  "花": 271,
+  "よ": 272,
+  "ゴ": 273,
+  "异": 274,
+  "Ⅱ": 275,
+  "笔": 276,
+  "予": 277,
+  "サ": 278,
+  "上": 279,
+  "ゃ": 280,
+  "英": 281,
+  "啦": 282,
+  "柯": 283,
+  "蜡": 284,
+  "侦": 285,
+  "活": 286,
+  "語": 287,
+  "、": 288,
+  "雄": 289,
+  "珠": 290,
+  "事": 291,
+  "仙": 292,
+  "體": 293,
+  "哆": 294,
+  "万": 295,
+  "蓝": 296,
+  "め": 297,
+  "色": 298,
+  "つ": 299,
+  "想": 300,
+  "宝": 301,
+  "け": 302,
+  "与": 303,
+  "説": 304,
+  "場": 305,
+  "勇": 306,
+  "回": 307,
+  "犬": 308,
+  "本": 309,
+  "重": 310,
+  "妖": 311,
+  "最": 312,
+  "太": 313,
+  "偶": 314,
+  "ァ": 315,
+  "心": 316,
+  "宇": 317,
+  "传": 318,
+  "宙": 319,
+  "ヤ": 320,
+  "贼": 321,
+  "明": 322,
+  "ビ": 323,
+  "編": 324,
+  "四": 325,
+  "出": 326,
+  "ベ": 327,
+  "完": 328,
+  "ふ": 329,
+  "云": 330,
+  "ェ": 331,
+  "遊": 332,
+  "师": 333,
+  "来": 334,
+  "ゲ": 335,
+  "恋": 336,
+  "ヴ": 337,
+  "｢": 338,
+  "ソ": 339,
+  "｣": 340,
+  "道": 341,
+  "锛": 342,
+  "金": 343,
+  "そ": 344,
+  "ネ": 345,
+  "灵": 346,
+  "是": 347,
+  "わ": 348,
+  "风": 349,
+  "科": 350,
+  "行": 351,
+  "精": 352,
+  "機": 353,
+  "冒": 354,
+  "八": 355,
+  "成": 356,
+  "���": 357,
+  "ワ": 358,
+  "動": 359,
+  "白": 360,
+  "叉": 361,
+  "百": 362,
+  "限": 363,
+  "树": 364,
+  "会": 365,
+  "鬼": 366,
+  "记": 367,
+  "舞": 368,
+  "ザ": 369,
+  "樱": 370,
+  "黑": 371,
+  "ケ": 372,
+  "奇": 373,
+  "劇": 374,
+  "外": 375,
+  "ど": 376,
+  "愛": 377,
+  "目": 378,
+  "青": 379,
+  "じ": 380,
+  "次": 381,
+  "清": 382,
+  "时": 383,
+  "無": 384,
+  "期": 385,
+  "下": 386,
+  "夏": 387,
+  "了": 388,
+  "球": 389,
+  "ひ": 390,
+  "記": 391,
+  "校": 392,
+  "兽": 393,
+  "场": 394,
+  "妹": 395,
+  "ゼ": 396,
+  "城": 397,
+  "公": 398,
+  "彼": 399,
+  "ギ": 400,
+  "兄": 401,
+  "羊": 402,
+  "河": 403,
+  "ば": 404,
+  "冷": 405,
+  "手": 406,
+  "晨": 407,
+  "曦": 408,
+  "ろ": 409,
+  "爆": 410,
+  "男": 411,
+  "郎": 412,
+  "，": 413,
+  "隊": 414,
+  "教": 415,
+  "剧": 416,
+  "雪": 417,
+  "有": 418,
+  "游": 419,
+  "力": 420,
+  "前": 421,
+  "師": 422,
+  "Ⅲ": 423,
+  "へ": 424,
+  "面": 425,
+  "食": 426,
+  "狂": 427,
+  "。": 428,
+  "始": 429,
+  "せ": 430,
+  "狼": 431,
+  "可": 432,
+  "全": 433,
+  "都": 434,
+  "件": 435,
+  "族": 436,
+  "破": 437,
+  "武": 438,
+  "末": 439,
+  "补": 440,
+  "や": 441,
+  "在": 442,
+  "银": 443,
+  "决": 444,
+  "銀": 445,
+  "无": 446,
+  "ぎ": 447,
+  "京": 448,
+  "未": 449,
+  "ペ": 450,
+  "戰": 451,
+  "強": 452,
+  "園": 453,
+  "音": 454,
+  "和": 455,
+  "招": 456,
+  "卡": 457,
+  "妙": 458,
+  "文": 459,
+  "騎": 460,
+  "台": 461,
+  "猫": 462,
+  "丸": 463,
+  "七": 464,
+  "歌": 465,
+  "旅": 466,
+  "娘": 467,
+  "闘": 468,
+  "能": 469,
+  "弟": 470,
+  "★": 471,
+  "山": 472,
+  "黒": 473,
+  "ピ": 474,
+  "君": 475,
+  "爱": 476,
+  "章": 477,
+  "風": 478,
+  "戏": 479,
+  "斯": 480,
+  "血": 481,
+  "春": 482,
+  "銉": 483,
+  "部": 484,
+  "院": 485,
+  "學": 486,
+  "聖": 487,
+  "ょ": 488,
+  "五": 489,
+  "机": 490,
+  "真": 491,
+  "流": 492,
+  "改": 493,
+  "術": 494,
+  "巴": 495,
+  "乱": 496,
+  "東": 497,
+  "募": 498,
+  "険": 499,
+  "決": 500,
+  "画": 501,
+  "幻": 502,
+  "命": 503,
+  "拳": 504,
+  "救": 505,
+  "代": 506,
+  "間": 507,
+  "戯": 508,
+  "野": 509,
+  "自": 510,
+  "先": 511,
+  "石": 512,
+  "翻": 513,
+  "巻": 514,
+  "十": 515,
+  "迷": 516,
+  "路": 517,
+  "艦": 518,
+  "圣": 519,
+  "後": 520,
+  "剑": 521,
+  "市": 522,
+  "译": 523,
+  "紀": 524,
+  "纪": 525,
+  "暗": 526,
+  "北": 527,
+  "常": 528,
+  "時": 529,
+  "尾": 530,
+  "ご": 531,
+  "為": 532,
+  "ポ": 533,
+  "拉": 534,
+  "穹": 535,
+  "榫": 536,
+  "走": 537,
+  "踪": 538,
+  "ぶ": 539,
+  "千": 540,
+  "喜": 541,
+  "甜": 542,
+  "苍": 543,
+  "园": 544,
+  "所": 545,
+  "½": 546,
+  "安": 547,
+  "港": 548,
+  "撃": 549,
+  "电": 550,
+  "俺": 551,
+  "夢": 552,
+  "僅": 553,
+  "澳": 554,
+  "修": 555,
+  "矢": 556,
+  "室": 557,
+  "書": 558,
+  "赤": 559,
+  "區": 560,
+  "欑": 561,
+  "险": 562,
+  "合": 563,
+  "方": 564,
+  "様": 565,
+  "六": 566,
+  "变": 567,
+  "ォ": 568,
+  "灰": 569,
+  "姐": 570,
+  "里": 571,
+  "彔": 572,
+  "與": 573,
+  "ヒ": 574,
+  "鉄": 575,
+  "ゆ": 576,
+  "び": 577,
+  "実": 578,
+  "…": 579,
+  "殺": 580,
+  "逆": 581,
+  "ぐ": 582,
+  "元": 583,
+  "等": 584,
+  "秘": 585,
+  "内": 586,
+  "終": 587,
+  "嵌": 588,
+  "転": 589,
+  "到": 590,
+  "田": 591,
+  "姫": 592,
+  "僕": 593,
+  "雨": 594,
+  "孩": 595,
+  "草": 596,
+  "ず": 597,
+  "同": 598,
+  "再": 599,
+  "码": 600,
+  "開": 601,
+  "禁": 602,
+  "`": 603,
+  "原": 604,
+  "旋": 605,
+  "好": 606,
+  "脳": 607,
+  "涔": 608,
+  "水": 609,
+  "巨": 610,
+  "堕": 611,
+  "笑": 612,
+  "思": 613,
+  "独": 614,
+  "录": 615,
+  "配": 616,
+  "社": 617,
+  "灏": 618,
+  "情": 619,
+  "桃": 620,
+  "骑": 621,
+  "贝": 622,
+  "老": 623,
+  "櫻": 624,
+  "知": 625,
+  "言": 626,
+  "被": 627,
+  "身": 628,
+  "图": 629,
+  "挂": 630,
+  "杀": 631,
+  "軍": 632,
+  "約": 633,
+  "炎": 634,
+  "牙": 635,
+  "理": 636,
+  "ホ": 637,
+  "閾": 638,
+  "龍": 639,
+  "獣": 640,
+  "眼": 641,
+  "見": 642,
+  "Ⅰ": 643,
+  "む": 644,
+  "放": 645,
+  "派": 646,
+  "瓊": 647,
+  "ユ": 648,
+  "数": 649,
+  "戟": 650,
+  "后": 651,
+  "曲": 652,
+  "変": 653,
+  "器": 654,
+  "ヘ": 655,
+  "境": 656,
+  "鋼": 657,
+  "魂": 658,
+  "剣": 659,
+  "形": 660,
+  "街": 661,
+  "進": 662,
+  "恶": 663,
+  "落": 664,
+  "史": 665,
+  "咪": 666,
+  "相": 667,
+  "意": 668,
+  "平": 669,
+  "就": 670,
+  "克": 671,
+  "用": 672,
+  "博": 673,
+  "攻": 674,
+  "飛": 675,
+  "発": 676,
+  "貓": 677,
+  "玩": 678,
+  "比": 679,
+  "刀": 680,
+  "結": 681,
+  "要": 682,
+  "入": 683,
+  "车": 684,
+  "虫": 685,
+  "化": 686,
+  "九": 687,
+  "甲": 688,
+  "推": 689,
+  "育": 690,
+  "密": 691,
+  "马": 692,
+  "悪": 693,
+  "头": 694,
+  "電": 695,
+  "墓": 696,
+  "印": 697,
+  "ぬ": 698,
+  "Ⅴ": 699,
+  "红": 700,
+  "島": 701,
+  "你": 702,
+  "義": 703,
+  "ぼ": 704,
+  "轉": 705,
+  "ね": 706,
+  "罗": 707,
+  "装": 708,
+  "邦": 709,
+  "戲": 710,
+  "吧": 711,
+  "竜": 712,
+  "莺": 713,
+  "対": 714,
+  "長": 715,
+  "永": 716,
+  "疾": 717,
+  "べ": 718,
+  "劣": 719,
+  "悟": 720,
+  "　": 721,
+  "消": 722,
+  "ヨ": 723,
+  "通": 724,
+  "雷": 725,
+  "曹": 726,
+  "勝": 727,
+  "乌": 728,
+  "击": 729,
+  "果": 730,
+  "{": 731,
+  "線": 732,
+  "防": 733,
+  "德": 734,
+  "}": 735,
+  "ぞ": 736,
+  "哥": 737,
+  "长": 738,
+  "刃": 739,
+  "泣": 740,
+  "盗": 741,
+  "惑": 742,
+  "蹈": 743,
+  "冴": 744,
+  "気": 745,
+  "國": 746,
+  "斬": 747,
+  "门": 748,
+  "福": 749,
+  "絶": 750,
+  "爸": 751,
+  "げ": 752,
+  "假": 753,
+  "婚": 754,
+  "獄": 755,
+  "叶": 756,
+  "嫁": 757,
+  "萌": 758,
+  "宠": 759,
+  "线": 760,
+  "座": 761,
+  "飞": 762,
+  "江": 763,
+  "奴": 764,
+  "格": 765,
+  "戀": 766,
+  "尊": 767,
+  "味": 768,
+  "鲁": 769,
+  "失": 770,
+  "童": 771,
+  "当": 772,
+  "正": 773,
+  "今": 774,
+  "이": 775,
+  "声": 776,
+  "暴": 777,
+  "恐": 778,
+  "利": 779,
+  "号": 780,
+  "讨": 781,
+  "堂": 782,
+  "누": 783,
+  "야": 784,
+  "黄": 785,
+  "輪": 786,
+  "戝": 787,
+  "转": 788,
+  "宣": 789,
+  "律": 790,
+  "进": 791,
+  "彩": 792,
+  "盟": 793,
+  "激": 794,
+  "塔": 795,
+  "工": 796,
+  "间": 797,
+  "分": 798,
+  "古": 799,
+  "森": 800,
+  "汉": 801,
+  "宮": 802,
+  "守": 803,
+  "铁": 804,
+  "奈": 805,
+  "職": 806,
+  "’": 807,
+  "庭": 808,
+  "去": 809,
+  "切": 810,
+  "嬬": 811,
+  "Ⅳ": 812,
+  "幽": 813,
+  "陽": 814,
+  "猎": 815,
+  "敵": 816,
+  "危": 817,
+  "绵": 818,
+  "幸": 819,
+  "厌": 820,
+  "宗": 821,
+  "；": 822,
+  "儿": 823,
+  "初": 824,
+  "角": 825,
+  "罪": 826,
+  "念": 827,
+  "噬": 828,
+  "帝": 829,
+  "♭": 830,
+  "深": 831,
+  "反": 832,
+  "登": 833,
+  "快": 834,
+  "木": 835,
+  "望": 836,
+  "♪": 837,
+  "网": 838,
+  "鎴": 839,
+  "弱": 840,
+  "对": 841,
+  "庚": 842,
+  "看": 843,
+  "为": 844,
+  "波": 845,
+  "私": 846,
+  "极": 847,
+  "仮": 848,
+  "林": 849,
+  "屋": 850,
+  "別": 851,
+  "向": 852,
+  "ほ": 853,
+  "亚": 854,
+  "警": 855,
+  "兵": 856,
+  "母": 857,
+  "终": 858,
+  "信": 859,
+  "个": 860,
+  "極": 861,
+  "圈": 862,
+  "助": 863,
+  "干": 864,
+  "牌": 865,
+  "藏": 866,
+  "甘": 867,
+  "伊": 868,
+  "鬥": 869,
+  "ゾ": 870,
+  "徒": 871,
+  "√": 872,
+  "契": 873,
+  "湖": 874,
+  "运": 875,
+  "虎": 876,
+  ":": 877,
+  "送": 878,
+  "滅": 879,
+  "定": 880,
+  "跳": 881,
+  "狐": 882,
+  "遠": 883,
+  "交": 884,
+  "浪": 885,
+  "西": 886,
+  "羽": 887,
+  "翼": 888,
+  "丈": 889,
+  "涓": 890,
+  "《": 891,
+  "》": 892,
+  "傳": 893,
+  "咯": 894,
+  "馬": 895,
+  "運": 896,
+  "ざ": 897,
+  "达": 898,
+  "村": 899,
+  "说": 900,
+  "略": 901,
+  "孫": 902,
+  "莉": 903,
+  "姬": 904,
+  "加": 905,
+  "〜": 906,
+  "铛": 907,
+  "録": 908,
+  "劍": 909,
+  "烈": 910,
+  "紅": 911,
+  "视": 912,
+  "钉": 913,
+  "姆": 914,
+  "起": 915,
+  "邪": 916,
+  "皿": 917,
+  "至": 918,
+  "香": 919,
+  "争": 920,
+  "達": 921,
+  "娜": 922,
+  "队": 923,
+  "结": 924,
+  "銈": 925,
+  "殑": 926,
+  "追": 927,
+  "衛": 928,
+  "造": 929,
+  "來": 930,
+  "簿": 931,
+  "带": 932,
+  "立": 933,
+  "毛": 934,
+  "打": 935,
+  "岛": 936,
+  "解": 937,
+  "开": 938,
+  "突": 939,
+  "妮": 940,
+  "洛": 941,
+  "诸": 942,
+  "餐": 943,
+  "화": 944,
+  "联": 945,
+  "管": 946,
+  "闇": 947,
+  "点": 948,
+  "降": 949,
+  "業": 950,
+  "列": 951,
+  "那": 952,
+  "呼": 953,
+  "響": 954,
+  "復": 955,
+  "侠": 956,
+  "才": 957,
+  "棒": 958,
+  "片": 959,
+  "琪": 960,
+  "奥": 961,
+  "ぷ": 962,
+  "技": 963,
+  "『": 964,
+  "』": 965,
+  "弾": 966,
+  "术": 967,
+  "怖": 968,
+  "蒼": 969,
+  "鸣": 970,
+  "種": 971,
+  "寒": 972,
+  "鐨": 973,
+  "感": 974,
+  "熊": 975,
+  "荒": 976,
+  "ぁ": 977,
+  "사": 978,
+  "亜": 979,
+  "布": 980,
+  "尸": 981,
+  "脑": 982,
+  "內": 983,
+  "燃": 984,
+  "喰": 985,
+  "赛": 986,
+  "存": 987,
+  "祖": 988,
+  "摇": 989,
+  "见": 990,
+  "病": 991,
+  "酒": 992,
+  "凡": 993,
+  "挑": 994,
+  "虹": 995,
+  "競": 996,
+  "东": 997,
+  "葉": 998,
+  "阿": 999,
+  "粤": 1000,
+  "巫": 1001,
+  "豪": 1002,
+  "孤": 1003,
+  "陰": 1004,
+  "陣": 1005,
+  "惡": 1006,
+  "乐": 1007,
+  "尼": 1008,
+  "咲": 1009,
+  "ぱ": 1010,
+  "系": 1011,
+  "谜": 1012,
+  "譚": 1013,
+  "襲": 1014,
+  "靈": 1015,
+  "别": 1016,
+  "伍": 1017,
+  "良": 1018,
+  "歡": 1019,
+  "取": 1020,
+  "級": 1021,
+  "悲": 1022,
+  "妻": 1023,
+  "袭": 1024,
+  "帰": 1025,
+  "亡": 1026,
+  "药": 1027,
+  "會": 1028,
+  "熱": 1029,
+  "藍": 1030,
+  "賊": 1031,
+  "客": 1032,
+  "秦": 1033,
+  "将": 1034,
+  "謎": 1035,
+  "車": 1036,
+  "多": 1037,
+  "求": 1038,
+  "抱": 1039,
+  "纯": 1040,
+  "然": 1041,
+  "吞": 1042,
+  "瓒": 1043,
+  "锚": 1044,
+  "何": 1045,
+  "断": 1046,
+  "束": 1047,
+  "鍥": 1048,
+  "．": 1049,
+  "骨": 1050,
+  "祭": 1051,
+  "非": 1052,
+  "鏃": 1053,
+  "发": 1054,
+  "鳥": 1055,
+  "享": 1056,
+  "鍏": 1057,
+  "寄": 1058,
+  "Δ": 1059,
+  "聲": 1060,
+  "近": 1061,
+  "秋": 1062,
+  "民": 1063,
+  "川": 1064,
+  "们": 1065,
+  "銇": 1066,
+  "度": 1067,
+  "露": 1068,
+  "雲": 1069,
+  "驱": 1070,
+  "复": 1071,
+  "绝": 1072,
+  "歁": 1073,
+  "犲": 1074,
+  "书": 1075,
+  "素": 1076,
+  "幼": 1077,
+  "御": 1078,
+  "职": 1079,
+  "租": 1080,
+  "得": 1081,
+  "指": 1082,
+  "鍒": 1083,
+  "宅": 1084,
+  "欢": 1085,
+  "꞉": 1086,
+  "休": 1087,
+  "希": 1088,
+  "底": 1089,
+  "宿": 1090,
+  "噹": 1091,
+  "Ψ": 1092,
+  "－": 1093,
+  "宫": 1094,
+  "現": 1095,
+  "竹": 1096,
+  "拥": 1097,
+  "召": 1098,
+  "弐": 1099,
+  "醒": 1100,
+  "選": 1101,
+  "霸": 1102,
+  "封": 1103,
+  "辰": 1104,
+  "侵": 1105,
+  "政": 1106,
+  "借": 1107,
+  "ぃ": 1108,
+  "輝": 1109,
+  "倒": 1110,
+  "楽": 1111,
+  "吉": 1112,
+  "ゥ": 1113,
+  "兗": 1114,
+  "尚": 1115,
+  "偵": 1116,
+  "也": 1117,
+  "把": 1118,
+  "磁": 1119,
+  "叮": 1120,
+  "透": 1121,
+  "險": 1122,
+  "從": 1123,
+  "問": 1124,
+  "止": 1125,
+  "启": 1126,
+  "治": 1127,
+  "如": 1128,
+  "ぽ": 1129,
+  "榄": 1130,
+  "晚": 1131,
+  "샤": 1132,
+  "级": 1133,
+  "搞": 1134,
+  "庡": 1135,
+  "强": 1136,
+  "啊": 1137,
+  "共": 1138,
+  "铆": 1139,
+  "°": 1140,
+  "肉": 1141,
+  "卒": 1142,
+  "艺": 1143,
+  "医": 1144,
+  "玉": 1145,
+  "首": 1146,
+  "奏": 1147,
+  "―": 1148,
+  "頭": 1149,
+  "性": 1150,
+  "過": 1151,
+  "冰": 1152,
+  "捕": 1153,
+  "銃": 1154,
+  "優": 1155,
+  "尔": 1156,
+  "灼": 1157,
+  "館": 1158,
+  "ゅ": 1159,
+  "霊": 1160,
+  "◆": 1161,
+  "蛋": 1162,
+  "羅": 1163,
+  "员": 1164,
+  "半": 1165,
+  "鹰": 1166,
+  "萨": 1167,
+  "監": 1168,
+  "卫": 1169,
+  "什": 1170,
+  "é": 1171,
+  "演": 1172,
+  "負": 1173,
+  "秒": 1174,
+  "銆": 1175,
+  "关": 1176,
+  "轮": 1177,
+  "班": 1178,
+  "導": 1179,
+  "船": 1180,
+  "吹": 1181,
+  "牧": 1182,
+  "退": 1183,
+  "领": 1184,
+  "這": 1185,
+  "涙": 1186,
+  "络": 1187,
+  "店": 1188,
+  "玗": 1189,
+  "嵃": 1190,
+  "魯": 1191,
+  "ヌ": 1192,
+  "跡": 1193,
+  "兂": 1194,
+  "现": 1195,
+  "篮": 1196,
+  "橘": 1197,
+  "荘": 1198,
+  "丹": 1199,
+  "門": 1200,
+  "遮": 1201,
+  "莲": 1202,
+  "吸": 1203,
+  "某": 1204,
+  "朋": 1205,
+  "夫": 1206,
+  "志": 1207,
+  "皇": 1208,
+  "临": 1209,
+  "直": 1210,
+  "製": 1211,
+  "砂": 1212,
+  "塾": 1213,
+  "冠": 1214,
+  "鲸": 1215,
+  "铺": 1216,
+  "迎": 1217,
+  "々": 1218,
+  "过": 1219,
+  "夈": 1220,
+  "觉": 1221,
+  "願": 1222,
+  "們": 1223,
+  "除": 1224,
+  "镜": 1225,
+  "恒": 1226,
+  "嘘": 1227,
+  "說": 1228,
+  "式": 1229,
+  "歩": 1230,
+  "粉": 1231,
+  "叔": 1232,
+  "衣": 1233,
+  "総": 1234,
+  "唱": 1235,
+  "錄": 1236,
+  "酱": 1237,
+  "待": 1238,
+  "哦": 1239,
+  "晴": 1240,
+  "＋": 1241,
+  "父": 1242,
+  "阳": 1243,
+  "服": 1244,
+  "呪": 1245,
+  "而": 1246,
+  "鏄": 1247,
+  "華": 1248,
+  "２": 1249,
+  "刻": 1250,
+  "瀹": 1251,
+  "實": 1252,
+  "于": 1253,
+  "帳": 1254,
+  "以": 1255,
+  "压": 1256,
+  "壊": 1257,
+  "紒": 1258,
+  "架": 1259,
+  "勫": 1260,
+  "唤": 1261,
+  "孔": 1262,
+  "任": 1263,
+  "档": 1264,
+  "若": 1265,
+  "妈": 1266,
+  "閃": 1267,
+  "充": 1268,
+  "历": 1269,
+  "怒": 1270,
+  "儵": 1271,
+  "席": 1272,
+  "員": 1273,
+  "獸": 1274,
+  "憶": 1275,
+  "蘭": 1276,
+  "气": 1277,
+  "號": 1278,
+  "枪": 1279,
+  "町": 1280,
+  "談": 1281,
+  "短": 1282,
+  "乙": 1283,
+  "埋": 1284,
+  "泉": 1285,
+  "樺": 1286,
+  "诛": 1287,
+  "足": 1288,
+  "△": 1289,
+  "故": 1290,
+  "莱": 1291,
+  "辉": 1292,
+  "支": 1293,
+  "零": 1294,
+  "芙": 1295,
+  "執": 1296,
+  "役": 1297,
+  "曼": 1298,
+  "笛": 1299,
+  "逃": 1300,
+  "題": 1301,
+  "替": 1302,
+  "庫": 1303,
+  "淬": 1304,
+  "伴": 1305,
+  "彈": 1306,
+  "收": 1307,
+  "葬": 1308,
+  "只": 1309,
+  "溿": 1310,
+  "敌": 1311,
+  "米": 1312,
+  "速": 1313,
+  "喚": 1314,
+  "對": 1315,
+  "帐": 1316,
+  "舟": 1317,
+  "砕": 1318,
+  "鐵": 1319,
+  "观": 1320,
+  "鏈": 1321,
+  "灯": 1322,
+  "巧": 1323,
+  "祝": 1324,
+  "盾": 1325,
+  "缁": 1326,
+  "団": 1327,
+  "確": 1328,
+  "袨": 1329,
+  "關": 1330,
+  "越": 1331,
+  "嵐": 1332,
+  "企": 1333,
+  "叫": 1334,
+  "样": 1335,
+  "浣": 1336,
+  "织": 1337,
+  "型": 1338,
+  "漂": 1339,
+  "違": 1340,
+  "魚": 1341,
+  "镇": 1342,
+  "認": 1343,
+  "幹": 1344,
+  "錬": 1345,
+  "品": 1346,
+  "覚": 1347,
+  "普": 1348,
+  "鍩": 1349,
+  "戠": 1350,
+  "托": 1351,
+  "议": 1352,
+  "兔": 1353,
+  "講": 1354,
+  "局": 1355,
+  "變": 1356,
+  "她": 1357,
+  "���": 1358,
+  "個": 1359,
+  "朵": 1360,
+  "因": 1361,
+  "腹": 1362,
+  "點": 1363,
+  "由": 1364,
+  "崎": 1365,
+  "咼": 1366,
+  "曳": 1367,
+  "胞": 1368,
+  "満": 1369,
+  "戒": 1370,
+  "拿": 1371,
+  "糕": 1372,
+  "湯": 1373,
+  "桜": 1374,
+  "缘": 1375,
+  "鱼": 1376,
+  "於": 1377,
+  "司": 1378,
+  "智": 1379,
+  "忌": 1380,
+  "很": 1381,
+  "究": 1382,
+  "刚": 1383,
+  "誕": 1384,
+  "寺": 1385,
+  "嬪": 1386,
+  "著": 1387,
+  "釣": 1388,
+  "瀛": 1389,
+  "虚": 1390,
+  "殻": 1391,
+  "蓮": 1392,
+  "乾": 1393,
+  "佸": 1394,
+  "態": 1395,
+  "灌": 1396,
+  "脿": 1397,
+  "靠": 1398,
+  "樂": 1399,
+  "总": 1400,
+  "绻": 1401,
+  "仇": 1402,
+  "胜": 1403,
+  "謀": 1404,
+  "濂": 1405,
+  "混": 1406,
+  "寻": 1407,
+  "純": 1408,
+  "哈": 1409,
+  "仲": 1410,
+  "厜": 1411,
+  "蟲": 1412,
+  "照": 1413,
+  "着": 1414,
+  "营": 1415,
+  "樹": 1416,
+  "忆": 1417,
+  "験": 1418,
+  "远": 1419,
+  "么": 1420,
+  "誰": 1421,
+  "貴": 1422,
+  "細": 1423,
+  "傷": 1424,
+  "裏": 1425,
+  "懂": 1426,
+  "持": 1427,
+  "盖": 1428,
+  "ぇ": 1429,
+  "詩": 1430,
+  "伪": 1431,
+  "杯": 1432,
+  "氷": 1433,
+  "澶": 1434,
+  "歅": 1435,
+  "１": 1436,
+  "兰": 1437,
+  "娌": 1438,
+  "参": 1439,
+  "鐛": 1440,
+  "髪": 1441,
+  "续": 1442,
+  "晶": 1443,
+  "炼": 1444,
+  "熸": 1445,
+  "弹": 1446,
+  "油": 1447,
+  "絆": 1448,
+  "報": 1449,
+  "义": 1450,
+  "槦": 1451,
+  "秀": 1452,
+  "连": 1453,
+  "帖": 1454,
+  "灭": 1455,
+  "螺": 1456,
+  "频": 1457,
+  "奶": 1458,
+  "问": 1459,
+  "排": 1460,
+  "源": 1461,
+  "鐗": 1462,
+  "响": 1463,
+  "試": 1464,
+  "眠": 1465,
+  "谍": 1466,
+  "瑰": 1467,
+  "創": 1468,
+  "丽": 1469,
+  "刺": 1470,
+  "廻": 1471,
+  "處": 1472,
+  "节": 1473,
+  "基": 1474,
+  "呬": 1475,
+  "瓟": 1476,
+  "皮": 1477,
+  "昭": 1478,
+  "禄": 1479,
+  "急": 1480,
+  "鳴": 1481,
+  "团": 1482,
+  "两": 1483,
+  "其": 1484,
+  "”": 1485,
+  "騒": 1486,
+  "蝉": 1487,
+  "暁": 1488,
+  "雫": 1489,
+  "杰": 1490,
+  "馆": 1491,
+  "朝": 1492,
+  "销": 1493,
+  "则": 1494,
+  "察": 1495,
+  "づ": 1496,
+  "飯": 1497,
+  "還": 1498,
+  "ㄦ": 1499,
+  "口": 1500,
+  "从": 1501,
+  "鏡": 1502,
+  "%": 1503,
+  "哄": 1504,
+  "浦": 1505,
+  "珍": 1506,
+  "緋": 1507,
+  "喵": 1508,
+  "做": 1509,
+  "忘": 1510,
+  "约": 1511,
+  "散": 1512,
+  "瞳": 1513,
+  "单": 1514,
+  "索": 1515,
+  "保": 1516,
+  "谎": 1517,
+  "佐": 1518,
+  "雀": 1519,
+  "饭": 1520,
+  "撞": 1521,
+  "偽": 1522,
+  "坤": 1523,
+  "返": 1524,
+  "歋": 1525,
+  "威": 1526,
+  "亞": 1527,
+  "椋": 1528,
+  "傛": 1529,
+  "征": 1530,
+  "屍": 1531,
+  "必": 1532,
+  "值": 1533,
+  "息": 1534,
+  "承": 1535,
+  "脱": 1536,
+  "猿": 1537,
+  "纳": 1538,
+  "冥": 1539,
+  "刑": 1540,
+  "令": 1541,
+  "忔": 1542,
+  "搜": 1543,
+  "浜": 1544,
+  "晫": 1545,
+  "芥": 1546,
+  "尽": 1547,
+  "表": 1548,
+  "潔": 1549,
+  "哠": 1550,
+  "逮": 1551,
+  "ｘ": 1552,
+  "兒": 1553,
+  "松": 1554,
+  "稿": 1555,
+  "嬫": 1556,
+  "沙": 1557,
+  "獨": 1558,
+  "鏉": 1559,
+  "奪": 1560,
+  "寮": 1561,
+  "楀": 1562,
+  "富": 1563,
+  "炮": 1564,
+  "序": 1565,
+  "官": 1566,
+  "麻": 1567,
+  "苦": 1568,
+  "根": 1569,
+  "離": 1570,
+  "狩": 1571,
+  "群": 1572,
+  "犯": 1573,
+  "給": 1574,
+  "ぜ": 1575,
+  "诞": 1576,
+  "у": 1577,
+  "诲": 1578,
+  "堟": 1579,
+  "Ω": 1580,
+  "玄": 1581,
+  "菜": 1582,
+  "闻": 1583,
+  "计": 1584,
+  "絵": 1585,
+  "坂": 1586,
+  "他": 1587,
+  "残": 1588,
+  "房": 1589,
+  "卧": 1590,
+  "应": 1591,
+  "図": 1592,
+  "量": 1593,
+  "塞": 1594,
+  "创": 1595,
+  "柟": 1596,
+  "悠": 1597,
+  "齡": 1598,
+  "涢": 1599,
+  "鑰": 1600,
+  "欏": 1601,
+  "焰": 1602,
+  "谭": 1603,
+  "鯨": 1604,
+  "姊": 1605,
+  "爾": 1606,
+  "煩": 1607,
+  "鐑": 1608,
+  "欧": 1609,
+  "盜": 1610,
+  "糖": 1611,
+  "咒": 1612,
+  "紙": 1613,
+  "綔": 1614,
+  "祵": 1615,
+  "當": 1616,
+  "敗": 1617,
+  "◎": 1618,
+  "鐜": 1619,
+  "❤": 1620,
+  "樿": 1621,
+  "侀": 1622,
+  "烦": 1623,
+  "“": 1624,
+  "井": 1625,
+  "罠": 1626,
+  "狱": 1627,
+  "率": 1628,
+  "鸟": 1629,
+  "燈": 1630,
+  "吗": 1631,
+  "轨": 1632,
+  "洞": 1633,
+  "炽": 1634,
+  "琴": 1635,
+  "徹": 1636,
+  "親": 1637,
+  "冲": 1638,
+  "蜂": 1639,
+  "华": 1640,
+  "擊": 1641,
+  "胎": 1642,
+  "疑": 1643,
+  "编": 1644,
+  "麼": 1645,
+  "注": 1646,
+  "顔": 1647,
+  "魁": 1648,
+  "绘": 1649,
+  "忙": 1650,
+  "邂": 1651,
+  "逅": 1652,
+  "闖": 1653,
+  "种": 1654,
+  "策": 1655,
+  "谷": 1656,
+  "課": 1657,
+  "迴": 1658,
+  "剁": 1659,
+  "热": 1660,
+  "藤": 1661,
+  "划": 1662,
+  "屁": 1663,
+  "厅": 1664,
+  "斿": 1665,
+  "閲": 1666,
+  "欲": 1667,
+  "昏": 1668,
+  "護": 1669,
+  "獵": 1670,
+  "懐": 1671,
+  "類": 1672,
+  "將": 1673,
+  "熺": 1674,
+  "骞": 1675,
+  "兘": 1676,
+  "住": 1677,
+  "闪": 1678,
+  "誘": 1679,
+  "鬱": 1680,
+  "裂": 1681,
+  "受": 1682,
+  "槑": 1683,
+  "乃": 1684,
+  "ヲ": 1685,
+  "颂": 1686,
+  "吃": 1687,
+  "酷": 1688,
+  "练": 1689,
+  "考": 1690,
+  "橋": 1691,
+  "唯": 1692,
+  "坛": 1693,
+  "計": 1694,
+  "Ａ": 1695,
+  "壞": 1696,
+  "천": 1697,
+  "소": 1698,
+  "○": 1699,
+  "占": 1700,
+  "让": 1701,
+  "料": 1702,
+  "沧": 1703,
+  "接": 1704,
+  "蜜": 1705,
+  "丁": 1706,
+  "猛": 1707,
+  "库": 1708,
+  "俏": 1709,
+  "蛛": 1710,
+  "咏": 1711,
+  "狙": 1712,
+  "諜": 1713,
+  "鏅": 1714,
+  "凪": 1715,
+  "业": 1716,
+  "難": 1717,
+  "檬": 1718,
+  "毒": 1719,
+  "听": 1720,
+  "逐": 1721,
+  "聞": 1722,
+  "璃": 1723,
+  "鐢": 1724,
+  "･": 1725,
+  "ñ": 1726,
+  "洣": 1727,
+  "丮": 1728,
+  "麗": 1729,
+  "惧": 1730,
+  "贵": 1731,
+  "植": 1732,
+  "蜘": 1733,
+  "昆": 1734,
+  "＜": 1735,
+  "＞": 1736,
+  "続": 1737,
+  "帽": 1738,
+  "旀": 1739,
+  "硶": 1740,
+  "辛": 1741,
+  "曟": 1742,
+  "拾": 1743,
+  "녀": 1744,
+  "티": 1745,
+  "依": 1746,
+  "伐": 1747,
+  "找": 1748,
+  "營": 1749,
+  "肌": 1750,
+  "売": 1751,
+  "歍": 1752,
+  "甦": 1753,
+  "네": 1754,
+  "雙": 1755,
+  "議": 1756,
+  "题": 1757,
+  "氣": 1758,
+  "楂": 1759,
+  "候": 1760,
+  "摩": 1761,
+  "領": 1762,
+  "萊": 1763,
+  "♡": 1764,
+  "宰": 1765,
+  "鐩": 1766,
+  "杞": 1767,
+  "勾": 1768,
+  "婆": 1769,
+  "Ⅵ": 1770,
+  "憂": 1771,
+  "负": 1772,
+  "站": 1773,
+  "姩": 1774,
+  "揪": 1775,
+  "洋": 1776,
+  "景": 1777,
+  "浠": 1778,
+  "温": 1779,
+  "蟹": 1780,
+  "連": 1781,
+  "庄": 1782,
+  "廊": 1783,
+  "欳": 1784,
+  "夋": 1785,
+  "滄": 1786,
+  "頌": 1787,
+  "偢": 1788,
+  "獻": 1789,
+  "愿": 1790,
+  "殿": 1791,
+  "土": 1792,
+  "振": 1793,
+  "迫": 1794,
+  "渊": 1795,
+  "箱": 1796,
+  "似": 1797,
+  "烧": 1798,
+  "搖": 1799,
+  "—": 1800,
+  "护": 1801,
+  "楄": 1802,
+  "賭": 1803,
+  "駆": 1804,
+  "横": 1805,
+  "茅": 1806,
+  "算": 1807,
+  "夕": 1808,
+  "袣": 1809,
+  "擅": 1810,
+  "佺": 1811,
+  "迹": 1812,
+  "泽": 1813,
+  "練": 1814,
+  "遇": 1815,
+  "够": 1816,
+  "鋒": 1817,
+  "賽": 1818,
+  "状": 1819,
+  "観": 1820,
+  "彻": 1821,
+  "團": 1822,
+  "殊": 1823,
+  "梅": 1824,
+  "卜": 1825,
+  "扮": 1826,
+  "瀵": 1827,
+  "绁": 1828,
+  "豚": 1829,
+  "鷹": 1830,
+  "柠": 1831,
+  "寿": 1832,
+  "匠": 1833,
+  "芽": 1834,
+  "則": 1835,
+  "関": 1836,
+  "ต": 1837,
+  "น": 1838,
+  "ท": 1839,
+  "่": 1840,
+  "弄": 1841,
+  "滿": 1842,
+  "往": 1843,
+  "拓": 1844,
+  "訓": 1845,
+  "锋": 1846,
+  "赫": 1847,
+  "慬": 1848,
+  "陸": 1849,
+  "氏": 1850,
+  "อ": 1851,
+  "ี": 1852,
+  "畫": 1853,
+  "壁": 1854,
+  "涼": 1855,
+  "臨": 1856,
+  "仕": 1857,
+  "栫": 1858,
+  "亲": 1859,
+  "囧": 1860,
+  "预": 1861,
+  "惨": 1862,
+  "轴": 1863,
+  "冬": 1864,
+  "歲": 1865,
+  "刊": 1866,
+  "鍔": 1867,
+  "鎮": 1868,
+  "娴": 1869,
+  "粍": 1870,
+  "久": 1871,
+  "步": 1872,
+  "訪": 1873,
+  "赝": 1874,
+  "翔": 1875,
+  "汽": 1876,
+  "鼠": 1877,
+  "¡": 1878,
+  "錯": 1879,
+  "岁": 1880,
+  "誤": 1881,
+  "驯": 1882,
+  "恰": 1883,
+  "栈": 1884,
+  "兼": 1885,
+  "沈": 1886,
+  "仁": 1887,
+  "满": 1888,
+  "鬪": 1889,
+  "黃": 1890,
+  "提": 1891,
+  "射": 1892,
+  "紵": 1893,
+  "驅": 1894,
+  "懈": 1895,
+  "崩": 1896,
+  "拍": 1897,
+  "具": 1898,
+  "協": 1899,
+  "┍": 1900,
+  "掉": 1901,
+  "瞬": 1902,
+  "阴": 1903,
+  "鍙": 1904,
+  "右": 1905,
+  "焔": 1906,
+  "怣": 1907,
+  "泳": 1908,
+  "標": 1909,
+  "棩": 1910,
+  "换": 1911,
+  "筋": 1912,
+  "蕾": 1913,
+  "嫌": 1914,
+  "礼": 1915,
+  "誓": 1916,
+  "习": 1917,
+  "党": 1918,
+  "胖": 1919,
+  "佹": 1920,
+  "遭": 1921,
+  "杜": 1922,
+  "縛": 1923,
+  "罐": 1924,
+  "伏": 1925,
+  "灄": 1926,
+  "儚": 1927,
+  "渚": 1928,
+  "〈": 1929,
+  "〉": 1930,
+  "狗": 1931,
+  "袠": 1932,
+  "養": 1933,
+  "鐧": 1934,
+  "裡": 1935,
+  "辨": 1936,
+  "示": 1937,
+  "案": 1938,
+  "嫳": 1939,
+  "居": 1940,
+  "包": 1941,
+  "逢": 1942,
+  "滚": 1943,
+  "哀": 1944,
+  "糊": 1945,
+  "更": 1946,
+  "璐": 1947,
+  "鐖": 1948,
+  "低": 1949,
+  "戮": 1950,
+  "補": 1951,
+  "铃": 1952,
+  "択": 1953,
+  "煌": 1954,
+  "廢": 1955,
+  "坏": 1956,
+  "弦": 1957,
+  "骸": 1958,
+  "瓙": 1959,
+  "輩": 1960,
+  "标": 1961,
+  "圆": 1962,
+  "珊": 1963,
+  "瑚": 1964,
+  "讐": 1965,
+  "虛": 1966,
+  "绯": 1967,
+  "屈": 1968,
+  "曜": 1969,
+  "军": 1970,
+  "跨": 1971,
+  "板": 1972,
+  "肩": 1973,
+  "聽": 1974,
+  "陷": 1975,
+  "６": 1976,
+  "闷": 1977,
+  "ぺ": 1978,
+  "菓": 1979,
+  "伤": 1980,
+  "供": 1981,
+  "稲": 1982,
+  "搭": 1983,
+  "庢": 1984,
+  "姉": 1985,
+  "跑": 1986,
+  "増": 1987,
+  "伃": 1988,
+  "亂": 1989,
+  "慘": 1990,
+  "但": 1991,
+  "爷": 1992,
+  "續": 1993,
+  "耳": 1994,
+  "钻": 1995,
+  "鎧": 1996,
+  "条": 1997,
+  "伒": 1998,
+  "億": 1999,
+  "铠": 2000,
+  "周": 2001,
+  "给": 2002,
+  "械": 2003,
+  "选": 2004,
+  "弁": 2005,
+  "倉": 2006,
+  "詠": 2007,
+  "´": 2008,
+  "愮": 2009,
+  "瓶": 2010,
+  "雅": 2011,
+  "單": 2012,
+  "袋": 2013,
+  "勯": 2014,
+  "鍐": 2015,
+  "珨": 2016,
+  "瓦": 2017,
+  "眾": 2018,
+  "發": 2019,
+  "舰": 2020,
+  "养": 2021,
+  "各": 2022,
+  "塵": 2023,
+  "壽": 2024,
+  "袪": 2025,
+  "檔": 2026,
+  "╃": 2027,
+  "諾": 2028,
+  "鍓": 2029,
+  "鍖": 2030,
+  "惊": 2031,
+  "苏": 2032,
+  "尖": 2033,
+  "边": 2034,
+  "遺": 2035,
+  "戸": 2036,
+  "广": 2037,
+  "吻": 2038,
+  "桔": 2039,
+  "梗": 2040,
+  "５": 2041,
+  "垷": 2042,
+  "麒": 2043,
+  "麟": 2044,
+  "陀": 2045,
+  "習": 2046,
+  "写": 2047,
+  "討": 2048,
+  "碧": 2049,
+  "勬": 2050,
+  "榛": 2051,
+  "姑": 2052,
+  "娅": 2053,
+  "僧": 2054,
+  "哇": 2055,
+  "踏": 2056,
+  "旦": 2057,
+  "儶": 2058,
+  "哲": 2059,
+  "⁉": 2060,
+  "袦": 2061,
+  "播": 2062,
+  "易": 2063,
+  "抄": 2064,
+  "升": 2065,
+  "節": 2066,
+  "伙": 2067,
+  "勪": 2068,
+  "ó": 2069,
+  "勮": 2070,
+  "傜": 2071,
+  "辣": 2072,
+  "搬": 2073,
+  "継": 2074,
+  "准": 2075,
+  "円": 2076,
+  "证": 2077,
+  "嬢": 2078,
+  "腐": 2079,
+  "付": 2080,
+  "薇": 2081,
+  "眷": 2082,
+  "畜": 2083,
+  "爵": 2084,
+  "便": 2085,
+  "庨": 2086,
+  "鍦": 2087,
+  "梾": 2088,
+  "脚": 2089,
+  "途": 2090,
+  "驰": 2091,
+  "黎": 2092,
+  "迪": 2093,
+  "革": 2094,
+  "慎": 2095,
+  "染": 2096,
+  "頃": 2097,
+  "鹅": 2098,
+  "賢": 2099,
+  "插": 2100,
+  "早": 2101,
+  "鎭": 2102,
+  "冨": 2103,
+  "闆": 2104,
+  "尋": 2105,
+  "鵑": 2106,
+  "箷": 2107,
+  "控": 2108,
+  "蛇": 2109,
+  "吾": 2110,
+  "溅": 2111,
+  "没": 2112,
+  "呆": 2113,
+  "吀": 2114,
+  "引": 2115,
+  "厨": 2116,
+  "傑": 2117,
+  "豆": 2118,
+  "ö": 2119,
+  "锦": 2120,
+  "袧": 2121,
+  "又": 2122,
+  "统": 2123,
+  "紶": 2124,
+  "嬩": 2125,
+  "嶈": 2126,
+  "展": 2127,
+  "屬": 2128,
+  "否": 2129,
+  "烏": 2130,
+  "♯": 2131,
+  "и": 2132,
+  "左": 2133,
+  "鈥": 2134,
+  "鎷": 2135,
+  "敓": 2136,
+  "藥": 2137,
+  "┖": 2138,
+  "姣": 2139,
+  "拔": 2140,
+  "娃": 2141,
+  "般": 2142,
+  "遗": 2143,
+  "婕": 2144,
+  "預": 2145,
+  "折": 2146,
+  "概": 2147,
+  "差": 2148,
+  "怕": 2149,
+  "谁": 2150,
+  "模": 2151,
+  "蝶": 2152,
+  "溫": 2153,
+  "害": 2154,
+  "椼": 2155,
+  "夺": 2156,
+  "潜": 2157,
+  "蔵": 2158,
+  "泡": 2159,
+  "→": 2160,
+  "｜": 2161,
+  "凍": 2162,
+  "의": 2163,
+  "覇": 2164,
+  "涚": 2165,
+  "难": 2166,
+  "兆": 2167,
+  "位": 2168,
+  "頂": 2169,
+  "陆": 2170,
+  "雾": 2171,
+  "肝": 2172,
+  "抜": 2173,
+  "辽": 2174,
+  "ぴ": 2175,
+  "岩": 2176,
+  "紗": 2177,
+  "墍": 2178,
+  "珂": 2179,
+  "湅": 2180,
+  "獲": 2181,
+  "樣": 2182,
+  "乎": 2183,
+  "鑸": 2184,
+  "绑": 2185,
+  "离": 2186,
+  "悆": 2187,
+  "呮": 2188,
+  "悎": 2189,
+  "诗": 2190,
+  "疯": 2191,
+  "摵": 2192,
+  "祫": 2193,
+  "緊": 2194,
+  "際": 2195,
+  " ": 2196,
+  "耀": 2197,
+  "澜": 2198,
+  "溯": 2199,
+  "視": 2200,
+  "衍": 2201,
+  "炶": 2202,
+  "†": 2203,
+  "岚": 2204,
+  "鍋": 2205,
+  "沢": 2206,
+  "钱": 2207,
+  "柉": 2208,
+  "犻": 2209,
+  "邁": 2210,
+  "凶": 2211,
+  "滑": 2212,
+  "斩": 2213,
+  "投": 2214,
+  "=": 2215,
+  "堀": 2216,
+  "畅": 2217,
+  "ヱ": 2218,
+  "勉": 2219,
+  "呴": 2220,
+  "係": 2221,
+  "纱": 2222,
+  "咖": 2223,
+  "障": 2224,
+  "腿": 2225,
+  "勭": 2226,
+  "摸": 2227,
+  "沉": 2228,
+  "癒": 2229,
+  "糞": 2230,
+  "緣": 2231,
+  "缇": 2232,
+  "網": 2233,
+  "务": 2234,
+  "谈": 2235,
+  "择": 2236,
+  "弓": 2237,
+  "绲": 2238,
+  "札": 2239,
+  "唄": 2240,
+  "赐": 2241,
+  "欴": 2242,
+  "堬": 2243,
+  "７": 2244,
+  "Ζ": 2245,
+  "鄰": 2246,
+  "瑗": 2247,
+  "椿": 2248,
+  "鍘": 2249,
+  "織": 2250,
+  "默": 2251,
+  "寶": 2252,
+  "隨": 2253,
+  "撿": 2254,
+  "查": 2255,
+  "试": 2256,
+  "症": 2257,
+  "归": 2258,
+  "处": 2259,
+  "哉": 2260,
+  "収": 2261,
+  "衝": 2262,
+  "辈": 2263,
+  "納": 2264,
+  "背": 2265,
+  "簮": 2266,
+  "隠": 2267,
+  "偣": 2268,
+  "衰": 2269,
+  "容": 2270,
+  "端": 2271,
+  "微": 2272,
+  "枫": 2273,
+  "悼": 2274,
+  "仔": 2275,
+  "╁": 2276,
+  "呭": 2277,
+  "昂": 2278,
+  "胆": 2279,
+  "旧": 2280,
+  "忧": 2281,
+  "研": 2282,
+  "霧": 2283,
+  "讲": 2284,
+  "牛": 2285,
+  "核": 2286,
+  "μ": 2287,
+  "茶": 2288,
+  "乗": 2289,
+  "＊": 2290,
+  "嶅": 2291,
+  "丝": 2292,
+  "捉": 2293,
+  "棺": 2294,
+  "穿": 2295,
+  "丘": 2296,
+  "毁": 2297,
+  "宴": 2298,
+  "奖": 2299,
+  "整": 2300,
+  "艇": 2301,
+  "叛": 2302,
+  "準": 2303,
+  "窟": 2304,
+  "段": 2305,
+  "艾": 2306,
+  "弥": 2307,
+  "厄": 2308,
+  "絕": 2309,
+  "槸": 2310,
+  "沒": 2311,
+  "隱": 2312,
+  "夥": 2313,
+  "扭": 2314,
+  "紫": 2315,
+  "雏": 2316,
+  "静": 2317,
+  "痛": 2318,
+  "晖": 2319,
+  "軌": 2320,
+  "符": 2321,
+  "黙": 2322,
+  "震": 2323,
+  "拟": 2324,
+  "⁄": 2325,
+  "鑽": 2326,
+  "囬": 2327,
+  "凰": 2328,
+  "淵": 2329,
+  "侊": 2330,
+  "奔": 2331,
+  "捏": 2332,
+  "佬": 2333,
+  "报": 2334,
+  "介": 2335,
+  "呂": 2336,
+  "祈": 2337,
+  "敾": 2338,
+  "袖": 2339,
+  "塚": 2340,
+  "败": 2341,
+  "伽": 2342,
+  "悬": 2343,
+  "潰": 2344,
+  "午": 2345,
+  "嗎": 2346,
+  "摆": 2347,
+  "濡": 2348,
+  "烤": 2349,
+  "玛": 2350,
+  "泊": 2351,
+  "適": 2352,
+  "爺": 2353,
+  "适": 2354,
+  "掌": 2355,
+  "毎": 2356,
+  "缩": 2357,
+  "災": 2358,
+  "с": 2359,
+  "钢": 2360,
+  "扎": 2361,
+  "朱": 2362,
+  "検": 2363,
+  "蒂": 2364,
+  "区": 2365,
+  "潮": 2366,
+  "伓": 2367,
+  "壒": 2368,
+  "斾": 2369,
+  "健": 2370,
+  "笺": 2371,
+  "–": 2372,
+  "蘇": 2373,
+  "还": 2374,
+  "鐙": 2375,
+  "挨": 2376,
+  "碍": 2377,
+  "鍝": 2378,
+  "舵": 2379,
+  "︽": 2380,
+  "瓢": 2381,
+  "哃": 2382,
+  "隶": 2383,
+  "癖": 2384,
+  "庶": 2385,
+  "緒": 2386,
+  "郷": 2387,
+  "憑": 2388,
+  "憧": 2389,
+  "經": 2390,
+  "峰": 2391,
+  "撲": 2392,
+  "鍊": 2393,
+  "抗": 2394,
+  "航": 2395,
+  "媽": 2396,
+  "嘆": 2397,
+  "凯": 2398,
+  "②": 2399,
+  "构": 2400,
+  "焼": 2401,
+  "挙": 2402,
+  "栖": 2403,
+  "煶": 2404,
+  "參": 2405,
+  "届": 2406,
+  "功": 2407,
+  "興": 2408,
+  "調": 2409,
+  "培": 2410,
+  "盡": 2411,
+  "鹿": 2412,
+  "悩": 2413,
+  "翠": 2414,
+  "裁": 2415,
+  "辞": 2416,
+  "卷": 2417,
+  "犵": 2418,
+  "鞠": 2419,
+  "仆": 2420,
+  "櫧": 2421,
+  "애": 2422,
+  "니": 2423,
+  "제": 2424,
+  "閒": 2425,
+  "農": 2426,
+  "渣": 2427,
+  "戶": 2428,
+  "統": 2429,
+  "炲": 2430,
+  "艂": 2431,
+  "鍗": 2432,
+  "‧": 2433,
+  "浴": 2434,
+  "泥": 2435,
+  "绔": 2436,
+  "飘": 2437,
+  "绶": 2438,
+  "聚": 2439,
+  "实": 2440,
+  "程": 2441,
+  "庵": 2442,
+  "張": 2443,
+  "熟": 2444,
+  "魅": 2445,
+  "忛": 2446,
+  "曠": 2447,
+  "骄": 2448,
+  "^": 2449,
+  "槌": 2450,
+  "祦": 2451,
+  "‼": 2452,
+  "坑": 2453,
+  "宽": 2454,
+  "笁": 2455,
+  "厭": 2456,
+  "怎": 2457,
+  "設": 2458,
+  "稻": 2459,
+  "贸": 2460,
+  "擁": 2461,
+  "鎺": 2462,
+  "貳": 2463,
+  "屻": 2464,
+  "邊": 2465,
+  "粵": 2466,
+  "況": 2467,
+  "淋": 2468,
+  "钟": 2469,
+  "涂": 2470,
+  "鸦": 2471,
+  "驚": 2472,
+  "豹": 2473,
+  "＃": 2474,
+  "蟬": 2475,
+  "燂": 2476,
+  "偗": 2477,
+  "嶃": 2478,
+  "塑": 2479,
+  "偦": 2480,
+  "偝": 2481,
+  "崱": 2482,
+  "池": 2483,
+  "勒": 2484,
+  "©": 2485,
+  "僚": 2486,
+  "卞": 2487,
+  "赖": 2488,
+  "扉": 2489,
+  "傲": 2490,
+  "您": 2491,
+  "煤": 2492,
+  "及": 2493,
+  "涗": 2494,
+  "堝": 2495,
+  "愁": 2496,
+  "豬": 2497,
+  "覺": 2498,
+  "療": 2499,
+  "憎": 2500,
+  "鑑": 2501,
+  "骚": 2502,
+  "象": 2503,
+  "楝": 2504,
+  "卓": 2505,
+  "擬": 2506,
+  "睡": 2507,
+  "蹲": 2508,
+  "糟": 2509,
+  "贰": 2510,
+  "阔": 2511,
+  "卖": 2512,
+  "３": 2513,
+  "贈": 2514,
+  "戻": 2515,
+  "飼": 2516,
+  "駄": 2517,
+  "畳": 2518,
+  "脙": 2519,
+  "类": 2520,
+  "數": 2521,
+  "即": 2522,
+  "势": 2523,
+  "濆": 2524,
+  "枕": 2525,
+  "滾": 2526,
+  "凤": 2527,
+  "纸": 2528,
+  "阱": 2529,
+  "须": 2530,
+  "浮": 2531,
+  "授": 2532,
+  "侣": 2533,
+  "请": 2534,
+  "歄": 2535,
+  "堢": 2536,
+  "笉": 2537,
+  "祓": 2538,
+  "籠": 2539,
+  "遙": 2540,
+  "鸠": 2541,
+  "楱": 2542,
+  "壬": 2543,
+  "隸": 2544,
+  "恩": 2545,
+  "哪": 2546,
+  "亮": 2547,
+  "霉": 2548,
+  "畤": 2549,
+  "爛": 2550,
+  "葱": 2551,
+  "诱": 2552,
+  "懒": 2553,
+  "讀": 2554,
+  "脅": 2555,
+  "Ｖ": 2556,
+  "庞": 2557,
+  "效": 2558,
+  "鍕": 2559,
+  "经": 2560,
+  "留": 2561,
+  "鐚": 2562,
+  "隷": 2563,
+  "坊": 2564,
+  "芯": 2565,
+  "蒐": 2566,
+  "委": 2567,
+  "어": 2568,
+  "碎": 2569,
+  "驗": 2570,
+  "姏": 2571,
+  "犳": 2572,
+  "帇": 2573,
+  "鍚": 2574,
+  "噸": 2575,
+  "娲": 2576,
+  "嬮": 2577,
+  "岄": 2578,
+  "称": 2579,
+  "捡": 2580,
+  "Ⅶ": 2581,
+  "嶇": 2582,
+  "困": 2583,
+  "鴨": 2584,
+  "课": 2585,
+  "窝": 2586,
+  "陵": 2587,
+  "玲": 2588,
+  "操": 2589,
+  "茜": 2590,
+  "捨": 2591,
+  "慢": 2592,
+  "缚": 2593,
+  "催": 2594,
+  "歐": 2595,
+  "栄": 2596,
+  "套": 2597,
+  "猩": 2598,
+  "歳": 2599,
+  "鍵": 2600,
+  "砲": 2601,
+  "己": 2602,
+  "偤": 2603,
+  "兴": 2604,
+  "湘": 2605,
+  "致": 2606,
+  "╀": 2607,
+  "í": 2608,
+  "囪": 2609,
+  "廣": 2610,
+  "俄": 2611,
+  "属": 2612,
+  "莫": 2613,
+  "笘": 2614,
+  "验": 2615,
+  "論": 2616,
+  "譯": 2617,
+  "愚": 2618,
+  "郁": 2619,
+  "炸": 2620,
+  "商": 2621,
+  "啲": 2622,
+  "總": 2623,
+  "瓧": 2624,
+  "備": 2625,
+  "贴": 2626,
+  "磩": 2627,
+  "笼": 2628,
+  "袙": 2629,
+  "ū": 2630,
+  "楠": 2631,
+  "柴": 2632,
+  "崇": 2633,
+  "些": 2634,
+  "漠": 2635,
+  "置": 2636,
+  "骇": 2637,
+  "簹": 2638,
+  "冪": 2639,
+  "‐": 2640,
+  "傘": 2641,
+  "跟": 2642,
+  "偷": 2643,
+  "诺": 2644,
+  "曾": 2645,
+  "楼": 2646,
+  "碰": 2647,
+  "洗": 2648,
+  "户": 2649,
+  "钘": 2650,
+  "込": 2651,
+  "顶": 2652,
+  "楔": 2653,
+  "融": 2654,
+  "値": 2655,
+  "殖": 2656,
+  "憩": 2657,
+  "е": 2658,
+  "µ": 2659,
+  "繪": 2660,
+  "″": 2661,
+  "判": 2662,
+  "薔": 2663,
+  "琉": 2664,
+  "ㄧ": 2665,
+  "杩": 2666,
+  "闈": 2667,
+  "刔": 2668,
+  "距": 2669,
+  "貝": 2670,
+  "盃": 2671,
+  "触": 2672,
+  "玻": 2673,
+  "孙": 2674,
+  "柑": 2675,
+  "煮": 2676,
+  "薩": 2677,
+  "殭": 2678,
+  "捜": 2679,
+  "瀞": 2680,
+  "减": 2681,
+  "鈽": 2682,
+  "•": 2683,
+  "桑": 2684,
+  "穴": 2685,
+  " ": 2686,
+  "飙": 2687,
+  "泪": 2688,
+  "柔": 2689,
+  "á": 2690,
+  "隐": 2691,
+  "＄": 2692,
+  "虽": 2693,
+  "停": 2694,
+  "麥": 2695,
+  "测": 2696,
+  "沌": 2697,
+  "淘": 2698,
+  "匙": 2699,
+  "盛": 2700,
+  "掛": 2701,
+  "褰": 2702,
+  "妄": 2703,
+  "檚": 2704,
+  "词": 2705,
+  "菲": 2706,
+  "咆": 2707,
+  "伎": 2708,
+  "尻": 2709,
+  "喧": 2710,
+  "剃": 2711,
+  "夛": 2712,
+  "囩": 2713,
+  "劫": 2714,
+  "児": 2715,
+  "␣": 2716,
+  "均": 2717,
+  "?": 2718,
+  "啡": 2719,
+  "隻": 2720,
+  "편": 2721,
+  "拷": 2722,
+  "妳": 2723,
+  "昼": 2724,
+  "绿": 2725,
+  "链": 2726,
+  "湼": 2727,
+  "¿": 2728,
+  "谱": 2729,
+  "忓": 2730,
+  "屼": 2731,
+  "嚜": 2732,
+  "暒": 2733,
+  "瑪": 2734,
+  "偆": 2735,
+  "裤": 2736,
+  "鹤": 2737,
+  "蜻": 2738,
+  "鸡": 2739,
+  "附": 2740,
+  "肢": 2741,
+  "琥": 2742,
+  "珀": 2743,
+  "烙": 2744,
+  "婦": 2745,
+  "继": 2746,
+  "卵": 2747,
+  "薄": 2748,
+  "几": 2749,
+  "繰": 2750,
+  "扑": 2751,
+  "尤": 2752,
+  "履": 2753,
+  "한": 2754,
+  "완": 2755,
+  "逛": 2756,
+  "慄": 2757,
+  "胸": 2758,
+  "穗": 2759,
+  "环": 2760,
+  "姝": 2761,
+  "寰": 2762,
+  "庣": 2763,
+  "绱": 2764,
+  "莎": 2765,
+  "训": 2766,
+  "州": 2767,
+  "诡": 2768,
+  "瀬": 2769,
+  "洸": 2770,
+  "哮": 2771,
+  "讚": 2772,
+  "紞": 2773,
+  "К": 2774,
+  "敱": 2775,
+  "丶": 2776,
+  "惠": 2777,
+  "賀": 2778,
+  "綺": 2779,
+  "剋": 2780,
+  "溺": 2781,
+  "兩": 2782,
+  "側": 2783,
+  "鎵": 2784,
+  "伯": 2785,
+  "读": 2786,
+  "姜": 2787,
+  "导": 2788,
+  "斁": 2789,
+  "羞": 2790,
+  "倛": 2791,
+  "務": 2792,
+  "蕉": 2793,
+  "专": 2794,
+  "缥": 2795,
+  "缈": 2796,
+  "随": 2797,
+  "献": 2798,
+  "蠅": 2799,
+  "茸": 2800,
+  "処": 2801,
+  "囚": 2802,
+  "椂": 2803,
+  "逼": 2804,
+  "縁": 2805,
+  "拐": 2806,
+  "歂": 2807,
+  "漆": 2808,
+  "幡": 2809,
+  "桌": 2810,
+  "曇": 2811,
+  "須": 2812,
+  "証": 2813,
+  "谨": 2814,
+  "仓": 2815,
+  "ヂ": 2816,
+  "р": 2817,
+  "я": 2818,
+  "з": 2819,
+  "奉": 2820,
+  "더": 2821,
+  "결": 2822,
+  "援": 2823,
+  "弒": 2824,
+  "奧": 2825,
+  "努": 2826,
+  "椴": 2827,
+  "傚": 2828,
+  "捣": 2829,
+  "裝": 2830,
+  "绮": 2831,
+  "綻": 2832,
+  "彷": 2833,
+  "蛉": 2834,
+  "尘": 2835,
+  "壮": 2836,
+  "旗": 2837,
+  "質": 2838,
+  "査": 2839,
+  "萬": 2840,
+  "铏": 2841,
+  "鉱": 2842,
+  "①": 2843,
+  "鈴": 2844,
+  "妇": 2845,
+  "喂": 2846,
+  "葵": 2847,
+  "魍": 2848,
+  "鷲": 2849,
+  "津": 2850,
+  "ㆍ": 2851,
+  "ä": 2852,
+  "聆": 2853,
+  "隔": 2854,
+  "국": 2855,
+  "빙": 2856,
+  "扯": 2857,
+  "娣": 2858,
+  "歷": 2859,
+  "踊": 2860,
+  "產": 2861,
+  "锯": 2862,
+  "À": 2863,
+  "託": 2864,
+  "績": 2865,
+  "康": 2866,
+  "鍣": 2867,
+  "噗": 2868,
+  "撒": 2869,
+  "嗜": 2870,
+  "齊": 2871,
+  "避": 2872,
+  "娿": 2873,
+  "聯": 2874,
+  "喊": 2875,
+  "答": 2876,
+  "此": 2877,
+  "却": 2878,
+  "溂": 2879,
+  "垁": 2880,
+  "轻": 2881,
+  "麵": 2882,
+  "饶": 2883,
+  "喪": 2884,
+  "仏": 2885,
+  "汚": 2886,
+  "蜥": 2887,
+  "蜴": 2888,
+  "棰": 2889,
+  "ㄩ": 2890,
+  "移": 2891,
+  "懶": 2892,
+  "廏": 2893,
+  "許": 2894,
+  "磪": 2895,
+  "蛮": 2896,
+  "婢": 2897,
+  "湌": 2898,
+  "矒": 2899,
+  "檪": 2900,
+  "隇": 2901,
+  "塈": 2902,
+  "遣": 2903,
+  "Ｄ": 2904,
+  "Ｔ": 2905,
+  "､": 2906,
+  "洁": 2907,
+  "碼": 2908,
+  "识": 2909,
+  "♥": 2910,
+  "澄": 2911,
+  "涅": 2912,
+  "颜": 2913,
+  "旂": 2914,
+  "簨": 2915,
+  "拜": 2916,
+  "簡": 2917,
+  "懡": 2918,
+  "檺": 2919,
+  "寸": 2920,
+  "绌": 2921,
+  "屽": 2922,
+  "粖": 2923,
+  "栦": 2924,
+  "該": 2925,
+  "換": 2926,
+  "膽": 2927,
+  "黨": 2928,
+  "舊": 2929,
+  "卻": 2930,
+  "妃": 2931,
+  "懸": 2932,
+  "識": 2933,
+  "谋": 2934,
+  "柳": 2935,
+  "按": 2936,
+  "挿": 2937,
+  "躍": 2938,
+  "拯": 2939,
+  "鋸": 2940,
+  "删": 2941,
+  "欼": 2942,
+  "菊": 2943,
+  "魎": 2944,
+  "鎖": 2945,
+  "澗": 2946,
+  "杖": 2947,
+  "閮": 2948,
+  "鳳": 2949,
+  "顧": 2950,
+  "樻": 2951,
+  "猴": 2952,
+  "濠": 2953,
+  "阻": 2954,
+  "輔": 2955,
+  "憜": 2956,
+  "兓": 2957,
+  "戈": 2958,
+  "雖": 2959,
+  "��": 2960,
+  "优": 2961,
+  "墝": 2962,
+  "丟": 2963,
+  "抽": 2964,
+  "尟": 2965,
+  "緑": 2966,
+  "镖": 2967,
+  "桂": 2968,
+  "堛": 2969,
+  "墜": 2970,
+  "訣": 2971,
+  "辑": 2972,
+  "讓": 2973,
+  "腕": 2974,
+  "拖": 2975,
+  "偊": 2976,
+  "湥": 2977,
+  "ⅵ": 2978,
+  "峂": 2979,
+  "胄": 2980,
+  "哛": 2981,
+  "俗": 2982,
+  "亭": 2983,
+  "婭": 2984,
+  "壱": 2985,
+  "膏": 2986,
+  "å": 2987,
+  "曙": 2988,
+  "巌": 2989,
+  "姿": 2990,
+  "雛": 2991,
+  "凛": 2992,
+  "ō": 2993,
+  "遲": 2994,
+  "渡": 2995,
+  "鍑": 2996,
+  "忥": 2997,
+  "鏂": 2998,
+  "橀": 2999,
+  "㈠": 3000,
+  "′": 3001,
+  "或": 3002,
+  "媇": 3003,
+  "央": 3004,
+  "鞋": 3005,
+  "●": 3006,
+  "拶": 3007,
+  "憬": 3008,
+  "访": 3009,
+  "辭": 3010,
+  "氱": 3011,
+  "賞": 3012,
+  "鏽": 3013,
+  "償": 3014,
+  "贾": 3015,
+  "埍": 3016,
+  "棬": 3017,
+  "毚": 3018,
+  "掑": 3019,
+  "悕": 3020,
+  "誇": 3021,
+  "敷": 3022,
+  "熾": 3023,
+  "暖": 3024,
+  "楓": 3025,
+  "環": 3026,
+  "憾": 3027,
+  "买": 3028,
+  "论": 3029,
+  "闂": 3030,
+  "腑": 3031,
+  "灞": 3032,
+  "墨": 3033,
+  "暑": 3034,
+  "诅": 3035,
+  "鐪": 3036,
+  "儔": 3037,
+  "堡": 3038,
+  "鐒": 3039,
+  "繚": 3040,
+  "棋": 3041,
+  "眈": 3042,
+  "柱": 3043,
+  "鎲": 3044,
+  "ф": 3045,
+  "買": 3046,
+  "悔": 3047,
+  "哭": 3048,
+  "帕": 3049,
+  "乘": 3050,
+  "蓋": 3051,
+  "胶": 3052,
+  "週": 3053,
+  "貼": 3054,
+  "牲": 3055,
+  "阪": 3056,
+  "净": 3057,
+  "纷": 3058,
+  "贤": 3059,
+  "熼": 3060,
+  "宸": 3061,
+  "藉": 3062,
+  "鏁": 3063,
+  "句": 3064,
+  "醜": 3065,
+  "逝": 3066,
+  "众": 3067,
+  "絲": 3068,
+  "调": 3069,
+  "咕": 3070,
+  "维": 3071,
+  "訊": 3072,
+  "质": 3073,
+  "戴": 3074,
+  "闯": 3075,
+  "馁": 3076,
+  "产": 3077,
+  "滈": 3078,
+  "祽": 3079,
+  "咺": 3080,
+  "紳": 3081,
+  "册": 3082,
+  "虐": 3083,
+  "廳": 3084,
+  "呢": 3085,
+  "兇": 3086,
+  "舌": 3087,
+  "吠": 3088,
+  "à": 3089,
+  "垂": 3090,
+  "鐣": 3091,
+  "垬": 3092,
+  "湪": 3093,
+  "ぉ": 3094,
+  "蹇": 3095,
+  "請": 3096,
+  "材": 3097,
+  "帮": 3098,
+  "建": 3099,
+  "層": 3100,
+  "唇": 3101,
+  "矇": 3102,
+  "仺": 3103,
+  "汗": 3104,
+  "互": 3105,
+  "靦": 3106,
+  "腆": 3107,
+  "凱": 3108,
+  "頼": 3109,
+  "炭": 3110,
+  "誠": 3111,
+  "竞": 3112,
+  "窮": 3113,
+  "灉": 3114,
+  "匹": 3115,
+  "Ｏ": 3116,
+  "蛙": 3117,
+  "欒": 3118,
+  "糸": 3119,
+  "恵": 3120,
+  "傻": 3121,
+  "岐": 3122,
+  "痕": 3123,
+  "崛": 3124,
+  "蟻": 3125,
+  "絢": 3126,
+  "∀": 3127,
+  "囝": 3128,
+  "暮": 3129,
+  "夊": 3130,
+  "梯": 3131,
+  "è": 3132,
+  "皵": 3133,
+  "﹀": 3134,
+  "浗": 3135,
+  "绡": 3136,
+  "誼": 3137,
+  "栗": 3138,
+  "张": 3139,
+  "囊": 3140,
+  "固": 3141,
+  "寂": 3142,
+  "邻": 3143,
+  "诀": 3144,
+  "块": 3145,
+  "嗚": 3146,
+  "揺": 3147,
+  "綾": 3148,
+  "脸": 3149,
+  "盒": 3150,
+  "掘": 3151,
+  "洓": 3152,
+  "箣": 3153,
+  "迈": 3154,
+  "栧": 3155,
+  "僵": 3156,
+  "③": 3157,
+  "蝎": 3158,
+  "４": 3159,
+  "澧": 3160,
+  "Ⅹ": 3161,
+  "嘩": 3162,
+  "蒲": 3163,
+  "昔": 3164,
+  "Ｆ": 3165,
+  "副": 3166,
+  "错": 3167,
+  "胁": 3168,
+  "备": 3169,
+  "雑": 3170,
+  "誉": 3171,
+  "昴": 3172,
+  "芝": 3173,
+  "圖": 3174,
+  "擾": 3175,
+  "도": 3176,
+  "撮": 3177,
+  "寝": 3178,
+  "脫": 3179,
+  "畬": 3180,
+  "祕": 3181,
+  "丑": 3182,
+  "﹁": 3183,
+  "摑": 3184,
+  "佷": 3185,
+  "嘴": 3186,
+  "嗶": 3187,
+  "踢": 3188,
+  "蠢": 3189,
+  "恼": 3190,
+  "℃": 3191,
+  "尯": 3192,
+  "瑟": 3193,
+  "峡": 3194,
+  "剪": 3195,
+  "娇": 3196,
+  "股": 3197,
+  "薫": 3198,
+  "咰": 3199,
+  "赏": 3200,
+  "侍": 3201,
+  "冈": 3202,
+  "嚫": 3203,
+  "贩": 3204,
+  "剛": 3205,
+  "蕩": 3206,
+  "巡": 3207,
+  "昌": 3208,
+  "嬌": 3209,
+  "瘽": 3210,
+  "墿": 3211,
+  "儖": 3212,
+  "掓": 3213,
+  "槬": 3214,
+  "忠": 3215,
+  "欠": 3216,
+  "暇": 3217,
+  "産": 3218,
+  "鮮": 3219,
+  "覆": 3220,
+  "寲": 3221,
+  "診": 3222,
+  "鐘": 3223,
+  "愤": 3224,
+  "惰": 3225,
+  "亀": 3226,
+  "刘": 3227,
+  "０": 3228,
+  "铳": 3229,
+  "邸": 3230,
+  "犧": 3231,
+  "湴": 3232,
+  "赌": 3233,
+  "沖": 3234,
+  "両": 3235,
+  "愉": 3236,
+  "※": 3237,
+  "惱": 3238,
+  "滴": 3239,
+  "呯": 3240,
+  "楦": 3241,
+  "鸿": 3242,
+  "垫": 3243,
+  "渤": 3244,
+  "貫": 3245,
+  "俱": 3246,
+  "薰": 3247,
+  "毀": 3248,
+  "笂": 3249,
+  "仯": 3250,
+  "岸": 3251,
+  "寵": 3252,
+  "涘": 3253,
+  "嗐": 3254,
+  "鈾": 3255,
+  "猐": 3256,
+  "楃": 3257,
+  "紧": 3258,
+  "瓜": 3259,
+  "羡": 3260,
+  "紹": 3261,
+  "娉": 3262,
+  "拂": 3263,
+  "佛": 3264,
+  "液": 3265,
+  "頑": 3266,
+  "稀": 3267,
+  "晓": 3268,
+  "濞": 3269,
+  "濊": 3270,
+  "钃": 3271,
+  "ｆ": 3272,
+  "淽": 3273,
+  "â": 3274,
+  "挖": 3275,
+  "欺": 3276,
+  "帶": 3277,
+  "禦": 3278,
+  "睛": 3279,
+  "掕": 3280,
+  "氭": 3281,
+  "濅": 3282,
+  "挡": 3283,
+  "淇": 3284,
+  "斻": 3285,
+  "昇": 3286,
+  "润": 3287,
+  "仰": 3288,
+  "閉": 3289,
+  "煙": 3290,
+  "蒸": 3291,
+  "囨": 3292,
+  "洲": 3293,
+  "頓": 3294,
+  "窓": 3295,
+  "怠": 3296,
+  "祥": 3297,
+  "荻": 3298,
+  "坪": 3299,
+  "痴": 3300,
+  "擇": 3301,
+  "장": 3302,
+  "판": 3303,
+  "绽": 3304,
+  "皆": 3305,
+  "掟": 3306,
+  "恨": 3307,
+  "壇": 3308,
+  "硬": 3309,
+  "递": 3310,
+  "ú": 3311,
+  "颁": 3312,
+  "綋": 3313,
+  "ч": 3314,
+  "庝": 3315,
+  "箟": 3316,
+  "璇": 3317,
+  "嬭": 3318,
+  "伸": 3319,
+  "駅": 3320,
+  "炴": 3321,
+  "佳": 3322,
+  "陛": 3323,
+  "彲": 3324,
+  "読": 3325,
+  "综": 3326,
+  "幇": 3327,
+  "帥": 3328,
+  "堤": 3329,
+  "斷": 3330,
+  "柚": 3331,
+  "割": 3332,
+  "绂": 3333,
+  "戍": 3334,
+  "燎": 3335,
+  "構": 3336,
+  "慧": 3337,
+  "愬": 3338,
+  "倍": 3339,
+  "扇": 3340,
+  "骷": 3341,
+  "ｇ": 3342,
+  "崉": 3343,
+  "槍": 3344,
+  "芸": 3345,
+  "蒙": 3346,
+  "鑱": 3347,
+  "余": 3348,
+  "嚎": 3349,
+  "綍": 3350,
+  "靴": 3351,
+  "滆": 3352,
+  "潐": 3353,
+  "螃": 3354,
+  "咃": 3355,
+  "窻": 3356,
+  "鍨": 3357,
+  "溇": 3358,
+  "檽": 3359,
+  "爪": 3360,
+  "细": 3361,
+  "吐": 3362,
+  "Ｗ": 3363,
+  "Ⅷ": 3364,
+  "督": 3365,
+  "糫": 3366,
+  "迦": 3367,
+  "ē": 3368,
+  "绅": 3369,
+  "轟": 3370,
+  "姮": 3371,
+  "醉": 3372,
+  "偅": 3373,
+  "顾": 3374,
+  "澤": 3375,
+  "応": 3376,
+  "髮": 3377,
+  "逸": 3378,
+  "欽": 3379,
+  "蘑": 3380,
+  "啪": 3381,
+  "夌": 3382,
+  "臋": 3383,
+  "缺": 3384,
+  "荤": 3385,
+  "粠": 3386,
+  "洿": 3387,
+  "嶄": 3388,
+  "掔": 3389,
+  "瑕": 3390,
+  "鏋": 3391,
+  "纏": 3392,
+  "毫": 3393,
+  "姳": 3394,
+  "淑": 3395,
+  "遥": 3396,
+  "煎": 3397,
+  "匣": 3398,
+  "紡": 3399,
+  "废": 3400,
+  "蹄": 3401,
+  "垃": 3402,
+  "圾": 3403,
+  "閿": 3404,
+  "湡": 3405,
+  "愪": 3406,
+  "刹": 3407,
+  "應": 3408,
+  "鬧": 3409,
+  "謊": 3410,
+  "慶": 3411,
+  "漢": 3412,
+  "焉": 3413,
+  "钓": 3414,
+  "悗": 3415,
+  "髅": 3416,
+  "龟": 3417,
+  "伀": 3418,
+  "従": 3419,
+  "泰": 3420,
+  "岡": 3421,
+  "暂": 3422,
+  "李": 3423,
+  "斧": 3424,
+  "盷": 3425,
+  "皯": 3426,
+  "贡": 3427,
+  "鎿": 3428,
+  "簜": 3429,
+  "Ⅺ": 3430,
+  "滝": 3431,
+  "鯉": 3432,
+  "狸": 3433,
+  "噢": 3434,
+  "澡": 3435,
+  "弗": 3436,
+  "疆": 3437,
+  "岳": 3438,
+  "轩": 3439,
+  "아": 3440,
+  "堅": 3441,
+  "宏": 3442,
+  "綘": 3443,
+  "椤": 3444,
+  "娑": 3445,
+  "谩": 3446,
+  "檻": 3447,
+  "缤": 3448,
+  "鐞": 3449,
+  "埌": 3450,
+  "垮": 3451,
+  "潃": 3452,
+  "弻": 3453,
+  "鎸": 3454,
+  "洖": 3455,
+  "娆": 3456,
+  "姘": 3457,
+  "票": 3458,
+  "倞": 3459,
+  "忎": 3460,
+  "枃": 3461,
+  "氦": 3462,
+  "嬰": 3463,
+  "抢": 3464,
+  "綠": 3465,
+  "縫": 3466,
+  "仱": 3467,
+  "戙": 3468,
+  "臂": 3469,
+  "悶": 3470,
+  "瑛": 3471,
+  "赘": 3472,
+  "婿": 3473,
+  "輕": 3474,
+  "抚": 3475,
+  "渴": 3476,
+  "娶": 3477,
+  "瑾": 3478,
+  "樋": 3479,
+  "晩": 3480,
+  "簯": 3481,
+  "戜": 3482,
+  "徨": 3483,
+  "贺": 3484,
+  "Ｇ": 3485,
+  "階": 3486,
+  "凸": 3487,
+  "廟": 3488,
+  "暉": 3489,
+  "傭": 3490,
+  "爭": 3491,
+  "稚": 3492,
+  "沼": 3493,
+  "鄉": 3494,
+  "翰": 3495,
+  "善": 3496,
+  "夠": 3497,
+  "泧": 3498,
+  "瓨": 3499,
+  "循": 3500,
+  "歴": 3501,
+  "瑞": 3502,
+  "郊": 3503,
+  "采": 3504,
+  "紐": 3505,
+  "権": 3506,
+  "罚": 3507,
+  "麦": 3508,
+  "貨": 3509,
+  "狭": 3510,
+  "晃": 3511,
+  "墅": 3512,
+  "袥": 3513,
+  "Φ": 3514,
+  "裙": 3515,
+  "鑷": 3516,
+  "矛": 3517,
+  "菇": 3518,
+  "顿": 3519,
+  "喷": 3520,
+  "緱": 3521,
+  "涎": 3522,
+  "闹": 3523,
+  "趣": 3524,
+  "э": 3525,
+  "鐤": 3526,
+  "绾": 3527,
+  "篯": 3528,
+  "掍": 3529,
+  "╂": 3530,
+  "濮": 3531,
+  "採": 3532,
+  "儀": 3533,
+  "廷": 3534,
+  "伄": 3535,
+  "畾": 3536,
+  "費": 3537,
+  "繋": 3538,
+  "ㄣ": 3539,
+  "賣": 3540,
+  "暟": 3541,
+  "剎": 3542,
+  "檸": 3543,
+  "繩": 3544,
+  "嫄": 3545,
+  "鈬": 3546,
+  "憡": 3547,
+  "瘦": 3548,
+  "烟": 3549,
+  "沐": 3550,
+  "乡": 3551,
+  "狀": 3552,
+  "蹂": 3553,
+  "悓": 3554,
+  "诉": 3555,
+  "府": 3556,
+  "碗": 3557,
+  "檼": 3558,
+  "荣": 3559,
+  "啟": 3560,
+  "觸": 3561,
+  "娓": 3562,
+  "侯": 3563,
+  "评": 3564,
+  "譜": 3565,
+  "♀": 3566,
+  "歀": 3567,
+  "堥": 3568,
+  "鑹": 3569,
+  "ω": 3570,
+  "馭": 3571,
+  "駕": 3572,
+  "傅": 3573,
+  "繘": 3574,
+  "掋": 3575,
+  "偓": 3576,
+  "谣": 3577,
+  "翁": 3578,
+  "摊": 3579,
+  "獅": 3580,
+  "埂": 3581,
+  "惢": 3582,
+  "鑾": 3583,
+  "楹": 3584,
+  "繼": 3585,
+  "廚": 3586,
+  "伞": 3587,
+  "亰": 3588,
+  "侶": 3589,
+  "锈": 3590,
+  "劧": 3591,
+  "禍": 3592,
+  "￠": 3593,
+  "弸": 3594,
+  "苺": 3595,
+  "畢": 3596,
+  "鐓": 3597,
+  "岭": 3598,
+  "嫾": 3599,
+  "喔": 3600,
+  "Ｓ": 3601,
+  "゛": 3602,
+  "描": 3603,
+  "歯": 3604,
+  "偍": 3605,
+  "偨": 3606,
+  "Ⅸ": 3607,
+  "奮": 3608,
+  "遂": 3609,
+  "*": 3610,
+  "帅": 3611,
+  "‥": 3612,
+  "嗛": 3613,
+  "肆": 3614,
+  "谕": 3615,
+  "袛": 3616,
+  "袗": 3617,
+  "ｎ": 3618,
+  "懺": 3619,
+  "溜": 3620,
+  "複": 3621,
+  "극": 3622,
+  "대": 3623,
+  "芹": 3624,
+  "傾": 3625,
+  "泛": 3626,
+  "态": 3627,
+  "呀": 3628,
+  "顯": 3629,
+  "岀": 3630,
+  "鑻": 3631,
+  "璧": 3632,
+  "賜": 3633,
+  "尗": 3634,
+  "箙": 3635,
+  "榉": 3636,
+  "帹": 3637,
+  "嗙": 3638,
+  "〃": 3639,
+  "柜": 3640,
+  "鼴": 3641,
+  "栥": 3642,
+  "禪": 3643,
+  "雜": 3644,
+  "櫃": 3645,
+  "檯": 3646,
+  "蹺": 3647,
+  "桿": 3648,
+  "倠": 3649,
+  "姓": 3650,
+  "吵": 3651,
+  "慕": 3652,
+  "箭": 3653,
+  "抓": 3654,
+  "吶": 3655,
+  "霜": 3656,
+  "滩": 3657,
+  "酬": 3658,
+  "躪": 3659,
+  "舔": 3660,
+  "棉": 3661,
+  "閰": 3662,
+  "蔚": 3663,
+  "脡": 3664,
+  "珮": 3665,
+  "呐": 3666,
+  "傢": 3667,
+  "资": 3668,
+  "墠": 3669,
+  "穆": 3670,
+  "凹": 3671,
+  "姗": 3672,
+  "儹": 3673,
+  "徘": 3674,
+  "徊": 3675,
+  "懷": 3676,
+  "另": 3677,
+  "弃": 3678,
+  "欰": 3679,
+  "崈": 3680,
+  "僱": 3681,
+  "押": 3682,
+  "枊": 3683,
+  "牸": 3684,
+  "搐": 3685,
+  "碨": 3686,
+  "竺": 3687,
+  "罰": 3688,
+  "勢": 3689,
+  "粌": 3690,
+  "剦": 3691,
+  "籟": 3692,
+  "睙": 3693,
+  "浂": 3694,
+  "彙": 3695,
+  "愈": 3696,
+  "證": 3697,
+  "θ": 3698,
+  "堣": 3699,
+  "敳": 3700,
+  "窔": 3701,
+  "垉": 3702,
+  "囷": 3703,
+  "厤": 3704,
+  "媛": 3705,
+  "牠": 3706,
+  "揚": 3707,
+  "汁": 3708,
+  "閸": 3709,
+  "瓑": 3710,
+  "皽": 3711,
+  "剚": 3712,
+  "搧": 3713,
+  "憺": 3714,
+  "墽": 3715,
+  "闁": 3716,
+  "枓": 3717,
+  "簩": 3718,
+  "嵉": 3719,
+  "悐": 3720,
+  "嗕": 3721,
+  "鐭": 3722,
+  "氨": 3723,
+  "ｅ": 3724,
+  "櫠": 3725,
+  "圧": 3726,
+  "斎": 3727,
+  "噴": 3728,
+  "巣": 3729,
+  "甸": 3730,
+  "绎": 3731,
+  "窗": 3732,
+  "隣": 3733,
+  "囃": 3734,
+  "蛾": 3735,
+  "凄": 3736,
+  "握": 3737,
+  "Θ": 3738,
+  "谐": 3739,
+  "鈼": 3740,
+  "嬧": 3741,
+  "棆": 3742,
+  "稷": 3743,
+  "鹏": 3744,
+  "哗": 3745,
+  "〇": 3746,
+  "淨": 3747,
+  "捐": 3748,
+  "齑": 3749,
+  "堧": 3750,
+  "嫟": 3751,
+  "毵": 3752,
+  "敼": 3753,
+  "棟": 3754,
+  "佩": 3755,
+  "倫": 3756,
+  "하": 3757,
+  "마": 3758,
+  "리": 3759,
+  "라": 3760,
+  "綱": 3761,
+  "枚": 3762,
+  "讯": 3763,
+  "鑺": 3764,
+  "ª": 3765,
+  "効": 3766,
+  "廃": 3767,
+  "巾": 3768,
+  "芒": 3769,
+  "滨": 3770,
+  "焦": 3771,
+  "橙": 3772,
+  "啸": 3773,
+  "蜀": 3774,
+  "矜": 3775,
+  "阵": 3776,
+  "哎": 3777,
+  "莊": 3778,
+  "输": 3779,
+  "欿": 3780,
+  "訶": 3781,
+  "歖": 3782,
+  "欣": 3783,
+  "针": 3784,
+  "帯": 3785,
+  "歸": 3786,
+  "竭": 3787,
+  "顕": 3788,
+  "规": 3789,
+  "伦": 3790,
+  "嘗": 3791,
+  "榮": 3792,
+  "渋": 3793,
+  "鴉": 3794,
+  "臺": 3795,
+  "湳": 3796,
+  "搁": 3797,
+  "涌": 3798,
+  "硝": 3799,
+  "８": 3800,
+  "９": 3801,
+  "贄": 3802,
+  "彦": 3803,
+  "偛": 3804,
+  "搷": 3805,
+  "ヶ": 3806,
+  "洪": 3807,
+  "妯": 3808,
+  "洟": 3809,
+  "坐": 3810,
+  "抹": 3811,
+  "浅": 3812,
+  "显": 3813,
+  "狮": 3814,
+  "肥": 3815,
+  "擦": 3816,
+  "歪": 3817,
+  "铸": 3818,
+  "α": 3819,
+  "执": 3820,
+  "棲": 3821,
+  "責": 3822,
+  "Ｂ": 3823,
+  "摤": 3824,
+  "彛": 3825,
+  "咬": 3826,
+  "祟": 3827,
+  "壹": 3828,
+  "惩": 3829,
+  "［": 3830,
+  "］": 3831,
+  "維": 3832,
+  "鎗": 3833,
+  "炬": 3834,
+  "跃": 3835,
+  "広": 3836,
+  "甯": 3837,
+  "隆": 3838,
+  "怨": 3839,
+  "╄": 3840,
+  "х": 3841,
+  "ｄ": 3842,
+  "嗗": 3843,
+  "朗": 3844,
+  "瓪": 3845,
+  "酥": 3846,
+  "璜": 3847,
+  "积": 3848,
+  "仿": 3849,
+  "庛": 3850,
+  "翅": 3851,
+  "漁": 3852,
+  "坠": 3853,
+  "阁": 3854,
+  "芳": 3855,
+  "浄": 3856,
+  "湿": 3857,
+  "爽": 3858,
+  "価": 3859,
+  "俑": 3860,
+  "殜": 3861,
+  "涛": 3862,
+  "劲": 3863,
+  "际": 3864,
+  "渦": 3865,
+  "測": 3866,
+  "免": 3867,
+  "裕": 3868,
+  "舎": 3869,
+  "峕": 3870,
+  "審": 3871,
+  "臣": 3872,
+  "摄": 3873,
+  "盘": 3874,
+  "湾": 3875,
+  "$": 3876,
+  "崖": 3877,
+  "偡": 3878,
+  "诚": 3879,
+  "薪": 3880,
+  "枯": 3881,
+  "赴": 3882,
+  "亿": 3883,
+  "肖": 3884,
+  "㊙": 3885,
+  "峠": 3886,
+  "獮": 3887,
+  "기": 3888,
+  "나": 3889,
+  "비": 3890,
+  "庆": 3891,
+  "閫": 3892,
+  "ǎ": 3893,
+  "宂": 3894,
+  "鹃": 3895,
+  "鎼": 3896,
+  "欐": 3897,
+  "婄": 3898,
+  "釜": 3899,
+  "熷": 3900,
+  "﹂": 3901,
+  "担": 3902,
+  "笀": 3903,
+  "绊": 3904,
+  "耐": 3905,
+  "扫": 3906,
+  "锅": 3907,
+  "锁": 3908,
+  "驾": 3909,
+  "斋": 3910,
+  "盤": 3911,
+  "媺": 3912,
+  "鑼": 3913,
+  "柊": 3914,
+  "憐": 3915,
+  "杏": 3916,
+  "县": 3917,
+  "葡": 3918,
+  "鼓": 3919,
+  "颠": 3920,
+  "規": 3921,
+  "ヅ": 3922,
+  "慌": 3923,
+  "鳩": 3924,
+  "怜": 3925,
+  "臓": 3926,
+  "猟": 3927,
+  "財": 3928,
+  "드": 3929,
+  "黖": 3930,
+  "瑭": 3931,
+  "珷": 3932,
+  "婊": 3933,
+  "啺": 3934,
+  "辱": 3935,
+  "购": 3936,
+  "增": 3937,
+  "铜": 3938,
+  "徽": 3939,
+  "严": 3940,
+  "Ｅ": 3941,
+  "衆": 3942,
+  "哟": 3943,
+  "污": 3944,
+  "Ｎ": 3945,
+  "ぅ": 3946,
+  "蜃": 3947,
+  "勿": 3948,
+  "謝": 3949,
+  "㈡": 3950,
+  "匪": 3951,
+  "磯": 3952,
+  "Á": 3953,
+  "É": 3954,
+  "遍": 3955,
+  "시": 3956,
+  "는": 3957,
+  "음": 3958,
+  "카": 3959,
+  "인": 3960,
+  "詞": 3961,
+  "货": 3962,
+  "饰": 3963,
+  "膰": 3964,
+  "膮": 3965,
+  "嶆": 3966,
+  "烘": 3967,
+  "戞": 3968,
+  "偀": 3969,
+  "婂": 3970,
+  "譲": 3971,
+  "畝": 3972,
+  "嚐": 3973,
+  "酸": 3974,
+  "榻": 3975,
+  "躲": 3976,
+  "汇": 3977,
+  "亸": 3978,
+  "层": 3979,
+  "冦": 3980,
+  "纹": 3981,
+  "矝": 3982,
+  "撼": 3983,
+  "埃": 3984,
+  "胡": 3985,
+  "烬": 3986,
+  "鞎": 3987,
+  "勲": 3988,
+  "薯": 3989,
+  "締": 3990,
+  "絮": 3991,
+  "灾": 3992,
+  "噩": 3993,
+  "吊": 3994,
+  "彗": 3995,
+  "慟": 3996,
+  "睇": 3997,
+  "认": 3998,
+  "吓": 3999,
+  "祷": 4000,
+  "怀": 4001,
+  "鴿": 4002,
+  "‖": 4003,
+  "鵺": 4004,
+  "裸": 4005,
+  "損": 4006,
+  "潚": 4007,
+  "牢": 4008,
+  "慈": 4009,
+  "漬": 4010,
+  "丼": 4011,
+  "坦": 4012,
+  "恥": 4013,
+  "累": 4014,
+  "皬": 4015,
+  "绳": 4016,
+  "駒": 4017,
+  "燒": 4018,
+  "拌": 4019,
+  "蛹": 4020,
+  "噂": 4021,
+  "栨": 4022,
+  "痪": 4023,
+  "∬": 4024,
+  "寓": 4025,
+  "锣": 4026,
+  "舒": 4027,
+  "检": 4028,
+  "碑": 4029,
+  "苹": 4030,
+  "榎": 4031,
+  "蛍": 4032,
+  "荷": 4033,
+  "贖": 4034,
+  "惹": 4035,
+  "脈": 4036,
+  "砦": 4037,
+  "薬": 4038,
+  "乳": 4039,
+  "飾": 4040,
+  "軽": 4041,
+  "遅": 4042,
+  "卑": 4043,
+  "疲": 4044,
+  "鶴": 4045,
+  "辺": 4046,
+  "叢": 4047,
+  "财": 4048,
+  "豊": 4049,
+  "叹": 4050,
+  "署": 4051,
+  "袞": 4052,
+  "Ｒ": 4053,
+  "ã": 4054,
+  "毬": 4055,
+  "​": 4056,
+  "淫": 4057,
+  "貪": 4058,
+  "牡": 4059,
+  "隼": 4060,
+  "陶": 4061,
+  "舍": 4062,
+  "审": 4063,
+  "绪": 4064,
+  "丢": 4065,
+  "椒": 4066,
+  "钂": 4067,
+  "劳": 4068,
+  "霞": 4069,
+  "鈪": 4070,
+  "仪": 4071,
+  "勩": 4072,
+  "涩": 4073,
+  "牵": 4074,
+  "汪": 4075,
+  "杉": 4076,
+  "蓓": 4077,
+  "扣": 4078,
+  "含": 4079,
+  "燕": 4080,
+  "楚": 4081,
+  "歓": 4082,
+  "办": 4083,
+  "嘛": 4084,
+  "钧": 4085,
+  "鸽": 4086,
+  "蚁": 4087,
+  "減": 4088,
+  "壳": 4089,
+  "偿": 4090,
+  "惜": 4091,
+  "稼": 4092,
+  "詰": 4093,
+  "④": 4094,
+  "圿": 4095,
+  "畑": 4096,
+  "並": 4097,
+  "券": 4098,
+  "惚": 4099,
+  "窯": 4100,
+  "盯": 4101,
+  "泲": 4102,
+  "省": 4103,
+  "墙": 4104,
+  "坚": 4105,
+  "骰": 4106,
+  "秤": 4107,
+  "紋": 4108,
+  "綿": 4109,
+  "虜": 4110,
+  "迅": 4111,
+  "奋": 4112,
+  "纽": 4113,
+  "敢": 4114,
+  "揭": 4115,
+  "菌": 4116,
+  "囲": 4117,
+  "鳞": 4118,
+  "齐": 4119,
+  "墟": 4120,
+  "酋": 4121,
+  "价": 4122,
+  "掃": 4123,
+  "袡": 4124,
+  "槽": 4125,
+  "茉": 4126,
+  "賴": 4127,
+  "瓣": 4128,
+  "를": 4129,
+  "성": 4130,
+  "락": 4131,
+  "루": 4132,
+  "구": 4133,
+  "모": 4134,
+  "정": 4135,
+  "지": 4136,
+  "鎽": 4137,
+  "淚": 4138,
+  "縄": 4139,
+  "拼": 4140,
+  "囦": 4141,
+  "粦": 4142,
+  "ü": 4143,
+  "緳": 4144,
+  "鎶": 4145,
+  "尝": 4146,
+  "绉": 4147,
+  "暱": 4148,
+  "婁": 4149,
+  "秺": 4150,
+  "㈣": 4151,
+  "璀": 4152,
+  "皝": 4153,
+  "嘳": 4154,
+  "搶": 4155,
+  "鍛": 4156,
+  "婃": 4157,
+  "竊": 4158,
+  "萤": 4159,
+  "份": 4160,
+  "兜": 4161,
+  "亱": 4162,
+  "仒": 4163,
+  "仾": 4164,
+  "瑠": 4165,
+  "煄": 4166,
+  "挥": 4167,
+  "庙": 4168,
+  "欻": 4169,
+  "穂": 4170,
+  "熻": 4171,
+  "猍": 4172,
+  "矿": 4173,
+  "軸": 4174,
+  "每": 4175,
+  "陪": 4176,
+  "邀": 4177,
+  "葛": 4178,
+  "蹟": 4179,
+  "猜": 4180,
+  "資": 4181,
+  "縮": 4182,
+  "桐": 4183,
+  "鸭": 4184,
+  "盔": 4185,
+  "涯": 4186,
+  "苗": 4187,
+  "谢": 4188,
+  "邮": 4189,
+  "畔": 4190,
+  "穢": 4191,
+  "潫": 4192,
+  "粘": 4193,
+  "鐔": 4194,
+  "唺": 4195,
+  "棷": 4196,
+  "钥": 4197,
+  "床": 4198,
+  "酔": 4199,
+  "詛": 4200,
+  "髭": 4201,
+  "搏": 4202,
+  "仗": 4203,
+  "耍": 4204,
+  "伢": 4205,
+  "厕": 4206,
+  "貘": 4207,
+  "凌": 4208,
+  "贯": 4209,
+  "梁": 4210,
+  "銅": 4211,
+  "賛": 4212,
+  "权": 4213,
+  "餃": 4214,
+  "挟": 4215,
+  "围": 4216,
+  "柿": 4217,
+  "疗": 4218,
+  "忋": 4219,
+  "炪": 4220,
+  "儕": 4221,
+  "据": 4222,
+  "俠": 4223,
+  "茧": 4224,
+  "穷": 4225,
+  "貞": 4226,
+  "ç": 4227,
+  "鮒": 4228,
+  "喱": 4229,
+  "둑": 4230,
+  "─": 4231,
+  "繫": 4232,
+  "疊": 4233,
+  "肋": 4234,
+  "姻": 4235,
+  "거": 4236,
+  "속": 4237,
+  "련": 4238,
+  "래": 4239,
+  "에": 4240,
+  "바": 4241,
+  "반": 4242,
+  "부": 4243,
+  "鎯": 4244,
+  "恭": 4245,
+  "赢": 4246,
+  "驴": 4247,
+  "鼹": 4248,
+  "币": 4249,
+  "撳": 4250,
+  "閬": 4251,
+  "辩": 4252,
+  "闃": 4253,
+  "檃": 4254,
+  "艣": 4255,
+  "轰": 4256,
+  "蔷": 4257,
+  "敬": 4258,
+  "韩": 4259,
+  "ㄥ": 4260,
+  "旇": 4261,
+  "鐮": 4262,
+  "喅": 4263,
+  "呰": 4264,
+  "乚": 4265,
+  "熶": 4266,
+  "梋": 4267,
+  "嗭": 4268,
+  "紓": 4269,
+  "鑲": 4270,
+  "埗": 4271,
+  "垢": 4272,
+  "软": 4273,
+  "泦": 4274,
+  "误": 4275,
+  "厔": 4276,
+  "鍟": 4277,
+  "丧": 4278,
+  "鎰": 4279,
+  "婅": 4280,
+  "举": 4281,
+  "堆": 4282,
+  "暥": 4283,
+  "臆": 4284,
+  "剥": 4285,
+  "仸": 4286,
+  "伅": 4287,
+  "芬": 4288,
+  "柏": 4289,
+  "乔": 4290,
+  "鼻": 4291,
+  "厉": 4292,
+  "禮": 4293,
+  "捧": 4294,
+  "弩": 4295,
+  "措": 4296,
+  "宁": 4297,
+  "悄": 4298,
+  "梨": 4299,
+  "肚": 4300,
+  "戽": 4301,
+  "浆": 4302,
+  "讃": 4303,
+  "溢": 4304,
+  "夸": 4305,
+  "潛": 4306,
+  "針": 4307,
+  "芭": 4308,
+  "键": 4309,
+  "函": 4310,
+  "粗": 4311,
+  "欶": 4312,
+  "添": 4313,
+  "愨": 4314,
+  "槄": 4315,
+  "暙": 4316,
+  "咚": 4317,
+  "霍": 4318,
+  "飲": 4319,
+  "倶": 4320,
+  "饼": 4321,
+  "膀": 4322,
+  "蹦": 4323,
+  "患": 4324,
+  "殘": 4325,
+  "搲": 4326,
+  "孝": 4327,
+  "勤": 4328,
+  "聴": 4329,
+  "挽": 4330,
+  "疫": 4331,
+  "耶": 4332,
+  "孵": 4333,
+  "殉": 4334,
+  "⁈": 4335,
+  "绀": 4336,
+  "騙": 4337,
+  "払": 4338,
+  "項": 4339,
+  "레": 4340,
+  "동": 4341,
+  "噜": 4342,
+  "紺": 4343,
+  "粴": 4344,
+  "醋": 4345,
+  "绕": 4346,
+  "窥": 4347,
+  "填": 4348,
+  "责": 4349,
+  "橱": 4350,
+  "甩": 4351,
+  "售": 4352,
+  "缝": 4353,
+  "溶": 4354,
+  "揮": 4355,
+  "臭": 4356,
+  "设": 4357,
+  "获": 4358,
+  "玷": 4359,
+  "幫": 4360,
+  "Ｃ": 4361,
+  "徳": 4362,
+  "圏": 4363,
+  "諦": 4364,
+  "晦": 4365,
+  "倾": 4366,
+  "竟": 4367,
+  "熬": 4368,
+  "拒": 4369,
+  "単": 4370,
+  "鏖": 4371,
+  "顏": 4372,
+  "蔽": 4373,
+  "綐": 4374,
+  "儍": 4375,
+  "瀑": 4376,
+  "吼": 4377,
+  "毗": 4378,
+  "掳": 4379,
+  "农": 4380,
+  "氧": 4381,
+  "鉴": 4382,
+  "汐": 4383,
+  "捷": 4384,
+  "蟠": 4385,
+  "确": 4386,
+  "监": 4387,
+  "褋": 4388,
+  "褌": 4389,
+  "驟": 4390,
+  "茹": 4391,
+  "ø": 4392,
+  "밀": 4393,
+  "窃": 4394,
+  "桥": 4395,
+  "奕": 4396,
+  "淡": 4397,
+  "蠻": 4398,
+  "撇": 4399,
+  "초": 4400,
+  "월": 4401,
+  "울": 4402,
+  "홍": 4403,
+  "봉": 4404,
+  "계": 4405,
+  "고": 4406,
+  "함": 4407,
+  "운": 4408,
+  "을": 4409,
+  "竴": 4410,
+  "瑜": 4411,
+  "蓬": 4412,
+  "嘎": 4413,
+  "屾": 4414,
+  "垜": 4415,
+  "讳": 4416,
+  "绫": 4417,
+  "翱": 4418,
+  "眉": 4419,
+  "慨": 4420,
+  "枟": 4421,
+  "竷": 4422,
+  "悏": 4423,
+  "濉": 4424,
+  "欎": 4425,
+  "瘑": 4426,
+  "櫓": 4427,
+  "寫": 4428,
+  "ㄤ": 4429,
+  "欓": 4430,
+  "潤": 4431,
+  "绛": 4432,
+  "秴": 4433,
+  "慮": 4434,
+  "佽": 4435,
+  "闄": 4436,
+  "櫖": 4437,
+  "仌": 4438,
+  "撱": 4439,
+  "詮": 4440,
+  "渐": 4441,
+  "疼": 4442,
+  "仛": 4443,
+  "慰": 4444,
+  "厂": 4445,
+  "倗": 4446,
+  "獳": 4447,
+  "籌": 4448,
+  "籏": 4449,
+  "籄": 4450,
+  "籘": 4451,
+  "籗": 4452,
+  "籙": 4453,
+  "偒": 4454,
+  "寤": 4455,
+  "伨": 4456,
+  "綸": 4457,
+  "仐": 4458,
+  "劒": 4459,
+  "牬": 4460,
+  "┕": 4461,
+  "暘": 4462,
+  "忐": 4463,
+  "忑": 4464,
+  "兹": 4465,
+  "靜": 4466,
+  "痉": 4467,
+  "浼": 4468,
+  "挎": 4469,
+  "愭": 4470,
+  "萧": 4471,
+  "凭": 4472,
+  "赞": 4473,
+  "旃": 4474,
+  "敂": 4475,
+  "勶": 4476,
+  "巋": 4477,
+  "怯": 4478,
+  "鑳": 4479,
+  "谊": 4480,
+  "郵": 4481,
+  "签": 4482,
+  "虾": 4483,
+  "Ｐ": 4484,
+  "瞄": 4485,
+  "膳": 4486,
+  "輸": 4487,
+  "棄": 4488,
+  "馳": 4489,
+  "绍": 4490,
+  "犀": 4491,
+  "愕": 4492,
+  "妬": 4493,
+  "赶": 4494,
+  "萝": 4495,
+  "鎌": 4496,
+  "厛": 4497,
+  "娈": 4498,
+  "埜": 4499,
+  "硸": 4500,
+  "爞": 4501,
+  "摜": 4502,
+  "＠": 4503,
+  "敤": 4504,
+  "厳": 4505,
+  "蛤": 4506,
+  "亴": 4507,
+  "≒": 4508,
+  "筝": 4509,
+  "綜": 4510,
+  "歊": 4511,
+  "羁": 4512,
+  "飢": 4513,
+  "壺": 4514,
+  "缶": 4515,
+  "析": 4516,
+  "乏": 4517,
+  "餅": 4518,
+  "昧": 4519,
+  "繭": 4520,
+  "経": 4521,
+  "刈": 4522,
+  "崚": 4523,
+  "粯": 4524,
+  "埆": 4525,
+  "垰": 4526,
+  "築": 4527,
+  "摘": 4528,
+  "ò": 4529,
+  "揃": 4530,
+  "坡": 4531,
+  "腦": 4532,
+  "藩": 4533,
+  "錢": 4534,
+  "蟇": 4535,
+  "艶": 4536,
+  "薙": 4537,
+  "毘": 4538,
+  "頬": 4539,
+  "萄": 4540,
+  "塗": 4541,
+  "燦": 4542,
+  "笨": 4543,
+  "巅": 4544,
+  "氛": 4545,
+  "扰": 4546,
+  "斥": 4547,
+  "嚏": 4548,
+  "项": 4549,
+  "黏": 4550,
+  "许": 4551,
+  "袱": 4552,
+  "炖": 4553,
+  "锃": 4554,
+  "壶": 4555,
+  "桶": 4556,
+  "椅": 4557,
+  "艰": 4558,
+  "荞": 4559,
+  "汰": 4560,
+  "淳": 4561,
+  "粒": 4562,
+  "瑙": 4563,
+  "鹵": 4564,
+  "拭": 4565,
+  "饗": 4566,
+  "汝": 4567,
+  "壷": 4568,
+  "狛": 4569,
+  "施": 4570,
+  "゜": 4571,
+  "偉": 4572,
+  "塘": 4573,
+  "渉": 4574,
+  "勧": 4575,
+  "∞": 4576,
+  "髄": 4577,
+  "抉": 4578,
+  "秩": 4579,
+  "順": 4580,
+  "皑": 4581,
+  "焚": 4582,
+  "纵": 4583,
+  "祸": 4584,
+  "嬉": 4585,
+  "哩": 4586,
+  "弑": 4587,
+  "丛": 4588,
+  "柩": 4589,
+  "脉": 4590,
+  "卿": 4591,
+  "⅙": 4592,
+  "拙": 4593,
+  "β": 4594,
+  "鼬": 4595,
+  "狠": 4596,
+  "炉": 4597,
+  "Д": 4598,
+  "А": 4599,
+  "н": 4600,
+  "圭": 4601,
+  "歉": 4602,
+  "汤": 4603,
+  "矶": 4604,
+  "顺": 4605,
+  "筆": 4606,
+  "霹": 4607,
+  "撕": 4608,
+  "竪": 4609,
+  "樽": 4610,
+  "纭": 4611,
+  "矮": 4612,
+  "鄙": 4613,
+  "钴": 4614,
+  "夹": 4615,
+  "毕": 4616,
+  "蜗": 4617,
+  "烹": 4618,
+  "饪": 4619,
+  "董": 4620,
+  "绷": 4621,
+  "膜": 4622,
+  "르": 4623,
+  "디": 4624,
+  "厘": 4625,
+  "♂": 4626,
+  "蝕": 4627,
+  "崭": 4628,
+  "貌": 4629,
+  "帆": 4630,
+  "涟": 4631,
+  "漪": 4632,
+  "鷺": 4633,
+  "ß": 4634,
+  "逊": 4635,
+  "揍": 4636,
+  "玫": 4637,
+  "斑": 4638,
+  "다": 4639,
+  "Ｈ": 4640,
+  "Ｙ": 4641,
+  "竿": 4642,
+  "涉": 4643,
+  "茄": 4644,
+  "筹": 4645,
+  "辆": 4646,
+  "睽": 4647,
+  "Ø": 4648,
+  "嗒": 4649,
+  "龄": 4650,
+  "스": 4651,
+  "보": 4652,
+  "魑": 4653,
+  "喝": 4654,
+  "槙": 4655,
+  "叙": 4656,
+  "옥": 4657,
+  "외": 4658,
+  "剤": 4659,
+  "钀": 4660,
+  "臉": 4661,
+  "몽": 4662,
+  "환": 4663,
+  "패": 4664,
+  "검": 4665,
+  "전": 4666,
+  "히": 4667,
+  "추": 4668,
+  "격": 4669,
+  "명": 4670,
+  "슬": 4671,
+  "자": 4672,
+  "산": 4673,
+  "로": 4674,
+  "가": 4675,
+  "崙": 4676,
+  "闲": 4677,
+  "阶": 4678,
+  "披": 4679,
+  "鍜": 4680,
+  "綖": 4681,
+  "冩": 4682,
+  "棌": 4683,
+  "т": 4684,
+  "ê": 4685,
+  "袝": 4686,
+  "彶": 4687,
+  "艳": 4688,
+  "颈": 4689,
+  "紬": 4690,
+  "惃": 4691,
+  "紑": 4692,
+  "冭": 4693,
+  "緹": 4694,
+  "埄": 4695,
+  "繎": 4696,
+  "簳": 4697,
+  "瞾": 4698,
+  "禲": 4699,
+  "惂": 4700,
+  "鎬": 4701,
+  "禌": 4702,
+  "厠": 4703,
+  "炵": 4704,
+  "璢": 4705,
+  "湀": 4706,
+  "囯": 4707,
+  "浉": 4708,
+  "唴": 4709,
+  "盆": 4710,
+  "儑": 4711,
+  "楅": 4712,
+  "饱": 4713,
+  "袂": 4714,
+  "扶": 4715,
+  "炒": 4716,
+  "亼": 4717,
+  "猼": 4718,
+  "它": 4719,
+  "鸥": 4720,
+  "滃": 4721,
+  "陈": 4722,
+  "棘": 4723,
+  "榜": 4724,
+  "烛": 4725,
+  "荡": 4726,
+  "凉": 4727,
+  "梵": 4728,
+  "禅": 4729,
+  "廡": 4730,
+  "脆": 4731,
+  "鳄": 4732,
+  "箹": 4733,
+  "胃": 4734,
+  "虑": 4735,
+  "嗣": 4736,
+  "幌": 4737,
+  "粰": 4738,
+  "悧": 4739,
+  "缂": 4740,
+  "﹩": 4741,
+  "脏": 4742,
+  "罩": 4743,
+  "篝": 4744,
+  "評": 4745,
+  "醫": 4746,
+  "携": 4747,
+  "氫": 4748,
+  "饲": 4749,
+  "鹦": 4750,
+  "鹉": 4751,
+  "∽": 4752,
+  "婴": 4753,
+  "惉": 4754,
+  "湢": 4755,
+  "褐": 4756,
+  "锵": 4757,
+  "洩": 4758,
+  "嘉": 4759,
+  "餌": 4760,
+  "咎": 4761,
+  "滸": 4762,
+  "浒": 4763,
+  "乀": 4764,
+  "顽": 4765,
+  "蚊": 4766,
+  "桧": 4767,
+  "喇": 4768,
+  "叭": 4769,
+  "併": 4770,
+  "┿": 4771,
+  "筏": 4772,
+  "咦": 4773,
+  "渭": 4774,
+  "餓": 4775,
+  "擂": 4776,
+  "梢": 4777,
+  "枝": 4778,
+  "貸": 4779,
+  "鮫": 4780,
+  "傀": 4781,
+  "儡": 4782,
+  "覧": 4783,
+  "労": 4784,
+  "哨": 4785,
+  "翳": 4786,
+  "劉": 4787,
+  "詑": 4788,
+  "貧": 4789,
+  "聡": 4790,
+  "％": 4791,
+  "藪": 4792,
+  "仄": 4793,
+  "冊": 4794,
+  "垣": 4795,
+  "謹": 4796,
+  "莓": 4797,
+  "妨": 4798,
+  "啾": 4799,
+  "Ｘ": 4800,
+  "硫": 4801,
+  "鈔": 4802,
+  "塊": 4803,
+  "斜": 4804,
+  "蝴": 4805,
+  "飄": 4806,
+  "眞": 4807,
+  "湗": 4808,
+  "倓": 4809,
+  "鏇": 4810,
+  "埐": 4811,
+  "錆": 4812,
+  "磔": 4813,
+  "贷": 4814,
+  "款": 4815,
+  "悦": 4816,
+  "烫": 4817,
+  "笋": 4818,
+  "齿": 4819,
+  "痒": 4820,
+  "帘": 4821,
+  "蜓": 4822,
+  "銭": 4823,
+  "絡": 4824,
+  "謃": 4825,
+  "梓": 4826,
+  "沫": 4827,
+  "祀": 4828,
+  "滋": 4829,
+  "褒": 4830,
+  "腸": 4831,
+  "囁": 4832,
+  "戬": 4833,
+  "殇": 4834,
+  "剩": 4835,
+  "谅": 4836,
+  "狡": 4837,
+  "猾": 4838,
+  "并": 4839,
+  "延": 4840,
+  "諸": 4841,
+  "茱": 4842,
+  "®": 4843,
+  "烂": 4844,
+  "誌": 4845,
+  "凝": 4846,
+  "拝": 4847,
+  "隅": 4848,
+  "嶐": 4849,
+  "袴": 4850,
+  "粋": 4851,
+  "犠": 4852,
+  "幾": 4853,
+  "隙": 4854,
+  "饮": 4855,
+  "朔": 4856,
+  "枢": 4857,
+  "亦": 4858,
+  "魄": 4859,
+  "挫": 4860,
+  "抵": 4861,
+  "卟": 4862,
+  "琳": 4863,
+  "费": 4864,
+  "殲": 4865,
+  "閻": 4866,
+  "斉": 4867,
+  "乖": 4868,
+  "埼": 4869,
+  "尿": 4870,
+  "膵": 4871,
+  "営": 4872,
+  "筒": 4873,
+  "唸": 4874,
+  "犹": 4875,
+  "遷": 4876,
+  "忽": 4877,
+  "煉": 4878,
+  "壍": 4879,
+  "赎": 4880,
+  "褪": 4881,
+  "偔": 4882,
+  "儜": 4883,
+  "儊": 4884,
+  "赚": 4885,
+  "框": 4886,
+  "炁": 4887,
+  "勃": 4888,
+  "鳗": 4889,
+  "孽": 4890,
+  "雳": 4891,
+  "螢": 4892,
+  "霄": 4893,
+  "蠱": 4894,
+  "攪": 4895,
+  "漩": 4896,
+  "涡": 4897,
+  "刨": 4898,
+  "攀": 4899,
+  "腋": 4900,
+  "伟": 4901,
+  "熔": 4902,
+  "痣": 4903,
+  "需": 4904,
+  "剂": 4905,
+  "錠": 4906,
+  "铤": 4907,
+  "益": 4908,
+  "柄": 4909,
+  "脩": 4910,
+  "恢": 4911,
+  "茫": 4912,
+  "漸": 4913,
+  "트": 4914,
+  "丨": 4915,
+  "謁": 4916,
+  "鮎": 4917,
+  "凧": 4918,
+  "眸": 4919,
+  "堇": 4920,
+  "赁": 4921,
+  "哔": 4922,
+  "석": 4923,
+  "푸": 4924,
+  "潘": 4925,
+  "蝋": 4926,
+  "騨": 4927,
+  "撫": 4928,
+  "礫": 4929,
+  "顎": 4930,
+  "憤": 4931,
+  "Е": 4932,
+  "ぢ": 4933,
+  "珱": 4934,
+  "筷": 4935,
+  "Ö": 4936,
+  "亨": 4937,
+  "菈": 4938,
+  "郎": 4939,
+  "褲": 4940,
+  "상": 4941,
+  "미": 4942,
+  "코": 4943,
+  "령": 4944,
+  "혼": 4945,
+  "묘": 4946,
+  "들": 4947,
+  "즈": 4948,
+  "각": 4949,
+  "데": 4950,
+  "향": 4951,
+  "해": 4952,
+  "嚭": 4953,
+  "蛀": 4954,
+  "鈹": 4955,
+  "溌": 4956,
+  "瑅": 4957,
+  "脠": 4958,
+  "²": 4959,
+  "崑": 4960,
+  "晱": 4961,
+  "姞": 4962,
+  "铇": 4963,
+  "戣": 4964,
+  "弴": 4965,
+  "垚": 4966,
+  "鐐": 4967,
+  "渶": 4968,
+  "橝": 4969,
+  "艅": 4970,
+  "º": 4971,
+  "亾": 4972,
+  "粓": 4973,
+  "癸": 4974,
+  "楋": 4975,
+  "彂": 4976,
+  "噺": 4977,
+  "劚": 4978,
+  "彉": 4979,
+  "韬": 4980,
+  "櫒": 4981,
+  "湁": 4982,
+  "寘": 4983,
+  "堜": 4984,
+  "簬": 4985,
+  "繕": 4986,
+  "憳": 4987,
+  "墦": 4988,
+  "笌": 4989,
+  "矙": 4990,
+  "廬": 4991,
+  "愯": 4992,
+  "啗": 4993,
+  "嚮": 4994,
+  "︼": 4995,
+  "繃": 4996,
+  "氳": 4997,
+  "挋": 4998,
+  "櫥": 4999,
+  "忕": 5000,
+  "鏆": 5001,
+  "楗": 5002,
+  "璁": 5003,
+  "┒": 5004,
+  "莽": 5005,
+  "頁": 5006,
+  "吟": 5007,
+  "袍": 5008,
+  "糠": 5009,
+  "茂": 5010,
+  "拘": 5011,
+  "疏": 5012,
+  "笹": 5013,
+  "蝗": 5014,
+  "ц": 5015,
+  "閴": 5016,
+  "牨": 5017,
+  "冮": 5018,
+  "苞": 5019,
+  "槒": 5020,
+  "簵": 5021,
+  "揣": 5022,
+  "焆": 5023,
+  "玖": 5024,
+  "鲨": 5025,
+  "唐": 5026,
+  "闀": 5027,
+  "叧": 5028,
+  "晣": 5029,
+  "鐡": 5030,
+  "硅": 5031,
+  "缃": 5032,
+  "氶": 5033,
+  "楸": 5034,
+  "杂": 5035,
+  "盐": 5036,
+  "夷": 5037,
+  "烽": 5038,
+  "琼": 5039,
+  "浩": 5040,
+  "阗": 5041,
+  "钮": 5042,
+  "驶": 5043,
+  "ʼ": 5044,
+  "拡": 5045,
+  "颯": 5046,
+  "墰": 5047,
+  "儏": 5048,
+  "紮": 5049,
+  "搱": 5050,
+  "钑": 5051,
+  "╅": 5052,
+  "妫": 5053,
+  "粨": 5054,
+  "暀": 5055,
+  "Ｉ": 5056,
+  "誂": 5057,
+  "馒": 5058,
+  "嘻": 5059,
+  "茬": 5060,
+  "敇": 5061,
+  "摝": 5062,
+  "櫘": 5063,
+  "刷": 5064,
+  "饿": 5065,
+  "铚": 5066,
+  "狅": 5067,
+  "遁": 5068,
+  "梟": 5069,
+  "帷": 5070,
+  "嫉": 5071,
+  "琦": 5072,
+  "孴": 5073,
+  "峀": 5074,
+  "蝌": 5075,
+  "蚪": 5076,
+  "庐": 5077,
+  "荧": 5078,
+  "励": 5079,
+  "懲": 5080,
+  "泟": 5081,
+  "帿": 5082,
+  "侽": 5083,
+  "苑": 5084,
+  "鈞": 5085,
+  "闭": 5086,
+  "肱": 5087,
+  "垾": 5088,
+  "喬": 5089,
+  "钦": 5090,
+  "躯": 5091,
+  "枷": 5092,
+  "胧": 5093,
+  "沃": 5094,
+  "糧": 5095,
+  "浸": 5096,
+  "笐": 5097,
+  "孲": 5098,
+  "宭": 5099,
+  "孏": 5100,
+  "麺": 5101,
+  "鶏": 5102,
+  "棚": 5103,
+  "菖": 5104,
+  "鯛": 5105,
+  "⑤": 5106,
+  "⑥": 5107,
+  "炊": 5108,
+  "株": 5109,
+  "＾": 5110,
+  "兎": 5111,
+  "萩": 5112,
+  "抅": 5113,
+  "仑": 5114,
+  "盲": 5115,
+  "哖": 5116,
+  "蛟": 5117,
+  "鸵": 5118,
+  "盼": 5119,
+  "袜": 5120,
+  "例": 5121,
+  "Ｕ": 5122,
+  "岬": 5123,
+  "稱": 5124,
+  "梭": 5125,
+  "盧": 5126,
+  "蹤": 5127,
+  "價": 5128,
+  "瘋": 5129,
+  "蝦": 5130,
+  "鈷": 5131,
+  "铅": 5132,
+  "태": 5133,
+  "투": 5134,
+  "藝": 5135,
+  "鈍": 5136,
+  "牱": 5137,
+  "耻": 5138,
+  "夙": 5139,
+  "肴": 5140,
+  "啥": 5141,
+  "犰": 5142,
+  "狳": 5143,
+  "锤": 5144,
+  "飕": 5145,
+  "碌": 5146,
+  "浓": 5147,
+  "嗡": 5148,
+  "订": 5149,
+  "橄": 5150,
+  "楞": 5151,
+  "荏": 5152,
+  "辿": 5153,
+  "祠": 5154,
+  "擲": 5155,
+  "済": 5156,
+  "喫": 5157,
+  "箏": 5158,
+  "峙": 5159,
+  "渓": 5160,
+  "翌": 5161,
+  "籈": 5162,
+  "閣": 5163,
+  "絃": 5164,
+  "蒔": 5165,
+  "蝠": 5166,
+  "锏": 5167,
+  "拢": 5168,
+  "瞎": 5169,
+  "筵": 5170,
+  "肯": 5171,
+  "囉": 5172,
+  "叩": 5173,
+  "串": 5174,
+  "陳": 5175,
+  "攫": 5176,
+  "啓": 5177,
+  "肺": 5178,
+  "腺": 5179,
+  "坝": 5180,
+  "Ｍ": 5181,
+  "磷": 5182,
+  "鼎": 5183,
+  "蛊": 5184,
+  "珑": 5185,
+  "籁": 5186,
+  "瞰": 5187,
+  "較": 5188,
+  "棿": 5189,
+  "蹴": 5190,
+  "県": 5191,
+  "磐": 5192,
+  "濃": 5193,
+  "睦": 5194,
+  "殴": 5195,
+  "螂": 5196,
+  "陨": 5197,
+  "螫": 5198,
+  "偪": 5199,
+  "眺": 5200,
+  "呑": 5201,
+  "渾": 5202,
+  "閑": 5203,
+  "磨": 5204,
+  "捲": 5205,
+  "爐": 5206,
+  "憲": 5207,
+  "暦": 5208,
+  "冢": 5209,
+  "醍": 5210,
+  "醐": 5211,
+  "镰": 5212,
+  "勅": 5213,
+  "颱": 5214,
+  "妆": 5215,
+  "乒": 5216,
+  "乓": 5217,
+  "吕": 5218,
+  "綴": 5219,
+  "载": 5220,
+  "а": 5221,
+  "л": 5222,
+  "о": 5223,
+  "№": 5224,
+  "跺": 5225,
+  "煡": 5226,
+  "壗": 5227,
+  "昨": 5228,
+  "鲛": 5229,
+  "蛰": 5230,
+  "膠": 5231,
+  "歇": 5232,
+  "働": 5233,
+  "叡": 5234,
+  "鉂": 5235,
+  "巳": 5236,
+  "杨": 5237,
+  "蠍": 5238,
+  "裔": 5239,
+  "挺": 5240,
+  "籃": 5241,
+  "積": 5242,
+  "缰": 5243,
+  "跌": 5244,
+  "熏": 5245,
+  "吒": 5246,
+  "粮": 5247,
+  "伺": 5248,
+  "该": 5249,
+  "氓": 5250,
+  "琅": 5251,
+  "狄": 5252,
+  "蟆": 5253,
+  "曰": 5254,
+  "霆": 5255,
+  "倔": 5256,
+  "苛": 5257,
+  "鳶": 5258,
+  "喽": 5259,
+  "既": 5260,
+  "氤": 5261,
+  "氲": 5262,
+  "丰": 5263,
+  "虞": 5264,
+  "ゝ": 5265,
+  "訳": 5266,
+  "且": 5267,
+  "魉": 5268,
+  "堪": 5269,
+  "濫": 5270,
+  "瀕": 5271,
+  "哬": 5272,
+  "泄": 5273,
+  "岗": 5274,
+  "獏": 5275,
+  "攒": 5276,
+  "婶": 5277,
+  "톤": 5278,
+  "嘭": 5279,
+  "◉": 5280,
+  "谴": 5281,
+  "袟": 5282,
+  "袩": 5283,
+  "侑": 5284,
+  "宍": 5285,
+  "飓": 5286,
+  "尉": 5287,
+  "掠": 5288,
+  "簗": 5289,
+  "瘟": 5290,
+  "Ｌ": 5291,
+  "弯": 5292,
+  "膛": 5293,
+  "悍": 5294,
+  "咸": 5295,
+  "寧": 5296,
+  "萎": 5297,
+  "缪": 5298,
+  "蚂": 5299,
+  "Ú": 5300,
+  "矩": 5301,
+  "页": 5302,
+  "额": 5303,
+  "搅": 5304,
+  "损": 5305,
+  "瞭": 5306,
+  "谲": 5307,
+  "绸": 5308,
+  "饺": 5309,
+  "濯": 5310,
+  "ส": 5311,
+  "้": 5312,
+  "โ": 5313,
+  "õ": 5314,
+  "여": 5315,
+  "형": 5316,
+  "유": 5317,
+  "와": 5318,
+  "랑": 5319,
+  "타": 5320,
+  "억": 5321,
+  "경": 5322,
+  "약": 5323,
+  "연": 5324,
+  "ì": 5325,
+  "碟": 5326,
+  "惯": 5327,
+  "悖": 5328,
+  "慷": 5329,
+  "斐": 5330,
+  "藻": 5331,
+  "嘟": 5332,
+  "铀": 5333,
+  "穩": 5334,
+  "趟": 5335,
+  "В": 5336,
+  "Ц": 5337,
+  "毯": 5338,
+  "貯": 5339,
+  "冻": 5340,
+  "穫": 5341,
+  "−": 5342,
+  "雇": 5343,
+  "＝": 5344,
+  "敦": 5345,
+  "Ä": 5346,
+  "违": 5347,
+  "暫": 5348,
+  "傍": 5349,
+  "屑": 5350,
+  "乢": 5351,
+  "燭": 5352,
+  "谚": 5353,
+  "嫩": 5354,
+  "穏": 5355,
+  "饅": 5356,
+  "嶋": 5357,
+  "刎": 5358,
+  "煬": 5359,
+  "况": 5360,
+  "溪": 5361,
+  "谛": 5362,
+  "鹳": 5363,
+  "厢": 5364,
+  "爬": 5365,
+  "幅": 5366,
+  "특": 5367,
+  "영": 5368,
+  "토": 5369,
+  "곡": 5370,
+  "념": 5371,
+  "셋": 5372,
+  "쇼": 5373,
+  "되": 5374,
+  "순": 5375,
+  "간": 5376,
+  "최": 5377,
+  "후": 5378,
+  "통": 5379,
+  "승": 5380,
+  "픔": 5381,
+  "흔": 5382,
+  "꽃": 5383,
+  "심": 5384,
+  "요": 5385,
+  "당": 5386,
+  "람": 5387,
+  "륵": 5388,
+  "오": 5389,
+  "용": 5390,
+  "린": 5391,
+  "철": 5392,
+  "쇄": 5393,
+  "잔": 5394,
+  "파": 5395,
+  "몸": 5396,
+  "으": 5397,
+  "빛": 5398,
+  "별": 5399,
+  "짝": 5400,
+  "생": 5401,
+  "중": 5402,
+  "칸": 5403,
+  "질": 5404,
+  "없": 5405,
+  "망": 5406,
+  "둠": 5407,
+  "내": 5408,
+  "일": 5409,
+  "쿠": 5410,
+  "조": 5411,
+  "않": 5412,
+  "誅": 5413,
+  "櫙": 5414,
+  "珜": 5415,
+  "窉": 5416,
+  "儷": 5417,
+  "♫": 5418,
+  "彡": 5419,
+  "糬": 5420,
+  "咋": 5421,
+  "橲": 5422,
+  "弽": 5423,
+  "櫉": 5424,
+  "╋": 5425,
+  "棭": 5426,
+  "璨": 5427,
+  "锝": 5428,
+  "湻": 5429,
+  "嵅": 5430,
+  "楁": 5431,
+  "埦": 5432,
+  "ù": 5433,
+  "橭": 5434,
+  "檋": 5435,
+  "櫭": 5436,
+  "ヽ": 5437,
+  "檌": 5438,
+  "艢": 5439,
+  "潞": 5440,
+  "瞧": 5441,
+  "愰": 5442,
+  "橈": 5443,
+  "壈": 5444,
+  "︿": 5445,
+  "琛": 5446,
+  "铔": 5447,
+  "幓": 5448,
+  "綇": 5449,
+  "曞": 5450,
+  "瓩": 5451,
+  "垏": 5452,
+  "揩": 5453,
+  "壘": 5454,
+  "僝": 5455,
+  "笣": 5456,
+  "杈": 5457,
+  "摱": 5458,
+  "噧": 5459,
+  "ㄨ": 5460,
+  "毊": 5461,
+  "槱": 5462,
+  "崥": 5463,
+  "埇": 5464,
+  "熀": 5465,
+  "惤": 5466,
+  "噷": 5467,
+  "獊": 5468,
+  "綉": 5469,
+  "帴": 5470,
+  "紝": 5471,
+  "叏": 5472,
+  "鍎": 5473,
+  "啀": 5474,
+  "皢": 5475,
+  "籡": 5476,
+  "啋": 5477,
+  "闅": 5478,
+  "嬶": 5479,
+  "拻": 5480,
+  "儨": 5481,
+  "宕": 5482,
+  "簝": 5483,
+  "樇": 5484,
+  "濇": 5485,
+  "湜": 5486,
+  "亹": 5487,
+  "朷": 5488,
+  "磋": 5489,
+  "獌": 5490,
+  "姱": 5491,
+  "婏": 5492,
+  "垎": 5493,
+  "乑": 5494,
+  "痌": 5495,
+  "竾": 5496,
+  "枩": 5497,
+  "儴": 5498,
+  "劋": 5499,
+  "湶": 5500,
+  "垐": 5501,
+  "冿": 5502,
+  "敹": 5503,
+  "厓": 5504,
+  "筣": 5505,
+  "埛": 5506,
+  "仩": 5507,
+  "卯": 5508,
+  "湰": 5509,
+  "逗": 5510,
+  "耗": 5511,
+  "辫": 5512,
+  "盂": 5513,
+  "忚": 5514,
+  "澘": 5515,
+  "纰": 5516,
+  "棈": 5517,
+  "憠": 5518,
+  "櫚": 5519,
+  "潏": 5520,
+  "輾": 5521,
+  "載": 5522,
+  "跤": 5523,
+  "囡": 5524,
+  "恁": 5525,
+  "暝": 5526,
+  "佇": 5527,
+  "欱": 5528,
+  "嚒": 5529,
+  "彮": 5530,
+  "遐": 5531,
+  "疙": 5532,
+  "瘩": 5533,
+  "♨": 5534,
+  "皫": 5535,
+  "嫏": 5536,
+  "惕": 5537,
+  "擒": 5538,
+  "腾": 5539,
+  "崽": 5540,
+  "旷": 5541,
+  "账": 5542,
+  "粪": 5543,
+  "礁": 5544,
+  "猬": 5545,
+  "荆": 5546,
+  "羔": 5547,
+  "秉": 5548,
+  "衫": 5549,
+  "骁": 5550,
+  "豁": 5551,
+  "涧": 5552,
+  "渝": 5553,
+  "砸": 5554,
+  "奬": 5555,
+  "肠": 5556,
+  "凑": 5557,
+  "晒": 5558,
+  "绰": 5559,
+  "埴": 5560,
+  "濁": 5561,
+  "癩": 5562,
+  "掗": 5563,
+  "碷": 5564,
+  "甫": 5565,
+  "槺": 5566,
+  "畧": 5567,
+  "潗": 5568,
+  "奭": 5569,
+  "漖": 5570,
+  "晥": 5571,
+  "崪": 5572,
+  "禫": 5573,
+  "櫤": 5574,
+  "吔": 5575,
+  "紦": 5576,
+  "拰": 5577,
+  "煭": 5578,
+  "绗": 5579,
+  "剰": 5580,
+  "炰": 5581,
+  "胯": 5582,
+  "嗘": 5583,
+  "煟": 5584,
+  "胰": 5585,
+  "œ": 5586,
+  "購": 5587,
+  "ｰ": 5588,
+  "熴": 5589,
+  "协": 5590,
+  "阅": 5591,
+  "酌": 5592,
+  "榇": 5593,
+  "箖": 5594,
+  "嬨": 5595,
+  "柇": 5596,
+  "悊": 5597,
+  "抬": 5598,
+  "晰": 5599,
+  "穬": 5600,
+  "畽": 5601,
+  "⚔": 5602,
+  "️": 5603,
+  "爍": 5604,
+  "弊": 5605,
+  "髏": 5606,
+  "炫": 5607,
+  "佑": 5608,
+  "鲜": 5609,
+  "壓": 5610,
+  "烁": 5611,
+  "坍": 5612,
+  "锥": 5613,
+  "轭": 5614,
+  "禽": 5615,
+  "鎾": 5616,
+  "岃": 5617,
+  "垍": 5618,
+  "匽": 5619,
+  "慉": 5620,
+  "屉": 5621,
+  "儺": 5622,
+  "⓪": 5623,
+  "陋": 5624,
+  "脇": 5625,
+  "倝": 5626,
+  "嘷": 5627,
+  "榊": 5628,
+  "骏": 5629,
+  "鲤": 5630,
+  "毽": 5631,
+  "咩": 5632,
+  "舖": 5633,
+  "掴": 5634,
+  "儯": 5635,
+  "璙": 5636,
+  "倱": 5637,
+  "韭": 5638,
+  "诶": 5639,
+  "廉": 5640,
+  "轍": 5641,
+  "筈": 5642,
+  "櫌": 5643,
+  "洘": 5644,
+  "丗": 5645,
+  "湧": 5646,
+  "倪": 5647,
+  "權": 5648,
+  "宜": 5649,
+  "麾": 5650,
+  "耕": 5651,
+  "剔": 5652,
+  "胚": 5653,
+  "澹": 5654,
+  "倰": 5655,
+  "亪": 5656,
+  "媉": 5657,
+  "懼": 5658,
+  "棍": 5659,
+  "倢": 5660,
+  "砞": 5661,
+  "绐": 5662,
+  "儐": 5663,
+  "涖": 5664,
+  "儛": 5665,
+  "礭": 5666,
+  "韻": 5667,
+  "鞜": 5668,
+  "宻": 5669,
+  "宺": 5670,
+  "孍": 5671,
+  "㈱": 5672,
+  "澪": 5673,
+  "＼": 5674,
+  "◇": 5675,
+  "篭": 5676,
+  "È": 5677,
+  "饜": 5678,
+  "绒": 5679,
+  "剗": 5680,
+  "扱": 5681,
+  "撤": 5682,
+  "磺": 5683,
+  "哼": 5684,
+  "矗": 5685,
+  "骼": 5686,
+  "攝": 5687,
+  "敲": 5688,
+  "侖": 5689,
+  "龐": 5690,
+  "掩": 5691,
+  "賈": 5692,
+  "蘋": 5693,
+  "雞": 5694,
+  "獎": 5695,
+  "嚴": 5696,
+  "幣": 5697,
+  "缄": 5698,
+  "溃": 5699,
+  "炙": 5700,
+  "唠": 5701,
+  "叨": 5702,
+  "犸": 5703,
+  "皂": 5704,
+  "秸": 5705,
+  "扬": 5706,
+  "蓑": 5707,
+  "锻": 5708,
+  "獭": 5709,
+  "杆": 5710,
+  "鲭": 5711,
+  "吖": 5712,
+  "瞒": 5713,
+  "滓": 5714,
+  "鱗": 5715,
+  "燔": 5716,
+  "逡": 5717,
+  "椰": 5718,
+  "弘": 5719,
+  "夾": 5720,
+  "丞": 5721,
+  "螞": 5722,
+  "匡": 5723,
+  "諏": 5724,
+  "駿": 5725,
+  "萍": 5726,
+  "释": 5727,
+  "屏": 5728,
+  "刽": 5729,
+  "述": 5730,
+  "掷": 5731,
+  "蘊": 5732,
+  "匿": 5733,
+  "颤": 5734,
+  "枭": 5735,
+  "霁": 5736,
+  "饒": 5737,
+  "恕": 5738,
+  "溝": 5739,
+  "礙": 5740,
+  "掀": 5741,
+  "囮": 5742,
+  "漱": 5743,
+  "椎": 5744,
+  "稍": 5745,
+  "楊": 5746,
+  "潼": 5747,
+  "殷": 5748,
+  "妲": 5749,
+  "槐": 5750,
+  "赂": 5751,
+  "蚕": 5752,
+  "ｖ": 5753,
+  "ｓ": 5754,
+  "挤": 5755,
+  "弈": 5756,
+  "纤": 5757,
+  "脂": 5758,
+  "荑": 5759,
+  "饕": 5760,
+  "餮": 5761,
+  "阙": 5762,
+  "毅": 5763,
+  "税": 5764,
+  "醇": 5765,
+  "㈢": 5766,
+  "犱": 5767,
+  "栽": 5768,
+  "寡": 5769,
+  "蟑": 5770,
+  "踩": 5771,
+  "跷": 5772,
+  "桀": 5773,
+  "骜": 5774,
+  "鞘": 5775,
+  "槃": 5776,
+  "饥": 5777,
+  "熙": 5778,
+  "较": 5779,
+  "︺": 5780,
+  "曘": 5781,
+  "偂": 5782,
+  "骤": 5783,
+  "阋": 5784,
+  "鸳": 5785,
+  "鸯": 5786,
+  "掻": 5787,
+  "噛": 5788,
+  "笠": 5789,
+  "諧": 5790,
+  "謔": 5791,
+  "瀨": 5792,
+  "聳": 5793,
+  "窺": 5794,
+  "窩": 5795,
+  "勘": 5796,
+  "摂": 5797,
+  "芦": 5798,
+  "鋭": 5799,
+  "絹": 5800,
+  "弔": 5801,
+  "鍬": 5802,
+  "刪": 5803,
+  "燉": 5804,
+  "嘣": 5805,
+  "爲": 5806,
+  "拨": 5807,
+  "遼": 5808,
+  "斃": 5809,
+  "晝": 5810,
+  "顛": 5811,
+  "擴": 5812,
+  "渗": 5813,
+  "嵬": 5814,
+  "挵": 5815,
+  "嵒": 5816,
+  "粸": 5817,
+  "幆": 5818,
+  "姭": 5819,
+  "綊": 5820,
+  "嵈": 5821,
+  "О": 5822,
+  "爹": 5823,
+  "魇": 5824,
+  "娼": 5825,
+  "叆": 5826,
+  "宀": 5827,
+  "殣": 5828,
+  "≈": 5829,
+  "扩": 5830,
+  "諍": 5831,
+  "昡": 5832,
+  "尹": 5833,
+  "辅": 5834,
+  "巷": 5835,
+  "喋": 5836,
+  "滲": 5837,
+  "鬆": 5838,
+  "碁": 5839,
+  "篱": 5840,
+  "禹": 5841,
+  "軒": 5842,
+  "轅": 5843,
+  "懵": 5844,
+  "棠": 5845,
+  "儣": 5846,
+  "糾": 5847,
+  "紛": 5848,
+  "蚀": 5849,
+  "亘": 5850,
+  "腊": 5851,
+  "锡": 5852,
+  "橡": 5853,
+  "韁": 5854,
+  "穣": 5855,
+  "蔬": 5856,
+  "驭": 5857,
+  "哑": 5858,
+  "览": 5859,
+  "瞑": 5860,
+  "雕": 5861,
+  "聊": 5862,
+  "藕": 5863,
+  "嗯": 5864,
+  "赠": 5865,
+  "朦": 5866,
+  "醮": 5867,
+  "饵": 5868,
+  "莹": 5869,
+  "敛": 5870,
+  "隕": 5871,
+  "凋": 5872,
+  "屠": 5873,
+  "衷": 5874,
+  "亏": 5875,
+  "嫣": 5876,
+  "衅": 5877,
+  "扁": 5878,
+  "鹊": 5879,
+  "辗": 5880,
+  "迟": 5881,
+  "墩": 5882,
+  "兮": 5883,
+  "螳": 5884,
+  "俯": 5885,
+  "譽": 5886,
+  "敘": 5887,
+  "驕": 5888,
+  "厚": 5889,
+  "遞": 5890,
+  "朽": 5891,
+  "彫": 5892,
+  "苒": 5893,
+  "尴": 5894,
+  "尬": 5895,
+  "陌": 5896,
+  "讶": 5897,
+  "彀": 5898,
+  "氾": 5899,
+  "徴": 5900,
+  "洄": 5901,
+  "驹": 5902,
+  "荊": 5903,
+  "赋": 5904,
+  "羚": 5905,
+  "宪": 5906,
+  "敕": 5907,
+  "楕": 5908,
+  "濱": 5909,
+  "遜": 5910,
+  "侧": 5911,
+  "餘": 5912,
+  "盪": 5913,
+  "漾": 5914,
+  "絽": 5915,
+  "曉": 5916,
+  "寢": 5917,
+  "诊": 5918,
+  "汹": 5919,
+  "详": 5920,
+  "估": 5921,
+  "诹": 5922,
+  "隧": 5923,
+  "缓": 5924,
+  "铐": 5925,
+  "劾": 5926,
+  "諱": 5927,
+  "堺": 5928,
+  "舗": 5929,
+  "́": 5930,
+  "◞": 5931,
+  "౪": 5932,
+  "◟": 5933,
+  "‵": 5934,
+  "挣": 5935,
+  "锌": 5936,
+  "褘": 5937,
+  "衼": 5938,
+  "ｉ": 5939,
+  "販": 5940,
+  "促": 5941,
+  "÷": 5942,
+  "箋": 5943,
+  "聪": 5944,
+  "鍍": 5945,
+  "姥": 5946,
+  "蕪": 5947,
+  "尺": 5948,
+  "牺": 5949,
+  "圃": 5950,
+  "咧": 5951,
+  "仅": 5952,
+  "涤": 5953,
+  "嘲": 5954,
+  "獠": 5955,
+  "旺": 5956,
+  "縦": 5957,
+  "蕭": 5958,
+  "據": 5959,
+  "薛": 5960,
+  "辜": 5961,
+  "债": 5962,
+  "慑": 5963,
+  "拦": 5964,
+  "谬": 5965,
+  "氢": 5966,
+  "₂": 5967,
+  "疤": 5968,
+  "彰": 5969,
+  "酎": 5970,
+  "粧": 5971,
+  "瀾": 5972,
+  "縊": 5973,
+  "゚": 5974,
+  "蚤": 5975,
+  "荐": 5976,
+  "蹭": 5977,
+  "芋": 5978,
+  "扔": 5979,
+  "腌": 5980,
+  "拆": 5981,
+  "เ": 5982,
+  "า": 5983,
+  "ง": 5984,
+  "ู": 5985,
+  "ถ": 5986,
+  "ว": 5987,
+  "ย": 5988,
+  "ฮ": 5989,
+  "ค": 5990,
+  "ุ": 5991,
+  "ะ": 5992,
+  "귀": 5993,
+  "탑": 5994,
+  "습": 5995,
+  "치": 5996,
+  "크": 5997,
+  "새": 5998,
+  "벌": 5999,
+  "위": 6000,
+  "글": 6001,
+  "러": 6002,
+  "브": 6003,
+  "백": 6004,
+  "축": 6005,
+  "신": 6006,
+  "옛": 6007,
+  "발": 6008,
+  "렌": 6009,
+  "강": 6010,
+  "력": 6011,
+  "혜": 6012,
+  "알": 6013,
+  "수": 6014,
+  "찰": 6015,
+  "샐": 6016,
+  "잡": 6017,
+  "샴": 6018,
+  "델": 6019,
+  "회": 6020,
+  "찾": 6021,
+  "뷰": 6022,
+  "행": 6023,
+  "복": 6024,
+  "무": 6025,
+  "호": 6026,
+  "합": 6027,
+  "날": 6028,
+  "개": 6029,
+  "탐": 6030,
+  "단": 6031,
+  "돌": 6032,
+  "엄": 6033,
+  "셜": 6034,
+  "록": 6035,
+  "은": 6036,
+  "표": 6037,
+  "菩": 6038,
+  "酢": 6039,
+  "醬": 6040,
+  "顆": 6041,
+  "颶": 6042,
+  "胤": 6043,
+  "焗": 6044,
+  "鉛": 6045,
+  "嶽": 6046,
+  "咽": 6047,
+  "篠": 6048,
+  "躙": 6049,
+  "腭": 6050,
+  "筥": 6051,
+  "啤": 6052,
+  "堵": 6053,
+  "←": 6054,
+  "鵜": 6055,
+  "茨": 6056,
+  "硯": 6057,
+  "眇": 6058,
+  "瞼": 6059,
+  "茵": 6060,
+  "囀": 6061,
+  "嘯": 6062,
+  "曝": 6063,
+  "洼": 6064,
+  "俐": 6065,
+  "條": 6066,
+  "嚙": 6067,
+  "逻": 6068,
+  "霾": 6069,
+  "仍": 6070,
+  "鞄": 6071,
+  "∴": 6072,
+  "瞌": 6073,
+  "Н": 6074,
+  "Т": 6075,
+  "Ь": 6076,
+  "М": 6077,
+  "С": 6078,
+  "Я": 6079,
+  "錶": 6080,
+  "腳": 6081,
+  "觀": 6082,
+  "攬": 6083,
+  "搗": 6084,
+  "鵝": 6085,
+  "遨": 6086,
+  "黍": 6087,
+  "滞": 6088,
+  "涕": 6089,
+  "紘": 6090,
+  "锭": 6091,
+  "秧": 6092,
+  "匂": 6093,
+  "蔓": 6094,
+  "缠": 6095,
+  "嗝": 6096,
+  "挪": 6097,
+  "噶": 6098,
+  "闵": 6099,
+  "檎": 6100,
+  "櫛": 6101,
+  "Å": 6102,
+  "忒": 6103,
+  "朹": 6104,
+  "飽": 6105,
+  "騷": 6106,
+  "闊": 6107,
+  "囂": 6108,
+  "覿": 6109,
+  "輿": 6110,
+  "鉥": 6111,
+  "粹": 6112,
+  "觐": 6113,
+  "渔": 6114,
+  "濑": 6115,
+  "彝": 6116,
+  "屿": 6117,
+  "骋": 6118,
+  "汀": 6119,
+  "哺": 6120,
+  "駈": 6121,
+  "樅": 6122,
+  "麓": 6123,
+  "鉇": 6124,
+  "諠": 6125,
+  "嶺": 6126,
+  "雉": 6127,
+  "宵": 6128,
+  "截": 6129,
+  "簷": 6130,
+  "廁": 6131,
+  "嚇": 6132,
+  "膚": 6133,
+  "撓": 6134,
+  "俵": 6135,
+  "賄": 6136,
+  "賂": 6137,
+  "珈": 6138,
+  "琲": 6139,
+  "‘": 6140,
+  "骗": 6141,
+  "逞": 6142,
+  "漲": 6143,
+  "媚": 6144,
+  "ﾎ": 6145,
+  "ﾟ": 6146,
+  "酉": 6147,
+  "槿": 6148,
+  "馴": 6149,
+  "遡": 6150,
+  "鬨": 6151,
+  "拮": 6152,
+  "慣": 6153,
+  "榦": 6154,
+  "詄": 6155,
+  "躁": 6156,
+  "飈": 6157,
+  "阬": 6158,
+  "泀": 6159,
+  "踖": 6160,
+  "吝": 6161,
+  "靂": 6162,
+  "簾": 6163,
+  "贫": 6164,
+  "毙": 6165,
+  "頚": 6166,
+  "箪": 6167,
+  "忤": 6168,
+  "驷": 6169,
+  "庸": 6170,
+  "缭": 6171,
+  "彌": 6172,
+  "樓": 6173,
+  "扼": 6174,
+  "鉢": 6175,
+  "漣": 6176,
+  "濤": 6177,
+  "⑨": 6178,
+  "⑧": 6179,
+  "呉": 6180,
+  "⑩": 6181,
+  "⑦": 6182,
+  "飴": 6183,
+  "└": 6184,
+  "»": 6185,
+  "▒": 6186,
+  "╩": 6187,
+  "╨": 6188,
+  "╔": 6189,
+  "篷": 6190,
+  "嘿": 6191,
+  "唷": 6192,
+  "圓": 6193,
+  "痩": 6194,
+  "嗤": 6195,
+  "裹": 6196,
+  "徙": 6197,
+  "窖": 6198
+}