diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..d4edbbd1ad70361b8cc6c7543766a007dce4f55b
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,45 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+core.o filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..68bc17f9ff2104a9d7b6777058bb4c343ca72609
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+# For a library or package, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+# This is especially recommended for binary packages to ensure reproducibility, and is more
+# commonly ignored for libraries.
+# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+# in version control.
+# https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+# and can be added to the global gitignore or merged into this file. For a more nuclear
+# option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
diff --git a/Bert_VITS2_Guide.ipynb b/Bert_VITS2_Guide.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a9021650aba40ba72a430b3d6b393ec52729c19a
--- /dev/null
+++ b/Bert_VITS2_Guide.ipynb
@@ -0,0 +1,323 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "authorship_tag": "ABX9TyP+PQNqeOew0Ap+hzVH7i8r",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 0. 如果使用AutoDL,请运行下载packages的加速代码:"
+ ],
+ "metadata": {
+ "id": "CGg4SV4ObQaT"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "MgfAJzoHbK2-"
+ },
+ "outputs": [],
+ "source": [
+ "!source /etc/network_turbo\n",
+ "!python -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 1. 数据集重采样和标注"
+ ],
+ "metadata": {
+ "id": "sloMn00-bgxY"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import subprocess\n",
+ "import random\n",
+ "import os\n",
+ "from pathlib import Path\n",
+ "import librosa\n",
+ "from scipy.io import wavfile\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "import csv\n",
+ "import whisper\n",
+ "\n",
+ "a=\"linghua\" # 请在这里修改说话人的名字,目前只支持中文语音\n",
+ "\n",
+ "def split_long_audio(model, filepaths, save_dir=\"data_dir\", out_sr=44100):\n",
+ " if isinstance(filepaths, str):\n",
+ " filepaths = [filepaths]\n",
+ "\n",
+ " for file_idx, filepath in enumerate(filepaths):\n",
+ "\n",
+ " save_path = Path(save_dir)\n",
+ " save_path.mkdir(exist_ok=True, parents=True)\n",
+ "\n",
+ " print(f\"Transcribing file {file_idx}: '{filepath}' to segments...\")\n",
+ " result = model.transcribe(filepath, word_timestamps=True, task=\"transcribe\", beam_size=5, best_of=5)\n",
+ " segments = result['segments']\n",
+ "\n",
+ " wav, sr = librosa.load(filepath, sr=None, offset=0, duration=None, mono=True)\n",
+ " wav, _ = librosa.effects.trim(wav, top_db=20)\n",
+ " peak = np.abs(wav).max()\n",
+ " if peak > 1.0:\n",
+ " wav = 0.98 * wav / peak\n",
+ " wav2 = librosa.resample(wav, orig_sr=sr, target_sr=out_sr)\n",
+ " wav2 /= max(wav2.max(), -wav2.min())\n",
+ "\n",
+ " for i, seg in enumerate(segments):\n",
+ " start_time = seg['start']\n",
+ " end_time = seg['end']\n",
+ " wav_seg = wav2[int(start_time * out_sr):int(end_time * out_sr)]\n",
+ " wav_seg_name = f\"{a}_{i}.wav\" # 在上方可修改名字\n",
+ " out_fpath = save_path / wav_seg_name\n",
+ " wavfile.write(out_fpath, rate=out_sr, data=(wav_seg * np.iinfo(np.int16).max).astype(np.int16))"
+ ],
+ "metadata": {
+ "id": "LtLBGhGCbYYh"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "whisper_size = \"large\"\n",
+ "whisper_model = whisper.load_model(whisper_size)"
+ ],
+ "metadata": {
+ "id": "--wS7X95b--m"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 请将下方的**linghua.wav**修改成自己的.wav文件名,路径./custom_character_voice/**linghua**/也可以改为自己的角色名\n"
+ ],
+ "metadata": {
+ "id": "0wAE5HRXcCQ_"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "split_long_audio(whisper_model, \"./linghua.wav\", \"./custom_character_voice/linghua/\")"
+ ],
+ "metadata": {
+ "id": "3f7ljJhCcEbd"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python short_audio_transcribe.py --languages \"C\" --whisper_size large"
+ ],
+ "metadata": {
+ "id": "rBJDPe3ccVrP"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### 处理完成后,可以打开\"./filelists/short_character_anno.list\"文件进行微调"
+ ],
+ "metadata": {
+ "id": "4pesbcMjcikn"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 2. 文本处理"
+ ],
+ "metadata": {
+ "id": "9pxo4KL-ceGI"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python preprocess_text.py"
+ ],
+ "metadata": {
+ "id": "_xfO2r_0cgCT"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 3. 运行bert_gen.py"
+ ],
+ "metadata": {
+ "id": "DoDs7lL6cu01"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python bert_gen.py"
+ ],
+ "metadata": {
+ "id": "jyiT28B3cxWX"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 4. 训练"
+ ],
+ "metadata": {
+ "id": "dHQPDFdbc04g"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### 可以在\"./configs/config.json\"更改训练参数,包括epoch,学习率等"
+ ],
+ "metadata": {
+ "id": "gHNws-IUc6Sd"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "cd monotonic_align"
+ ],
+ "metadata": {
+ "id": "S56s0emH8BqN"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python setup.py build_ext --inplace"
+ ],
+ "metadata": {
+ "id": "6rLsyel-8KKc"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "cd .."
+ ],
+ "metadata": {
+ "id": "mUgA6ho2-XAN"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### 若为首次训练,请运行:"
+ ],
+ "metadata": {
+ "id": "8vJ6VF__dCYW"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python train_ms.py -c ./configs/config.json"
+ ],
+ "metadata": {
+ "id": "iwHCWVijc5h6"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### 若为继续训练,请运行:"
+ ],
+ "metadata": {
+ "id": "skAGULw2dKXW"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python train_ms.py -c ./configs/config.json --cont"
+ ],
+ "metadata": {
+ "id": "Ru09Gmavc2t4"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 5. 推理"
+ ],
+ "metadata": {
+ "id": "IinmucfadVLU"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#### 请将下方的**G_lastest.pth**修改为最新的模型文件,如**G_3400.pth**"
+ ],
+ "metadata": {
+ "id": "psBRLH_TdZDb"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python inference_webui.py --model_dir ./logs/OUTPUT_MODEL/G_latest.pth"
+ ],
+ "metadata": {
+ "id": "lOWVtUgMdUZa"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f288702d2fa16d3cdf0035b15a9fcbc552cd88e7
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,674 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ Copyright (C)
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+.
diff --git a/MODELS/DLM.pth b/MODELS/DLM.pth
new file mode 100644
index 0000000000000000000000000000000000000000..3d77e600a6ed52d442c9171d9da440a060dde796
--- /dev/null
+++ b/MODELS/DLM.pth
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f4187dbad0c4b817dfdb8e2db8b9bb35ed98280e2d5580215d346e416bbf82e
+size 629528157
diff --git a/MODELS/G_2900.pth b/MODELS/G_2900.pth
new file mode 100644
index 0000000000000000000000000000000000000000..ea754ee8619127cdc2547afe85fca06d00bc18ac
--- /dev/null
+++ b/MODELS/G_2900.pth
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04509249431a35303227a2476a68348089fc3552667bc225aa056b13895505d1
+size 629528157
diff --git a/MODELS/adorabledarling.pth b/MODELS/adorabledarling.pth
new file mode 100644
index 0000000000000000000000000000000000000000..bb6094f8eee25b78ff12a259214306ba38674e10
--- /dev/null
+++ b/MODELS/adorabledarling.pth
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:434ffd70ae4e3688bbfac4a5618363991f24e1205223ccbddcc2218a1d79d313
+size 629528157
diff --git a/MODELS/rabbit4900.pth b/MODELS/rabbit4900.pth
new file mode 100644
index 0000000000000000000000000000000000000000..47aa82ced87e027c09da7558852febe18db28b90
--- /dev/null
+++ b/MODELS/rabbit4900.pth
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:087be2e67ea98eff8937cf97a752be6386e803e6e7c4e2bbfdf684f30cf677ad
+size 629528157
diff --git a/MODELS/silverhandG_4400.pth b/MODELS/silverhandG_4400.pth
new file mode 100644
index 0000000000000000000000000000000000000000..49980bc984f1d00859e6c818d513e907cd08ddaa
--- /dev/null
+++ b/MODELS/silverhandG_4400.pth
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5fc0f7d1dfb6e03007830def07f7683f7d91bf2b73e6a54a007d91b354e22cb5
+size 629528157
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a1d572c39383d823eaf1728f444db120b113a740
--- /dev/null
+++ b/README.md
@@ -0,0 +1,13 @@
+---
+title: 声音生成测试
+emoji: ✨
+colorFrom: red
+colorTo: indigo
+sdk: gradio
+sdk_version: 3.36.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/README_zh.md b/README_zh.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/README_zh.md
@@ -0,0 +1 @@
+
diff --git a/app.py b/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..47b2121e800513b5426d2d4361969a141142d999
--- /dev/null
+++ b/app.py
@@ -0,0 +1,161 @@
+import sys, os
+
+if sys.platform == "darwin":
+ os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
+
+import logging
+
+logging.getLogger("numba").setLevel(logging.WARNING)
+logging.getLogger("markdown_it").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+logging.getLogger("matplotlib").setLevel(logging.WARNING)
+
+logging.basicConfig(level=logging.INFO, format="| %(name)s | %(levelname)s | %(message)s")
+
+logger = logging.getLogger(__name__)
+
+import torch
+import argparse
+import commons
+import utils
+from models import SynthesizerTrn
+from text.symbols import symbols
+from text import cleaned_text_to_sequence, get_bert
+from text.cleaner import clean_text
+import gradio as gr
+import webbrowser
+import soundfile as sf
+from datetime import datetime
+import pytz
+
+
+net_g = None
+models = {
+ "AdorableDarling": "./MODELS/adorabledarling.pth",
+ "Silverleg": "./MODELS/silverhandG_4400.pth",
+ "MoonLucidAloof": "./lMODELS/G_2900.pth",
+ "Rrabbitt": "./MODELS/rabbit4900.pth",
+ "Mainlade": "./MODELS/DLM.pth",
+}
+
+def get_text(text, language_str, hps):
+ norm_text, phone, tone, word2ph = clean_text(text, language_str)
+ phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
+
+ if hps.data.add_blank:
+ phone = commons.intersperse(phone, 0)
+ tone = commons.intersperse(tone, 0)
+ language = commons.intersperse(language, 0)
+ for i in range(len(word2ph)):
+ word2ph[i] = word2ph[i] * 2
+ word2ph[0] += 1
+ bert = get_bert(norm_text, word2ph, language_str)
+ del word2ph
+
+ assert bert.shape[-1] == len(phone)
+
+ phone = torch.LongTensor(phone)
+ tone = torch.LongTensor(tone)
+ language = torch.LongTensor(language)
+
+ return bert, phone, tone, language
+
+def infer(text, sdp_ratio, noise_scale, noise_scale_w, length_scale, sid, model_dir):
+ global net_g
+ bert, phones, tones, lang_ids = get_text(text, "ZH", hps)
+ with torch.no_grad():
+ x_tst=phones.to(device).unsqueeze(0)
+ tones=tones.to(device).unsqueeze(0)
+ lang_ids=lang_ids.to(device).unsqueeze(0)
+ bert = bert.to(device).unsqueeze(0)
+ x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
+ del phones
+ speakers = torch.LongTensor([hps.data.spk2id[sid]]).to(device)
+ audio = net_g.infer(x_tst, x_tst_lengths, speakers, tones, lang_ids, bert, sdp_ratio=sdp_ratio
+ , noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale)[0][0,0].data.cpu().float().numpy()
+ del x_tst, tones, lang_ids, bert, x_tst_lengths, speakers
+ sf.write("tmp.wav", audio, 44100)
+ return audio
+
+def convert_wav_to_mp3(wav_file):
+ tz = pytz.timezone('Asia/Shanghai')
+ now = datetime.now(tz).strftime('%m%d%H%M%S')
+ os.makedirs('out', exist_ok=True)
+ output_path_mp3 = os.path.join('out', f"{now}.mp3")
+
+ renamed_input_path = os.path.join('in', f"in.wav")
+ os.makedirs('in', exist_ok=True)
+ os.rename(wav_file.name, renamed_input_path)
+ command = ["ffmpeg", "-i", renamed_input_path, "-acodec", "libmp3lame", "-y", output_path_mp3]
+ os.system(" ".join(command))
+ return output_path_mp3
+
+def tts_generator(text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale, model):
+ global net_g
+ model_path = models[model]
+ net_g, _, _, _ = utils.load_checkpoint(model_path, net_g, None, skip_optimizer=True)
+ with torch.no_grad():
+ audio = infer(text, sdp_ratio=sdp_ratio, noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale, sid=speaker,model_dir=model)
+ with open('tmp.wav', 'rb') as wav_file:
+ mp3 = convert_wav_to_mp3(wav_file)
+ return "生成语音成功", (hps.data.sampling_rate, audio), mp3
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--model_dir", default="", help="path of your model")
+ parser.add_argument("--config_dir", default="./configs/config.json", help="path of your config file")
+ parser.add_argument("--share", default=False, help="make link public")
+ parser.add_argument("-d", "--debug", action="store_true", help="enable DEBUG-LEVEL log")
+
+ args = parser.parse_args()
+ if args.debug:
+ logger.info("Enable DEBUG-LEVEL log")
+ logging.basicConfig(level=logging.DEBUG)
+ hps = utils.get_hparams_from_file(args.config_dir)
+ device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+ net_g = SynthesizerTrn(
+ len(symbols),
+ hps.data.filter_length // 2 + 1,
+ hps.train.segment_size // hps.data.hop_length,
+ n_speakers=hps.data.n_speakers,
+ **hps.model).to(device)
+ _ = net_g.eval()
+
+
+ speaker_ids = hps.data.spk2id
+ speakers = list(speaker_ids.keys())
+
+ with gr.Blocks() as app:
+ with gr.Row():
+ with gr.Column():
+
+
+ gr.Markdown(value="""
+ 测试用
+ """)
+ text = gr.TextArea(label="Text", placeholder="Input Text Here",
+ value="在不在?能不能借给我三百块钱买可乐",info="使用huggingface的免费CPU进行推理,因此速度不快,一次性不要输入超过500汉字")
+
+ model = gr.Radio(choices=list(models.keys()), value=list(models.keys())[0], label='音声模型')
+ #model = gr.Dropdown(choices=models,value=models[0], label='音声模型')
+ speaker = gr.Radio(choices=speakers, value=speakers[0], label='Speaker')
+ gr.Markdown("生成参数,效果玄学")
+ sdp_ratio = gr.Slider(minimum=0, maximum=1, value=0.2, step=0.01, label='语调变化')
+ noise_scale = gr.Slider(minimum=0.1, maximum=1.5, value=0.5, step=0.01, label='感情变化')
+ noise_scale_w = gr.Slider(minimum=0.1, maximum=1.4, value=0.9, step=0.01, label='音节长度')
+ length_scale = gr.Slider(minimum=0.1, maximum=2, value=1, step=0.01, label='生成语音总长度')
+ btn = gr.Button("生成", variant="primary")
+ with gr.Column():
+ text_output = gr.Textbox(label="Message")
+ audio_output = gr.Audio(label="输出音频")
+ MP3_output = gr.File(label="WAV2MP3")
+ gr.Markdown(value="""
+
+ """)
+ btn.click(tts_generator,
+ inputs=[text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale, model],
+ outputs=[text_output, audio_output,MP3_output])
+
+
+ app.launch(show_error=True)
diff --git a/attentions.py b/attentions.py
new file mode 100644
index 0000000000000000000000000000000000000000..ecbdbc8be941a962046fc11fd6739b093112123e
--- /dev/null
+++ b/attentions.py
@@ -0,0 +1,343 @@
+import copy
+import math
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import commons
+import modules
+from torch.nn.utils import weight_norm, remove_weight_norm
+class LayerNorm(nn.Module):
+ def __init__(self, channels, eps=1e-5):
+ super().__init__()
+ self.channels = channels
+ self.eps = eps
+
+ self.gamma = nn.Parameter(torch.ones(channels))
+ self.beta = nn.Parameter(torch.zeros(channels))
+
+ def forward(self, x):
+ x = x.transpose(1, -1)
+ x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
+ return x.transpose(1, -1)
+
+
+
+@torch.jit.script
+def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
+ n_channels_int = n_channels[0]
+ in_act = input_a + input_b
+ t_act = torch.tanh(in_act[:, :n_channels_int, :])
+ s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
+ acts = t_act * s_act
+ return acts
+
+class Encoder(nn.Module):
+ def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, isflow = True, **kwargs):
+ super().__init__()
+ self.hidden_channels = hidden_channels
+ self.filter_channels = filter_channels
+ self.n_heads = n_heads
+ self.n_layers = n_layers
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.window_size = window_size
+ if isflow:
+ cond_layer = torch.nn.Conv1d(256, 2*hidden_channels*n_layers, 1)
+ self.cond_pre = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, 1)
+ self.cond_layer = weight_norm(cond_layer, name='weight')
+ self.gin_channels = 256
+ self.cond_layer_idx = self.n_layers
+ if 'gin_channels' in kwargs:
+ self.gin_channels = kwargs['gin_channels']
+ if self.gin_channels != 0:
+ self.spk_emb_linear = nn.Linear(self.gin_channels, self.hidden_channels)
+ # vits2 says 3rd block, so idx is 2 by default
+ self.cond_layer_idx = kwargs['cond_layer_idx'] if 'cond_layer_idx' in kwargs else 2
+ print(self.gin_channels, self.cond_layer_idx)
+ assert self.cond_layer_idx < self.n_layers, 'cond_layer_idx should be less than n_layers'
+ self.drop = nn.Dropout(p_dropout)
+ self.attn_layers = nn.ModuleList()
+ self.norm_layers_1 = nn.ModuleList()
+ self.ffn_layers = nn.ModuleList()
+ self.norm_layers_2 = nn.ModuleList()
+ for i in range(self.n_layers):
+ self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
+ self.norm_layers_1.append(LayerNorm(hidden_channels))
+ self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
+ self.norm_layers_2.append(LayerNorm(hidden_channels))
+ def forward(self, x, x_mask, g=None):
+ attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+ x = x * x_mask
+ for i in range(self.n_layers):
+ if i == self.cond_layer_idx and g is not None:
+ g = self.spk_emb_linear(g.transpose(1, 2))
+ g = g.transpose(1, 2)
+ x = x + g
+ x = x * x_mask
+ y = self.attn_layers[i](x, x, attn_mask)
+ y = self.drop(y)
+ x = self.norm_layers_1[i](x + y)
+
+ y = self.ffn_layers[i](x, x_mask)
+ y = self.drop(y)
+ x = self.norm_layers_2[i](x + y)
+ x = x * x_mask
+ return x
+
+
+class Decoder(nn.Module):
+ def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
+ super().__init__()
+ self.hidden_channels = hidden_channels
+ self.filter_channels = filter_channels
+ self.n_heads = n_heads
+ self.n_layers = n_layers
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.proximal_bias = proximal_bias
+ self.proximal_init = proximal_init
+
+ self.drop = nn.Dropout(p_dropout)
+ self.self_attn_layers = nn.ModuleList()
+ self.norm_layers_0 = nn.ModuleList()
+ self.encdec_attn_layers = nn.ModuleList()
+ self.norm_layers_1 = nn.ModuleList()
+ self.ffn_layers = nn.ModuleList()
+ self.norm_layers_2 = nn.ModuleList()
+ for i in range(self.n_layers):
+ self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
+ self.norm_layers_0.append(LayerNorm(hidden_channels))
+ self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
+ self.norm_layers_1.append(LayerNorm(hidden_channels))
+ self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
+ self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+ def forward(self, x, x_mask, h, h_mask):
+ """
+ x: decoder input
+ h: encoder output
+ """
+ self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
+ encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+ x = x * x_mask
+ for i in range(self.n_layers):
+ y = self.self_attn_layers[i](x, x, self_attn_mask)
+ y = self.drop(y)
+ x = self.norm_layers_0[i](x + y)
+
+ y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
+ y = self.drop(y)
+ x = self.norm_layers_1[i](x + y)
+
+ y = self.ffn_layers[i](x, x_mask)
+ y = self.drop(y)
+ x = self.norm_layers_2[i](x + y)
+ x = x * x_mask
+ return x
+
+
+class MultiHeadAttention(nn.Module):
+ def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
+ super().__init__()
+ assert channels % n_heads == 0
+
+ self.channels = channels
+ self.out_channels = out_channels
+ self.n_heads = n_heads
+ self.p_dropout = p_dropout
+ self.window_size = window_size
+ self.heads_share = heads_share
+ self.block_length = block_length
+ self.proximal_bias = proximal_bias
+ self.proximal_init = proximal_init
+ self.attn = None
+
+ self.k_channels = channels // n_heads
+ self.conv_q = nn.Conv1d(channels, channels, 1)
+ self.conv_k = nn.Conv1d(channels, channels, 1)
+ self.conv_v = nn.Conv1d(channels, channels, 1)
+ self.conv_o = nn.Conv1d(channels, out_channels, 1)
+ self.drop = nn.Dropout(p_dropout)
+
+ if window_size is not None:
+ n_heads_rel = 1 if heads_share else n_heads
+ rel_stddev = self.k_channels**-0.5
+ self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+ self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+
+ nn.init.xavier_uniform_(self.conv_q.weight)
+ nn.init.xavier_uniform_(self.conv_k.weight)
+ nn.init.xavier_uniform_(self.conv_v.weight)
+ if proximal_init:
+ with torch.no_grad():
+ self.conv_k.weight.copy_(self.conv_q.weight)
+ self.conv_k.bias.copy_(self.conv_q.bias)
+
+ def forward(self, x, c, attn_mask=None):
+ q = self.conv_q(x)
+ k = self.conv_k(c)
+ v = self.conv_v(c)
+
+ x, self.attn = self.attention(q, k, v, mask=attn_mask)
+
+ x = self.conv_o(x)
+ return x
+
+ def attention(self, query, key, value, mask=None):
+ # reshape [b, d, t] -> [b, n_h, t, d_k]
+ b, d, t_s, t_t = (*key.size(), query.size(2))
+ query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
+ key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+ value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+
+ scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
+ if self.window_size is not None:
+ assert t_s == t_t, "Relative attention is only available for self-attention."
+ key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
+ rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
+ scores_local = self._relative_position_to_absolute_position(rel_logits)
+ scores = scores + scores_local
+ if self.proximal_bias:
+ assert t_s == t_t, "Proximal bias is only available for self-attention."
+ scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
+ if mask is not None:
+ scores = scores.masked_fill(mask == 0, -1e4)
+ if self.block_length is not None:
+ assert t_s == t_t, "Local attention is only available for self-attention."
+ block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
+ scores = scores.masked_fill(block_mask == 0, -1e4)
+ p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
+ p_attn = self.drop(p_attn)
+ output = torch.matmul(p_attn, value)
+ if self.window_size is not None:
+ relative_weights = self._absolute_position_to_relative_position(p_attn)
+ value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
+ output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
+ output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
+ return output, p_attn
+
+ def _matmul_with_relative_values(self, x, y):
+ """
+ x: [b, h, l, m]
+ y: [h or 1, m, d]
+ ret: [b, h, l, d]
+ """
+ ret = torch.matmul(x, y.unsqueeze(0))
+ return ret
+
+ def _matmul_with_relative_keys(self, x, y):
+ """
+ x: [b, h, l, d]
+ y: [h or 1, m, d]
+ ret: [b, h, l, m]
+ """
+ ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
+ return ret
+
+ def _get_relative_embeddings(self, relative_embeddings, length):
+ max_relative_position = 2 * self.window_size + 1
+ # Pad first before slice to avoid using cond ops.
+ pad_length = max(length - (self.window_size + 1), 0)
+ slice_start_position = max((self.window_size + 1) - length, 0)
+ slice_end_position = slice_start_position + 2 * length - 1
+ if pad_length > 0:
+ padded_relative_embeddings = F.pad(
+ relative_embeddings,
+ commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
+ else:
+ padded_relative_embeddings = relative_embeddings
+ used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
+ return used_relative_embeddings
+
+ def _relative_position_to_absolute_position(self, x):
+ """
+ x: [b, h, l, 2*l-1]
+ ret: [b, h, l, l]
+ """
+ batch, heads, length, _ = x.size()
+ # Concat columns of pad to shift from relative to absolute indexing.
+ x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
+
+ # Concat extra elements so to add up to shape (len+1, 2*len-1).
+ x_flat = x.view([batch, heads, length * 2 * length])
+ x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
+
+ # Reshape and slice out the padded elements.
+ x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
+ return x_final
+
+ def _absolute_position_to_relative_position(self, x):
+ """
+ x: [b, h, l, l]
+ ret: [b, h, l, 2*l-1]
+ """
+ batch, heads, length, _ = x.size()
+ # padd along column
+ x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
+ x_flat = x.view([batch, heads, length**2 + length*(length -1)])
+ # add 0's in the beginning that will skew the elements after reshape
+ x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
+ x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
+ return x_final
+
+ def _attention_bias_proximal(self, length):
+ """Bias for self-attention to encourage attention to close positions.
+ Args:
+ length: an integer scalar.
+ Returns:
+ a Tensor with shape [1, 1, length, length]
+ """
+ r = torch.arange(length, dtype=torch.float32)
+ diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
+ return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
+
+
+class FFN(nn.Module):
+ def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.filter_channels = filter_channels
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.activation = activation
+ self.causal = causal
+
+ if causal:
+ self.padding = self._causal_padding
+ else:
+ self.padding = self._same_padding
+
+ self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
+ self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
+ self.drop = nn.Dropout(p_dropout)
+
+ def forward(self, x, x_mask):
+ x = self.conv_1(self.padding(x * x_mask))
+ if self.activation == "gelu":
+ x = x * torch.sigmoid(1.702 * x)
+ else:
+ x = torch.relu(x)
+ x = self.drop(x)
+ x = self.conv_2(self.padding(x * x_mask))
+ return x * x_mask
+
+ def _causal_padding(self, x):
+ if self.kernel_size == 1:
+ return x
+ pad_l = self.kernel_size - 1
+ pad_r = 0
+ padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+ x = F.pad(x, commons.convert_pad_shape(padding))
+ return x
+
+ def _same_padding(self, x):
+ if self.kernel_size == 1:
+ return x
+ pad_l = (self.kernel_size - 1) // 2
+ pad_r = self.kernel_size // 2
+ padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+ x = F.pad(x, commons.convert_pad_shape(padding))
+ return x
diff --git a/bert/chinese-roberta-wwm-ext-large/added_tokens.json b/bert/chinese-roberta-wwm-ext-large/added_tokens.json
new file mode 100644
index 0000000000000000000000000000000000000000..9e26dfeeb6e641a33dae4961196235bdb965b21b
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/added_tokens.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/bert/chinese-roberta-wwm-ext-large/config.json b/bert/chinese-roberta-wwm-ext-large/config.json
new file mode 100644
index 0000000000000000000000000000000000000000..920741798717df58aa766c378de136df3053b609
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/config.json
@@ -0,0 +1,28 @@
+{
+ "architectures": [
+ "BertForMaskedLM"
+ ],
+ "attention_probs_dropout_prob": 0.1,
+ "bos_token_id": 0,
+ "directionality": "bidi",
+ "eos_token_id": 2,
+ "hidden_act": "gelu",
+ "hidden_dropout_prob": 0.1,
+ "hidden_size": 1024,
+ "initializer_range": 0.02,
+ "intermediate_size": 4096,
+ "layer_norm_eps": 1e-12,
+ "max_position_embeddings": 512,
+ "model_type": "bert",
+ "num_attention_heads": 16,
+ "num_hidden_layers": 24,
+ "output_past": true,
+ "pad_token_id": 0,
+ "pooler_fc_size": 768,
+ "pooler_num_attention_heads": 12,
+ "pooler_num_fc_layers": 3,
+ "pooler_size_per_head": 128,
+ "pooler_type": "first_token_transform",
+ "type_vocab_size": 2,
+ "vocab_size": 21128
+}
diff --git a/bert/chinese-roberta-wwm-ext-large/flax_model.msgpack b/bert/chinese-roberta-wwm-ext-large/flax_model.msgpack
new file mode 100644
index 0000000000000000000000000000000000000000..8ead8b1d74914b95babe71f79b91fa7cdb929a54
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/flax_model.msgpack
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a46a510fe646213c728b80c9d0d5691d05235523d67f9ac3c3ce4e67deabf926
+size 1302196529
diff --git a/bert/chinese-roberta-wwm-ext-large/pytorch_model.bin b/bert/chinese-roberta-wwm-ext-large/pytorch_model.bin
new file mode 100644
index 0000000000000000000000000000000000000000..c99146ee87b5041ce25adbe69bbcbb99b9d46ce2
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/pytorch_model.bin
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ac62d49144d770c5ca9a5d1d3039c4995665a080febe63198189857c6bd11cd
+size 1306484351
diff --git a/bert/chinese-roberta-wwm-ext-large/special_tokens_map.json b/bert/chinese-roberta-wwm-ext-large/special_tokens_map.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7b0375001f109a6b8873d756ad4f7bbb15fbaa5
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/special_tokens_map.json
@@ -0,0 +1 @@
+{"unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]"}
\ No newline at end of file
diff --git a/bert/chinese-roberta-wwm-ext-large/tf_model.h5 b/bert/chinese-roberta-wwm-ext-large/tf_model.h5
new file mode 100644
index 0000000000000000000000000000000000000000..27e62bd43bcd8e23c6f0242a0a9e614a07a283da
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/tf_model.h5
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72d18616fb285b720cb869c25aa9f4d7371033dfd5d8ba82aca448fdd28132bf
+size 1302594480
diff --git a/bert/chinese-roberta-wwm-ext-large/tokenizer.json b/bert/chinese-roberta-wwm-ext-large/tokenizer.json
new file mode 100644
index 0000000000000000000000000000000000000000..eba64ab600f7bb029b38ac391b35651e3b55f185
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/tokenizer.json
@@ -0,0 +1 @@
+{"version":"1.0","truncation":null,"padding":null,"added_tokens":[{"id":0,"special":true,"content":"[PAD]","single_word":false,"lstrip":false,"rstrip":false,"normalized":false},{"id":100,"special":true,"content":"[UNK]","single_word":false,"lstrip":false,"rstrip":false,"normalized":false},{"id":101,"special":true,"content":"[CLS]","single_word":false,"lstrip":false,"rstrip":false,"normalized":false},{"id":102,"special":true,"content":"[SEP]","single_word":false,"lstrip":false,"rstrip":false,"normalized":false},{"id":103,"special":true,"content":"[MASK]","single_word":false,"lstrip":false,"rstrip":false,"normalized":false}],"normalizer":{"type":"BertNormalizer","clean_text":true,"handle_chinese_chars":true,"strip_accents":null,"lowercase":true},"pre_tokenizer":{"type":"BertPreTokenizer"},"post_processor":{"type":"TemplateProcessing","single":[{"SpecialToken":{"id":"[CLS]","type_id":0}},{"Sequence":{"id":"A","type_id":0}},{"SpecialToken":{"id":"[SEP]","type_id":0}}],"pair":[{"SpecialToken":{"id":"[CLS]","type_id":0}},{"Sequence":{"id":"A","type_id":0}},{"SpecialToken":{"id":"[SEP]","type_id":0}},{"Sequence":{"id":"B","type_id":1}},{"SpecialToken":{"id":"[SEP]","type_id":1}}],"special_tokens":{"[CLS]":{"id":"[CLS]","ids":[101],"tokens":["[CLS]"]},"[SEP]":{"id":"[SEP]","ids":[102],"tokens":["[SEP]"]}}},"decoder":{"type":"WordPiece","prefix":"##","cleanup":true},"model":{"type":"WordPiece","unk_token":"[UNK]","continuing_subword_prefix":"##","max_input_chars_per_word":100,"vocab":{"[PAD]":0,"[unused1]":1,"[unused2]":2,"[unused3]":3,"[unused4]":4,"[unused5]":5,"[unused6]":6,"[unused7]":7,"[unused8]":8,"[unused9]":9,"[unused10]":10,"[unused11]":11,"[unused12]":12,"[unused13]":13,"[unused14]":14,"[unused15]":15,"[unused16]":16,"[unused17]":17,"[unused18]":18,"[unused19]":19,"[unused20]":20,"[unused21]":21,"[unused22]":22,"[unused23]":23,"[unused24]":24,"[unused25]":25,"[unused26]":26,"[unused27]":27,"[unused28]":28,"[unused29]":29,"[unused30]":30,"[unused31]":31,"[unused32]":32,"[unused33]":33,"[unused34]":34,"[unused35]":35,"[unused36]":36,"[unused37]":37,"[unused38]":38,"[unused39]":39,"[unused40]":40,"[unused41]":41,"[unused42]":42,"[unused43]":43,"[unused44]":44,"[unused45]":45,"[unused46]":46,"[unused47]":47,"[unused48]":48,"[unused49]":49,"[unused50]":50,"[unused51]":51,"[unused52]":52,"[unused53]":53,"[unused54]":54,"[unused55]":55,"[unused56]":56,"[unused57]":57,"[unused58]":58,"[unused59]":59,"[unused60]":60,"[unused61]":61,"[unused62]":62,"[unused63]":63,"[unused64]":64,"[unused65]":65,"[unused66]":66,"[unused67]":67,"[unused68]":68,"[unused69]":69,"[unused70]":70,"[unused71]":71,"[unused72]":72,"[unused73]":73,"[unused74]":74,"[unused75]":75,"[unused76]":76,"[unused77]":77,"[unused78]":78,"[unused79]":79,"[unused80]":80,"[unused81]":81,"[unused82]":82,"[unused83]":83,"[unused84]":84,"[unused85]":85,"[unused86]":86,"[unused87]":87,"[unused88]":88,"[unused89]":89,"[unused90]":90,"[unused91]":91,"[unused92]":92,"[unused93]":93,"[unused94]":94,"[unused95]":95,"[unused96]":96,"[unused97]":97,"[unused98]":98,"[unused99]":99,"[UNK]":100,"[CLS]":101,"[SEP]":102,"[MASK]":103,"":104,"":105,"!":106,"\"":107,"#":108,"$":109,"%":110,"&":111,"'":112,"(":113,")":114,"*":115,"+":116,",":117,"-":118,".":119,"/":120,"0":121,"1":122,"2":123,"3":124,"4":125,"5":126,"6":127,"7":128,"8":129,"9":130,":":131,";":132,"<":133,"=":134,">":135,"?":136,"@":137,"[":138,"\\":139,"]":140,"^":141,"_":142,"a":143,"b":144,"c":145,"d":146,"e":147,"f":148,"g":149,"h":150,"i":151,"j":152,"k":153,"l":154,"m":155,"n":156,"o":157,"p":158,"q":159,"r":160,"s":161,"t":162,"u":163,"v":164,"w":165,"x":166,"y":167,"z":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,"β":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,"襟":6199,"襠":6200,"襪":6201,"襬":6202,"襯":6203,"襲":6204,"西":6205,"要":6206,"覃":6207,"覆":6208,"覇":6209,"見":6210,"規":6211,"覓":6212,"視":6213,"覚":6214,"覦":6215,"覧":6216,"親":6217,"覬":6218,"観":6219,"覷":6220,"覺":6221,"覽":6222,"觀":6223,"见":6224,"观":6225,"规":6226,"觅":6227,"视":6228,"览":6229,"觉":6230,"觊":6231,"觎":6232,"觐":6233,"觑":6234,"角":6235,"觞":6236,"解":6237,"觥":6238,"触":6239,"觸":6240,"言":6241,"訂":6242,"計":6243,"訊":6244,"討":6245,"訓":6246,"訕":6247,"訖":6248,"託":6249,"記":6250,"訛":6251,"訝":6252,"訟":6253,"訣":6254,"訥":6255,"訪":6256,"設":6257,"許":6258,"訳":6259,"訴":6260,"訶":6261,"診":6262,"註":6263,"証":6264,"詆":6265,"詐":6266,"詔":6267,"評":6268,"詛":6269,"詞":6270,"詠":6271,"詡":6272,"詢":6273,"詣":6274,"試":6275,"詩":6276,"詫":6277,"詬":6278,"詭":6279,"詮":6280,"詰":6281,"話":6282,"該":6283,"詳":6284,"詹":6285,"詼":6286,"誅":6287,"誇":6288,"誉":6289,"誌":6290,"認":6291,"誓":6292,"誕":6293,"誘":6294,"語":6295,"誠":6296,"誡":6297,"誣":6298,"誤":6299,"誥":6300,"誦":6301,"誨":6302,"說":6303,"説":6304,"読":6305,"誰":6306,"課":6307,"誹":6308,"誼":6309,"調":6310,"諄":6311,"談":6312,"請":6313,"諏":6314,"諒":6315,"論":6316,"諗":6317,"諜":6318,"諡":6319,"諦":6320,"諧":6321,"諫":6322,"諭":6323,"諮":6324,"諱":6325,"諳":6326,"諷":6327,"諸":6328,"諺":6329,"諾":6330,"謀":6331,"謁":6332,"謂":6333,"謄":6334,"謊":6335,"謎":6336,"謐":6337,"謔":6338,"謗":6339,"謙":6340,"講":6341,"謝":6342,"謠":6343,"謨":6344,"謬":6345,"謹":6346,"謾":6347,"譁":6348,"證":6349,"譎":6350,"譏":6351,"識":6352,"譙":6353,"譚":6354,"譜":6355,"警":6356,"譬":6357,"譯":6358,"議":6359,"譲":6360,"譴":6361,"護":6362,"譽":6363,"讀":6364,"變":6365,"讓":6366,"讚":6367,"讞":6368,"计":6369,"订":6370,"认":6371,"讥":6372,"讧":6373,"讨":6374,"让":6375,"讪":6376,"讫":6377,"训":6378,"议":6379,"讯":6380,"记":6381,"讲":6382,"讳":6383,"讴":6384,"讶":6385,"讷":6386,"许":6387,"讹":6388,"论":6389,"讼":6390,"讽":6391,"设":6392,"访":6393,"诀":6394,"证":6395,"诃":6396,"评":6397,"诅":6398,"识":6399,"诈":6400,"诉":6401,"诊":6402,"诋":6403,"词":6404,"诏":6405,"译":6406,"试":6407,"诗":6408,"诘":6409,"诙":6410,"诚":6411,"诛":6412,"话":6413,"诞":6414,"诟":6415,"诠":6416,"诡":6417,"询":6418,"诣":6419,"诤":6420,"该":6421,"详":6422,"诧":6423,"诩":6424,"诫":6425,"诬":6426,"语":6427,"误":6428,"诰":6429,"诱":6430,"诲":6431,"说":6432,"诵":6433,"诶":6434,"请":6435,"诸":6436,"诺":6437,"读":6438,"诽":6439,"课":6440,"诿":6441,"谀":6442,"谁":6443,"调":6444,"谄":6445,"谅":6446,"谆":6447,"谈":6448,"谊":6449,"谋":6450,"谌":6451,"谍":6452,"谎":6453,"谏":6454,"谐":6455,"谑":6456,"谒":6457,"谓":6458,"谔":6459,"谕":6460,"谗":6461,"谘":6462,"谙":6463,"谚":6464,"谛":6465,"谜":6466,"谟":6467,"谢":6468,"谣":6469,"谤":6470,"谥":6471,"谦":6472,"谧":6473,"谨":6474,"谩":6475,"谪":6476,"谬":6477,"谭":6478,"谯":6479,"谱":6480,"谲":6481,"谴":6482,"谶":6483,"谷":6484,"豁":6485,"豆":6486,"豇":6487,"豈":6488,"豉":6489,"豊":6490,"豌":6491,"豎":6492,"豐":6493,"豔":6494,"豚":6495,"象":6496,"豢":6497,"豪":6498,"豫":6499,"豬":6500,"豹":6501,"豺":6502,"貂":6503,"貅":6504,"貌":6505,"貓":6506,"貔":6507,"貘":6508,"貝":6509,"貞":6510,"負":6511,"財":6512,"貢":6513,"貧":6514,"貨":6515,"販":6516,"貪":6517,"貫":6518,"責":6519,"貯":6520,"貰":6521,"貳":6522,"貴":6523,"貶":6524,"買":6525,"貸":6526,"費":6527,"貼":6528,"貽":6529,"貿":6530,"賀":6531,"賁":6532,"賂":6533,"賃":6534,"賄":6535,"資":6536,"賈":6537,"賊":6538,"賑":6539,"賓":6540,"賜":6541,"賞":6542,"賠":6543,"賡":6544,"賢":6545,"賣":6546,"賤":6547,"賦":6548,"質":6549,"賬":6550,"賭":6551,"賴":6552,"賺":6553,"購":6554,"賽":6555,"贅":6556,"贈":6557,"贊":6558,"贍":6559,"贏":6560,"贓":6561,"贖":6562,"贛":6563,"贝":6564,"贞":6565,"负":6566,"贡":6567,"财":6568,"责":6569,"贤":6570,"败":6571,"账":6572,"货":6573,"质":6574,"贩":6575,"贪":6576,"贫":6577,"贬":6578,"购":6579,"贮":6580,"贯":6581,"贰":6582,"贱":6583,"贲":6584,"贴":6585,"贵":6586,"贷":6587,"贸":6588,"费":6589,"贺":6590,"贻":6591,"贼":6592,"贾":6593,"贿":6594,"赁":6595,"赂":6596,"赃":6597,"资":6598,"赅":6599,"赈":6600,"赊":6601,"赋":6602,"赌":6603,"赎":6604,"赏":6605,"赐":6606,"赓":6607,"赔":6608,"赖":6609,"赘":6610,"赚":6611,"赛":6612,"赝":6613,"赞":6614,"赠":6615,"赡":6616,"赢":6617,"赣":6618,"赤":6619,"赦":6620,"赧":6621,"赫":6622,"赭":6623,"走":6624,"赳":6625,"赴":6626,"赵":6627,"赶":6628,"起":6629,"趁":6630,"超":6631,"越":6632,"趋":6633,"趕":6634,"趙":6635,"趟":6636,"趣":6637,"趨":6638,"足":6639,"趴":6640,"趵":6641,"趸":6642,"趺":6643,"趾":6644,"跃":6645,"跄":6646,"跆":6647,"跋":6648,"跌":6649,"跎":6650,"跑":6651,"跖":6652,"跚":6653,"跛":6654,"距":6655,"跟":6656,"跡":6657,"跤":6658,"跨":6659,"跩":6660,"跪":6661,"路":6662,"跳":6663,"践":6664,"跷":6665,"跹":6666,"跺":6667,"跻":6668,"踉":6669,"踊":6670,"踌":6671,"踏":6672,"踐":6673,"踝":6674,"踞":6675,"踟":6676,"踢":6677,"踩":6678,"踪":6679,"踮":6680,"踱":6681,"踴":6682,"踵":6683,"踹":6684,"蹂":6685,"蹄":6686,"蹇":6687,"蹈":6688,"蹉":6689,"蹊":6690,"蹋":6691,"蹑":6692,"蹒":6693,"蹙":6694,"蹟":6695,"蹣":6696,"蹤":6697,"蹦":6698,"蹩":6699,"蹬":6700,"蹭":6701,"蹲":6702,"蹴":6703,"蹶":6704,"蹺":6705,"蹼":6706,"蹿":6707,"躁":6708,"躇":6709,"躉":6710,"躊":6711,"躋":6712,"躍":6713,"躏":6714,"躪":6715,"身":6716,"躬":6717,"躯":6718,"躲":6719,"躺":6720,"軀":6721,"車":6722,"軋":6723,"軌":6724,"軍":6725,"軒":6726,"軟":6727,"転":6728,"軸":6729,"軼":6730,"軽":6731,"軾":6732,"較":6733,"載":6734,"輒":6735,"輓":6736,"輔":6737,"輕":6738,"輛":6739,"輝":6740,"輟":6741,"輩":6742,"輪":6743,"輯":6744,"輸":6745,"輻":6746,"輾":6747,"輿":6748,"轄":6749,"轅":6750,"轆":6751,"轉":6752,"轍":6753,"轎":6754,"轟":6755,"车":6756,"轧":6757,"轨":6758,"轩":6759,"转":6760,"轭":6761,"轮":6762,"软":6763,"轰":6764,"轲":6765,"轴":6766,"轶":6767,"轻":6768,"轼":6769,"载":6770,"轿":6771,"较":6772,"辄":6773,"辅":6774,"辆":6775,"辇":6776,"辈":6777,"辉":6778,"辊":6779,"辍":6780,"辐":6781,"辑":6782,"输":6783,"辕":6784,"辖":6785,"辗":6786,"辘":6787,"辙":6788,"辛":6789,"辜":6790,"辞":6791,"辟":6792,"辣":6793,"辦":6794,"辨":6795,"辩":6796,"辫":6797,"辭":6798,"辮":6799,"辯":6800,"辰":6801,"辱":6802,"農":6803,"边":6804,"辺":6805,"辻":6806,"込":6807,"辽":6808,"达":6809,"迁":6810,"迂":6811,"迄":6812,"迅":6813,"过":6814,"迈":6815,"迎":6816,"运":6817,"近":6818,"返":6819,"还":6820,"这":6821,"进":6822,"远":6823,"违":6824,"连":6825,"迟":6826,"迢":6827,"迤":6828,"迥":6829,"迦":6830,"迩":6831,"迪":6832,"迫":6833,"迭":6834,"述":6835,"迴":6836,"迷":6837,"迸":6838,"迹":6839,"迺":6840,"追":6841,"退":6842,"送":6843,"适":6844,"逃":6845,"逅":6846,"逆":6847,"选":6848,"逊":6849,"逍":6850,"透":6851,"逐":6852,"递":6853,"途":6854,"逕":6855,"逗":6856,"這":6857,"通":6858,"逛":6859,"逝":6860,"逞":6861,"速":6862,"造":6863,"逢":6864,"連":6865,"逮":6866,"週":6867,"進":6868,"逵":6869,"逶":6870,"逸":6871,"逻":6872,"逼":6873,"逾":6874,"遁":6875,"遂":6876,"遅":6877,"遇":6878,"遊":6879,"運":6880,"遍":6881,"過":6882,"遏":6883,"遐":6884,"遑":6885,"遒":6886,"道":6887,"達":6888,"違":6889,"遗":6890,"遙":6891,"遛":6892,"遜":6893,"遞":6894,"遠":6895,"遢":6896,"遣":6897,"遥":6898,"遨":6899,"適":6900,"遭":6901,"遮":6902,"遲":6903,"遴":6904,"遵":6905,"遶":6906,"遷":6907,"選":6908,"遺":6909,"遼":6910,"遽":6911,"避":6912,"邀":6913,"邁":6914,"邂":6915,"邃":6916,"還":6917,"邇":6918,"邈":6919,"邊":6920,"邋":6921,"邏":6922,"邑":6923,"邓":6924,"邕":6925,"邛":6926,"邝":6927,"邢":6928,"那":6929,"邦":6930,"邨":6931,"邪":6932,"邬":6933,"邮":6934,"邯":6935,"邰":6936,"邱":6937,"邳":6938,"邵":6939,"邸":6940,"邹":6941,"邺":6942,"邻":6943,"郁":6944,"郅":6945,"郊":6946,"郎":6947,"郑":6948,"郜":6949,"郝":6950,"郡":6951,"郢":6952,"郤":6953,"郦":6954,"郧":6955,"部":6956,"郫":6957,"郭":6958,"郴":6959,"郵":6960,"郷":6961,"郸":6962,"都":6963,"鄂":6964,"鄉":6965,"鄒":6966,"鄔":6967,"鄙":6968,"鄞":6969,"鄢":6970,"鄧":6971,"鄭":6972,"鄰":6973,"鄱":6974,"鄲":6975,"鄺":6976,"酉":6977,"酊":6978,"酋":6979,"酌":6980,"配":6981,"酐":6982,"酒":6983,"酗":6984,"酚":6985,"酝":6986,"酢":6987,"酣":6988,"酥":6989,"酩":6990,"酪":6991,"酬":6992,"酮":6993,"酯":6994,"酰":6995,"酱":6996,"酵":6997,"酶":6998,"酷":6999,"酸":7000,"酿":7001,"醃":7002,"醇":7003,"醉":7004,"醋":7005,"醍":7006,"醐":7007,"醒":7008,"醚":7009,"醛":7010,"醜":7011,"醞":7012,"醣":7013,"醪":7014,"醫":7015,"醬":7016,"醮":7017,"醯":7018,"醴":7019,"醺":7020,"釀":7021,"釁":7022,"采":7023,"釉":7024,"释":7025,"釋":7026,"里":7027,"重":7028,"野":7029,"量":7030,"釐":7031,"金":7032,"釗":7033,"釘":7034,"釜":7035,"針":7036,"釣":7037,"釦":7038,"釧":7039,"釵":7040,"鈀":7041,"鈉":7042,"鈍":7043,"鈎":7044,"鈔":7045,"鈕":7046,"鈞":7047,"鈣":7048,"鈦":7049,"鈪":7050,"鈴":7051,"鈺":7052,"鈾":7053,"鉀":7054,"鉄":7055,"鉅":7056,"鉉":7057,"鉑":7058,"鉗":7059,"鉚":7060,"鉛":7061,"鉤":7062,"鉴":7063,"鉻":7064,"銀":7065,"銃":7066,"銅":7067,"銑":7068,"銓":7069,"銖":7070,"銘":7071,"銜":7072,"銬":7073,"銭":7074,"銮":7075,"銳":7076,"銷":7077,"銹":7078,"鋁":7079,"鋅":7080,"鋒":7081,"鋤":7082,"鋪":7083,"鋰":7084,"鋸":7085,"鋼":7086,"錄":7087,"錐":7088,"錘":7089,"錚":7090,"錠":7091,"錢":7092,"錦":7093,"錨":7094,"錫":7095,"錮":7096,"錯":7097,"録":7098,"錳":7099,"錶":7100,"鍊":7101,"鍋":7102,"鍍":7103,"鍛":7104,"鍥":7105,"鍰":7106,"鍵":7107,"鍺":7108,"鍾":7109,"鎂":7110,"鎊":7111,"鎌":7112,"鎏":7113,"鎔":7114,"鎖":7115,"鎗":7116,"鎚":7117,"鎧":7118,"鎬":7119,"鎮":7120,"鎳":7121,"鏈":7122,"鏖":7123,"鏗":7124,"鏘":7125,"鏞":7126,"鏟":7127,"鏡":7128,"鏢":7129,"鏤":7130,"鏽":7131,"鐘":7132,"鐮":7133,"鐲":7134,"鐳":7135,"鐵":7136,"鐸":7137,"鐺":7138,"鑄":7139,"鑊":7140,"鑑":7141,"鑒":7142,"鑣":7143,"鑫":7144,"鑰":7145,"鑲":7146,"鑼":7147,"鑽":7148,"鑾":7149,"鑿":7150,"针":7151,"钉":7152,"钊":7153,"钎":7154,"钏":7155,"钒":7156,"钓":7157,"钗":7158,"钙":7159,"钛":7160,"钜":7161,"钝":7162,"钞":7163,"钟":7164,"钠":7165,"钡":7166,"钢":7167,"钣":7168,"钤":7169,"钥":7170,"钦":7171,"钧":7172,"钨":7173,"钩":7174,"钮":7175,"钯":7176,"钰":7177,"钱":7178,"钳":7179,"钴":7180,"钵":7181,"钺":7182,"钻":7183,"钼":7184,"钾":7185,"钿":7186,"铀":7187,"铁":7188,"铂":7189,"铃":7190,"铄":7191,"铅":7192,"铆":7193,"铉":7194,"铎":7195,"铐":7196,"铛":7197,"铜":7198,"铝":7199,"铠":7200,"铡":7201,"铢":7202,"铣":7203,"铤":7204,"铨":7205,"铩":7206,"铬":7207,"铭":7208,"铮":7209,"铰":7210,"铲":7211,"铵":7212,"银":7213,"铸":7214,"铺":7215,"链":7216,"铿":7217,"销":7218,"锁":7219,"锂":7220,"锄":7221,"锅":7222,"锆":7223,"锈":7224,"锉":7225,"锋":7226,"锌":7227,"锏":7228,"锐":7229,"锑":7230,"错":7231,"锚":7232,"锟":7233,"锡":7234,"锢":7235,"锣":7236,"锤":7237,"锥":7238,"锦":7239,"锭":7240,"键":7241,"锯":7242,"锰":7243,"锲":7244,"锵":7245,"锹":7246,"锺":7247,"锻":7248,"镀":7249,"镁":7250,"镂":7251,"镇":7252,"镉":7253,"镌":7254,"镍":7255,"镐":7256,"镑":7257,"镕":7258,"镖":7259,"镗":7260,"镛":7261,"镜":7262,"镣":7263,"镭":7264,"镯":7265,"镰":7266,"镳":7267,"镶":7268,"長":7269,"长":7270,"門":7271,"閃":7272,"閉":7273,"開":7274,"閎":7275,"閏":7276,"閑":7277,"閒":7278,"間":7279,"閔":7280,"閘":7281,"閡":7282,"関":7283,"閣":7284,"閥":7285,"閨":7286,"閩":7287,"閱":7288,"閲":7289,"閹":7290,"閻":7291,"閾":7292,"闆":7293,"闇":7294,"闊":7295,"闌":7296,"闍":7297,"闔":7298,"闕":7299,"闖":7300,"闘":7301,"關":7302,"闡":7303,"闢":7304,"门":7305,"闪":7306,"闫":7307,"闭":7308,"问":7309,"闯":7310,"闰":7311,"闲":7312,"间":7313,"闵":7314,"闷":7315,"闸":7316,"闹":7317,"闺":7318,"闻":7319,"闽":7320,"闾":7321,"阀":7322,"阁":7323,"阂":7324,"阅":7325,"阆":7326,"阇":7327,"阈":7328,"阉":7329,"阎":7330,"阐":7331,"阑":7332,"阔":7333,"阕":7334,"阖":7335,"阙":7336,"阚":7337,"阜":7338,"队":7339,"阡":7340,"阪":7341,"阮":7342,"阱":7343,"防":7344,"阳":7345,"阴":7346,"阵":7347,"阶":7348,"阻":7349,"阿":7350,"陀":7351,"陂":7352,"附":7353,"际":7354,"陆":7355,"陇":7356,"陈":7357,"陋":7358,"陌":7359,"降":7360,"限":7361,"陕":7362,"陛":7363,"陝":7364,"陞":7365,"陟":7366,"陡":7367,"院":7368,"陣":7369,"除":7370,"陨":7371,"险":7372,"陪":7373,"陰":7374,"陲":7375,"陳":7376,"陵":7377,"陶":7378,"陷":7379,"陸":7380,"険":7381,"陽":7382,"隅":7383,"隆":7384,"隈":7385,"隊":7386,"隋":7387,"隍":7388,"階":7389,"随":7390,"隐":7391,"隔":7392,"隕":7393,"隘":7394,"隙":7395,"際":7396,"障":7397,"隠":7398,"隣":7399,"隧":7400,"隨":7401,"險":7402,"隱":7403,"隴":7404,"隶":7405,"隸":7406,"隻":7407,"隼":7408,"隽":7409,"难":7410,"雀":7411,"雁":7412,"雄":7413,"雅":7414,"集":7415,"雇":7416,"雉":7417,"雋":7418,"雌":7419,"雍":7420,"雎":7421,"雏":7422,"雑":7423,"雒":7424,"雕":7425,"雖":7426,"雙":7427,"雛":7428,"雜":7429,"雞":7430,"離":7431,"難":7432,"雨":7433,"雪":7434,"雯":7435,"雰":7436,"雲":7437,"雳":7438,"零":7439,"雷":7440,"雹":7441,"電":7442,"雾":7443,"需":7444,"霁":7445,"霄":7446,"霆":7447,"震":7448,"霈":7449,"霉":7450,"霊":7451,"霍":7452,"霎":7453,"霏":7454,"霑":7455,"霓":7456,"霖":7457,"霜":7458,"霞":7459,"霧":7460,"霭":7461,"霰":7462,"露":7463,"霸":7464,"霹":7465,"霽":7466,"霾":7467,"靂":7468,"靄":7469,"靈":7470,"青":7471,"靓":7472,"靖":7473,"静":7474,"靚":7475,"靛":7476,"靜":7477,"非":7478,"靠":7479,"靡":7480,"面":7481,"靥":7482,"靦":7483,"革":7484,"靳":7485,"靴":7486,"靶":7487,"靼":7488,"鞅":7489,"鞋":7490,"鞍":7491,"鞏":7492,"鞑":7493,"鞘":7494,"鞠":7495,"鞣":7496,"鞦":7497,"鞭":7498,"韆":7499,"韋":7500,"韌":7501,"韓":7502,"韜":7503,"韦":7504,"韧":7505,"韩":7506,"韬":7507,"韭":7508,"音":7509,"韵":7510,"韶":7511,"韻":7512,"響":7513,"頁":7514,"頂":7515,"頃":7516,"項":7517,"順":7518,"須":7519,"頌":7520,"預":7521,"頑":7522,"頒":7523,"頓":7524,"頗":7525,"領":7526,"頜":7527,"頡":7528,"頤":7529,"頫":7530,"頭":7531,"頰":7532,"頷":7533,"頸":7534,"頹":7535,"頻":7536,"頼":7537,"顆":7538,"題":7539,"額":7540,"顎":7541,"顏":7542,"顔":7543,"願":7544,"顛":7545,"類":7546,"顧":7547,"顫":7548,"顯":7549,"顱":7550,"顴":7551,"页":7552,"顶":7553,"顷":7554,"项":7555,"顺":7556,"须":7557,"顼":7558,"顽":7559,"顾":7560,"顿":7561,"颁":7562,"颂":7563,"预":7564,"颅":7565,"领":7566,"颇":7567,"颈":7568,"颉":7569,"颊":7570,"颌":7571,"颍":7572,"颐":7573,"频":7574,"颓":7575,"颔":7576,"颖":7577,"颗":7578,"题":7579,"颚":7580,"颛":7581,"颜":7582,"额":7583,"颞":7584,"颠":7585,"颡":7586,"颢":7587,"颤":7588,"颦":7589,"颧":7590,"風":7591,"颯":7592,"颱":7593,"颳":7594,"颶":7595,"颼":7596,"飄":7597,"飆":7598,"风":7599,"飒":7600,"飓":7601,"飕":7602,"飘":7603,"飙":7604,"飚":7605,"飛":7606,"飞":7607,"食":7608,"飢":7609,"飨":7610,"飩":7611,"飪":7612,"飯":7613,"飲":7614,"飼":7615,"飽":7616,"飾":7617,"餃":7618,"餅":7619,"餉":7620,"養":7621,"餌":7622,"餐":7623,"餒":7624,"餓":7625,"餘":7626,"餚":7627,"餛":7628,"餞":7629,"餡":7630,"館":7631,"餮":7632,"餵":7633,"餾":7634,"饅":7635,"饈":7636,"饋":7637,"饌":7638,"饍":7639,"饑":7640,"饒":7641,"饕":7642,"饗":7643,"饞":7644,"饥":7645,"饨":7646,"饪":7647,"饬":7648,"饭":7649,"饮":7650,"饯":7651,"饰":7652,"饱":7653,"饲":7654,"饴":7655,"饵":7656,"饶":7657,"饷":7658,"饺":7659,"饼":7660,"饽":7661,"饿":7662,"馀":7663,"馁":7664,"馄":7665,"馅":7666,"馆":7667,"馈":7668,"馋":7669,"馍":7670,"馏":7671,"馒":7672,"馔":7673,"首":7674,"馗":7675,"香":7676,"馥":7677,"馨":7678,"馬":7679,"馭":7680,"馮":7681,"馳":7682,"馴":7683,"駁":7684,"駄":7685,"駅":7686,"駆":7687,"駐":7688,"駒":7689,"駕":7690,"駛":7691,"駝":7692,"駭":7693,"駱":7694,"駿":7695,"騁":7696,"騎":7697,"騏":7698,"験":7699,"騙":7700,"騨":7701,"騰":7702,"騷":7703,"驀":7704,"驅":7705,"驊":7706,"驍":7707,"驒":7708,"驕":7709,"驗":7710,"驚":7711,"驛":7712,"驟":7713,"驢":7714,"驥":7715,"马":7716,"驭":7717,"驮":7718,"驯":7719,"驰":7720,"驱":7721,"驳":7722,"驴":7723,"驶":7724,"驷":7725,"驸":7726,"驹":7727,"驻":7728,"驼":7729,"驾":7730,"驿":7731,"骁":7732,"骂":7733,"骄":7734,"骅":7735,"骆":7736,"骇":7737,"骈":7738,"骊":7739,"骋":7740,"验":7741,"骏":7742,"骐":7743,"骑":7744,"骗":7745,"骚":7746,"骛":7747,"骜":7748,"骞":7749,"骠":7750,"骡":7751,"骤":7752,"骥":7753,"骧":7754,"骨":7755,"骯":7756,"骰":7757,"骶":7758,"骷":7759,"骸":7760,"骼":7761,"髂":7762,"髅":7763,"髋":7764,"髏":7765,"髒":7766,"髓":7767,"體":7768,"髖":7769,"高":7770,"髦":7771,"髪":7772,"髮":7773,"髯":7774,"髻":7775,"鬃":7776,"鬆":7777,"鬍":7778,"鬓":7779,"鬚":7780,"鬟":7781,"鬢":7782,"鬣":7783,"鬥":7784,"鬧":7785,"鬱":7786,"鬼":7787,"魁":7788,"魂":7789,"魄":7790,"魅":7791,"魇":7792,"魍":7793,"魏":7794,"魔":7795,"魘":7796,"魚":7797,"魯":7798,"魷":7799,"鮑":7800,"鮨":7801,"鮪":7802,"鮭":7803,"鮮":7804,"鯉":7805,"鯊":7806,"鯖":7807,"鯛":7808,"鯨":7809,"鯰":7810,"鯽":7811,"鰍":7812,"鰓":7813,"鰭":7814,"鰲":7815,"鰻":7816,"鰾":7817,"鱈":7818,"鱉":7819,"鱔":7820,"鱗":7821,"鱷":7822,"鱸":7823,"鱼":7824,"鱿":7825,"鲁":7826,"鲈":7827,"鲍":7828,"鲑":7829,"鲛":7830,"鲜":7831,"鲟":7832,"鲢":7833,"鲤":7834,"鲨":7835,"鲫":7836,"鲱":7837,"鲲":7838,"鲶":7839,"鲷":7840,"鲸":7841,"鳃":7842,"鳄":7843,"鳅":7844,"鳌":7845,"鳍":7846,"鳕":7847,"鳖":7848,"鳗":7849,"鳝":7850,"鳞":7851,"鳥":7852,"鳩":7853,"鳳":7854,"鳴":7855,"鳶":7856,"鴉":7857,"鴕":7858,"鴛":7859,"鴦":7860,"鴨":7861,"鴻":7862,"鴿":7863,"鵑":7864,"鵜":7865,"鵝":7866,"鵡":7867,"鵬":7868,"鵰":7869,"鵲":7870,"鶘":7871,"鶩":7872,"鶯":7873,"鶴":7874,"鷗":7875,"鷲":7876,"鷹":7877,"鷺":7878,"鸚":7879,"鸞":7880,"鸟":7881,"鸠":7882,"鸡":7883,"鸢":7884,"鸣":7885,"鸥":7886,"鸦":7887,"鸨":7888,"鸪":7889,"鸭":7890,"鸯":7891,"鸳":7892,"鸵":7893,"鸽":7894,"鸾":7895,"鸿":7896,"鹂":7897,"鹃":7898,"鹄":7899,"鹅":7900,"鹈":7901,"鹉":7902,"鹊":7903,"鹌":7904,"鹏":7905,"鹑":7906,"鹕":7907,"鹘":7908,"鹜":7909,"鹞":7910,"鹤":7911,"鹦":7912,"鹧":7913,"鹫":7914,"鹭":7915,"鹰":7916,"鹳":7917,"鹵":7918,"鹹":7919,"鹼":7920,"鹽":7921,"鹿":7922,"麂":7923,"麋":7924,"麒":7925,"麓":7926,"麗":7927,"麝":7928,"麟":7929,"麥":7930,"麦":7931,"麩":7932,"麴":7933,"麵":7934,"麸":7935,"麺":7936,"麻":7937,"麼":7938,"麽":7939,"麾":7940,"黃":7941,"黄":7942,"黍":7943,"黎":7944,"黏":7945,"黑":7946,"黒":7947,"黔":7948,"默":7949,"黛":7950,"黜":7951,"黝":7952,"點":7953,"黠":7954,"黨":7955,"黯":7956,"黴":7957,"鼋":7958,"鼎":7959,"鼐":7960,"鼓":7961,"鼠":7962,"鼬":7963,"鼹":7964,"鼻":7965,"鼾":7966,"齁":7967,"齊":7968,"齋":7969,"齐":7970,"齒":7971,"齡":7972,"齢":7973,"齣":7974,"齦":7975,"齿":7976,"龄":7977,"龅":7978,"龈":7979,"龊":7980,"龋":7981,"龌":7982,"龍":7983,"龐":7984,"龔":7985,"龕":7986,"龙":7987,"龚":7988,"龛":7989,"龜":7990,"龟":7991,"︰":7992,"︱":7993,"︶":7994,"︿":7995,"﹁":7996,"﹂":7997,"﹍":7998,"﹏":7999,"﹐":8000,"﹑":8001,"﹒":8002,"﹔":8003,"﹕":8004,"﹖":8005,"﹗":8006,"﹙":8007,"﹚":8008,"﹝":8009,"﹞":8010,"﹡":8011,"﹣":8012,"!":8013,""":8014,"#":8015,"$":8016,"%":8017,"&":8018,"'":8019,"(":8020,")":8021,"*":8022,"+":8023,",":8024,"-":8025,".":8026,"/":8027,"0":8028,"1":8029,"2":8030,"3":8031,"4":8032,"5":8033,"6":8034,"7":8035,"8":8036,"9":8037,":":8038,";":8039,"<":8040,"=":8041,">":8042,"?":8043,"@":8044,"[":8045,"\":8046,"]":8047,"^":8048,"_":8049,"`":8050,"a":8051,"b":8052,"c":8053,"d":8054,"e":8055,"f":8056,"g":8057,"h":8058,"i":8059,"j":8060,"k":8061,"l":8062,"m":8063,"n":8064,"o":8065,"p":8066,"q":8067,"r":8068,"s":8069,"t":8070,"u":8071,"v":8072,"w":8073,"x":8074,"y":8075,"z":8076,"{":8077,"|":8078,"}":8079,"~":8080,"。":8081,"「":8082,"」":8083,"、":8084,"・":8085,"ッ":8086,"ー":8087,"イ":8088,"ク":8089,"シ":8090,"ス":8091,"ト":8092,"ノ":8093,"フ":8094,"ラ":8095,"ル":8096,"ン":8097,"゙":8098,"゚":8099," ̄":8100,"¥":8101,"👍":8102,"🔥":8103,"😂":8104,"😎":8105,"...":8106,"yam":8107,"10":8108,"2017":8109,"12":8110,"11":8111,"2016":8112,"20":8113,"30":8114,"15":8115,"06":8116,"lofter":8117,"##s":8118,"2015":8119,"by":8120,"16":8121,"14":8122,"18":8123,"13":8124,"24":8125,"17":8126,"2014":8127,"21":8128,"##0":8129,"22":8130,"19":8131,"25":8132,"23":8133,"com":8134,"100":8135,"00":8136,"05":8137,"2013":8138,"##a":8139,"03":8140,"09":8141,"08":8142,"28":8143,"##2":8144,"50":8145,"01":8146,"04":8147,"##1":8148,"27":8149,"02":8150,"2012":8151,"##3":8152,"26":8153,"##e":8154,"07":8155,"##8":8156,"##5":8157,"##6":8158,"##4":8159,"##9":8160,"##7":8161,"29":8162,"2011":8163,"40":8164,"##t":8165,"2010":8166,"##o":8167,"##d":8168,"##i":8169,"2009":8170,"##n":8171,"app":8172,"www":8173,"the":8174,"##m":8175,"31":8176,"##c":8177,"##l":8178,"##y":8179,"##r":8180,"##g":8181,"2008":8182,"60":8183,"http":8184,"200":8185,"qq":8186,"##p":8187,"80":8188,"##f":8189,"google":8190,"pixnet":8191,"90":8192,"cookies":8193,"tripadvisor":8194,"500":8195,"##er":8196,"##k":8197,"35":8198,"##h":8199,"facebook":8200,"2007":8201,"2000":8202,"70":8203,"##b":8204,"of":8205,"##x":8206,"##u":8207,"45":8208,"300":8209,"iphone":8210,"32":8211,"1000":8212,"2006":8213,"48":8214,"ip":8215,"36":8216,"in":8217,"38":8218,"3d":8219,"##w":8220,"##ing":8221,"55":8222,"ctrip":8223,"##on":8224,"##v":8225,"33":8226,"##の":8227,"to":8228,"34":8229,"400":8230,"id":8231,"2005":8232,"it":8233,"37":8234,"windows":8235,"llc":8236,"top":8237,"99":8238,"42":8239,"39":8240,"000":8241,"led":8242,"at":8243,"##an":8244,"41":8245,"51":8246,"52":8247,"46":8248,"49":8249,"43":8250,"53":8251,"44":8252,"##z":8253,"android":8254,"58":8255,"and":8256,"59":8257,"2004":8258,"56":8259,"vr":8260,"##か":8261,"5000":8262,"2003":8263,"47":8264,"blogthis":8265,"twitter":8266,"54":8267,"##le":8268,"150":8269,"ok":8270,"2018":8271,"57":8272,"75":8273,"cn":8274,"no":8275,"ios":8276,"##in":8277,"##mm":8278,"##00":8279,"800":8280,"on":8281,"te":8282,"3000":8283,"65":8284,"2001":8285,"360":8286,"95":8287,"ig":8288,"lv":8289,"120":8290,"##ng":8291,"##を":8292,"##us":8293,"##に":8294,"pc":8295,"てす":8296,"──":8297,"600":8298,"##te":8299,"85":8300,"2002":8301,"88":8302,"##ed":8303,"html":8304,"ncc":8305,"wifi":8306,"email":8307,"64":8308,"blog":8309,"is":8310,"##10":8311,"##て":8312,"mail":8313,"online":8314,"##al":8315,"dvd":8316,"##ic":8317,"studio":8318,"##は":8319,"##℃":8320,"##ia":8321,"##と":8322,"line":8323,"vip":8324,"72":8325,"##q":8326,"98":8327,"##ce":8328,"##en":8329,"for":8330,"##is":8331,"##ra":8332,"##es":8333,"##j":8334,"usb":8335,"net":8336,"cp":8337,"1999":8338,"asia":8339,"4g":8340,"##cm":8341,"diy":8342,"new":8343,"3c":8344,"##お":8345,"ta":8346,"66":8347,"language":8348,"vs":8349,"apple":8350,"tw":8351,"86":8352,"web":8353,"##ne":8354,"ipad":8355,"62":8356,"you":8357,"##re":8358,"101":8359,"68":8360,"##tion":8361,"ps":8362,"de":8363,"bt":8364,"pony":8365,"atm":8366,"##2017":8367,"1998":8368,"67":8369,"##ch":8370,"ceo":8371,"##or":8372,"go":8373,"##na":8374,"av":8375,"pro":8376,"cafe":8377,"96":8378,"pinterest":8379,"97":8380,"63":8381,"pixstyleme3c":8382,"##ta":8383,"more":8384,"said":8385,"##2016":8386,"1997":8387,"mp3":8388,"700":8389,"##ll":8390,"nba":8391,"jun":8392,"##20":8393,"92":8394,"tv":8395,"1995":8396,"pm":8397,"61":8398,"76":8399,"nbsp":8400,"250":8401,"##ie":8402,"linux":8403,"##ma":8404,"cd":8405,"110":8406,"hd":8407,"##17":8408,"78":8409,"##ion":8410,"77":8411,"6000":8412,"am":8413,"##th":8414,"##st":8415,"94":8416,"##se":8417,"##et":8418,"69":8419,"180":8420,"gdp":8421,"my":8422,"105":8423,"81":8424,"abc":8425,"89":8426,"flash":8427,"79":8428,"one":8429,"93":8430,"1990":8431,"1996":8432,"##ck":8433,"gps":8434,"##も":8435,"##ly":8436,"web885":8437,"106":8438,"2020":8439,"91":8440,"##ge":8441,"4000":8442,"1500":8443,"xd":8444,"boss":8445,"isbn":8446,"1994":8447,"org":8448,"##ry":8449,"me":8450,"love":8451,"##11":8452,"0fork":8453,"73":8454,"##12":8455,"3g":8456,"##ter":8457,"##ar":8458,"71":8459,"82":8460,"##la":8461,"hotel":8462,"130":8463,"1970":8464,"pk":8465,"83":8466,"87":8467,"140":8468,"ie":8469,"##os":8470,"##30":8471,"##el":8472,"74":8473,"##50":8474,"seo":8475,"cpu":8476,"##ml":8477,"p2p":8478,"84":8479,"may":8480,"##る":8481,"sun":8482,"tue":8483,"internet":8484,"cc":8485,"posted":8486,"youtube":8487,"##at":8488,"##ン":8489,"##man":8490,"ii":8491,"##ル":8492,"##15":8493,"abs":8494,"nt":8495,"pdf":8496,"yahoo":8497,"ago":8498,"1980":8499,"##it":8500,"news":8501,"mac":8502,"104":8503,"##てす":8504,"##me":8505,"##り":8506,"java":8507,"1992":8508,"spa":8509,"##de":8510,"##nt":8511,"hk":8512,"all":8513,"plus":8514,"la":8515,"1993":8516,"##mb":8517,"##16":8518,"##ve":8519,"west":8520,"##da":8521,"160":8522,"air":8523,"##い":8524,"##ps":8525,"から":8526,"##to":8527,"1989":8528,"logo":8529,"htc":8530,"php":8531,"https":8532,"fi":8533,"momo":8534,"##son":8535,"sat":8536,"##ke":8537,"##80":8538,"ebd":8539,"suv":8540,"wi":8541,"day":8542,"apk":8543,"##88":8544,"##um":8545,"mv":8546,"galaxy":8547,"wiki":8548,"or":8549,"brake":8550,"##ス":8551,"1200":8552,"する":8553,"this":8554,"1991":8555,"mon":8556,"##こ":8557,"❤2017":8558,"po":8559,"##ない":8560,"javascript":8561,"life":8562,"home":8563,"june":8564,"##ss":8565,"system":8566,"900":8567,"##ー":8568,"##0":8569,"pp":8570,"1988":8571,"world":8572,"fb":8573,"4k":8574,"br":8575,"##as":8576,"ic":8577,"ai":8578,"leonardo":8579,"safari":8580,"##60":8581,"live":8582,"free":8583,"xx":8584,"wed":8585,"win7":8586,"kiehl":8587,"##co":8588,"lg":8589,"o2o":8590,"##go":8591,"us":8592,"235":8593,"1949":8594,"mm":8595,"しい":8596,"vfm":8597,"kanye":8598,"##90":8599,"##2015":8600,"##id":8601,"jr":8602,"##ey":8603,"123":8604,"rss":8605,"##sa":8606,"##ro":8607,"##am":8608,"##no":8609,"thu":8610,"fri":8611,"350":8612,"##sh":8613,"##ki":8614,"103":8615,"comments":8616,"name":8617,"##のて":8618,"##pe":8619,"##ine":8620,"max":8621,"1987":8622,"8000":8623,"uber":8624,"##mi":8625,"##ton":8626,"wordpress":8627,"office":8628,"1986":8629,"1985":8630,"##ment":8631,"107":8632,"bd":8633,"win10":8634,"##ld":8635,"##li":8636,"gmail":8637,"bb":8638,"dior":8639,"##rs":8640,"##ri":8641,"##rd":8642,"##ます":8643,"up":8644,"cad":8645,"##®":8646,"dr":8647,"して":8648,"read":8649,"##21":8650,"をお":8651,"##io":8652,"##99":8653,"url":8654,"1984":8655,"pvc":8656,"paypal":8657,"show":8658,"policy":8659,"##40":8660,"##ty":8661,"##18":8662,"with":8663,"##★":8664,"##01":8665,"txt":8666,"102":8667,"##ba":8668,"dna":8669,"from":8670,"post":8671,"mini":8672,"ar":8673,"taiwan":8674,"john":8675,"##ga":8676,"privacy":8677,"agoda":8678,"##13":8679,"##ny":8680,"word":8681,"##24":8682,"##22":8683,"##by":8684,"##ur":8685,"##hz":8686,"1982":8687,"##ang":8688,"265":8689,"cookie":8690,"netscape":8691,"108":8692,"##ka":8693,"##~":8694,"##ad":8695,"house":8696,"share":8697,"note":8698,"ibm":8699,"code":8700,"hello":8701,"nike":8702,"sim":8703,"survey":8704,"##016":8705,"1979":8706,"1950":8707,"wikia":8708,"##32":8709,"##017":8710,"5g":8711,"cbc":8712,"##tor":8713,"##kg":8714,"1983":8715,"##rt":8716,"##14":8717,"campaign":8718,"store":8719,"2500":8720,"os":8721,"##ct":8722,"##ts":8723,"##°":8724,"170":8725,"api":8726,"##ns":8727,"365":8728,"excel":8729,"##な":8730,"##ao":8731,"##ら":8732,"##し":8733,"~~":8734,"##nd":8735,"university":8736,"163":8737,"には":8738,"518":8739,"##70":8740,"##ya":8741,"##il":8742,"##25":8743,"pierre":8744,"ipo":8745,"0020":8746,"897":8747,"##23":8748,"hotels":8749,"##ian":8750,"のお":8751,"125":8752,"years":8753,"6606":8754,"##ers":8755,"##26":8756,"high":8757,"##day":8758,"time":8759,"##ay":8760,"bug":8761,"##line":8762,"##く":8763,"##す":8764,"##be":8765,"xp":8766,"talk2yam":8767,"yamservice":8768,"10000":8769,"coco":8770,"##dy":8771,"sony":8772,"##ies":8773,"1978":8774,"microsoft":8775,"david":8776,"people":8777,"##ha":8778,"1960":8779,"instagram":8780,"intel":8781,"その":8782,"##ot":8783,"iso":8784,"1981":8785,"##va":8786,"115":8787,"##mo":8788,"##land":8789,"xxx":8790,"man":8791,"co":8792,"ltxsw":8793,"##ation":8794,"baby":8795,"220":8796,"##pa":8797,"##ol":8798,"1945":8799,"7000":8800,"tag":8801,"450":8802,"##ue":8803,"msn":8804,"##31":8805,"oppo":8806,"##ト":8807,"##ca":8808,"control":8809,"##om":8810,"st":8811,"chrome":8812,"##ure":8813,"##ん":8814,"be":8815,"##き":8816,"lol":8817,"##19":8818,"した":8819,"##bo":8820,"240":8821,"lady":8822,"##100":8823,"##way":8824,"##から":8825,"4600":8826,"##ko":8827,"##do":8828,"##un":8829,"4s":8830,"corporation":8831,"168":8832,"##ni":8833,"herme":8834,"##28":8835,"cp":8836,"978":8837,"##up":8838,"##06":8839,"ui":8840,"##ds":8841,"ppt":8842,"admin":8843,"three":8844,"します":8845,"bbc":8846,"re":8847,"128":8848,"##48":8849,"ca":8850,"##015":8851,"##35":8852,"hp":8853,"##ee":8854,"tpp":8855,"##た":8856,"##ive":8857,"××":8858,"root":8859,"##cc":8860,"##ました":8861,"##ble":8862,"##ity":8863,"adobe":8864,"park":8865,"114":8866,"et":8867,"oled":8868,"city":8869,"##ex":8870,"##ler":8871,"##ap":8872,"china":8873,"##book":8874,"20000":8875,"view":8876,"##ice":8877,"global":8878,"##km":8879,"your":8880,"hong":8881,"##mg":8882,"out":8883,"##ms":8884,"ng":8885,"ebay":8886,"##29":8887,"menu":8888,"ubuntu":8889,"##cy":8890,"rom":8891,"##view":8892,"open":8893,"ktv":8894,"do":8895,"server":8896,"##lo":8897,"if":8898,"english":8899,"##ね":8900,"##5":8901,"##oo":8902,"1600":8903,"##02":8904,"step1":8905,"kong":8906,"club":8907,"135":8908,"july":8909,"inc":8910,"1976":8911,"mr":8912,"hi":8913,"##net":8914,"touch":8915,"##ls":8916,"##ii":8917,"michael":8918,"lcd":8919,"##05":8920,"##33":8921,"phone":8922,"james":8923,"step2":8924,"1300":8925,"ios9":8926,"##box":8927,"dc":8928,"##2":8929,"##ley":8930,"samsung":8931,"111":8932,"280":8933,"pokemon":8934,"css":8935,"##ent":8936,"##les":8937,"いいえ":8938,"##1":8939,"s8":8940,"atom":8941,"play":8942,"bmw":8943,"##said":8944,"sa":8945,"etf":8946,"ctrl":8947,"♥yoyo♥":8948,"##55":8949,"2025":8950,"##2014":8951,"##66":8952,"adidas":8953,"amazon":8954,"1958":8955,"##ber":8956,"##ner":8957,"visa":8958,"##77":8959,"##der":8960,"1800":8961,"connectivity":8962,"##hi":8963,"firefox":8964,"109":8965,"118":8966,"hr":8967,"so":8968,"style":8969,"mark":8970,"pop":8971,"ol":8972,"skip":8973,"1975":8974,"as":8975,"##27":8976,"##ir":8977,"##61":8978,"190":8979,"mba":8980,"##う":8981,"##ai":8982,"le":8983,"##ver":8984,"1900":8985,"cafe2017":8986,"lte":8987,"super":8988,"113":8989,"129":8990,"##ron":8991,"amd":8992,"like":8993,"##☆":8994,"are":8995,"##ster":8996,"we":8997,"##sk":8998,"paul":8999,"data":9000,"international":9001,"##ft":9002,"longchamp":9003,"ssd":9004,"good":9005,"##ート":9006,"##ti":9007,"reply":9008,"##my":9009,"↓↓↓":9010,"apr":9011,"star":9012,"##ker":9013,"source":9014,"136":9015,"js":9016,"112":9017,"get":9018,"force":9019,"photo":9020,"##one":9021,"126":9022,"##2013":9023,"##ow":9024,"link":9025,"bbs":9026,"1972":9027,"goods":9028,"##lin":9029,"python":9030,"119":9031,"##ip":9032,"game":9033,"##ics":9034,"##ません":9035,"blue":9036,"##●":9037,"520":9038,"##45":9039,"page":9040,"itunes":9041,"##03":9042,"1955":9043,"260":9044,"1968":9045,"gt":9046,"gif":9047,"618":9048,"##ff":9049,"##47":9050,"group":9051,"くたさい":9052,"about":9053,"bar":9054,"ganji":9055,"##nce":9056,"music":9057,"lee":9058,"not":9059,"1977":9060,"1971":9061,"1973":9062,"##per":9063,"an":9064,"faq":9065,"comment":9066,"##って":9067,"days":9068,"##ock":9069,"116":9070,"##bs":9071,"1974":9072,"1969":9073,"v1":9074,"player":9075,"1956":9076,"xbox":9077,"sql":9078,"fm":9079,"f1":9080,"139":9081,"##ah":9082,"210":9083,"##lv":9084,"##mp":9085,"##000":9086,"melody":9087,"1957":9088,"##3":9089,"550":9090,"17life":9091,"199":9092,"1966":9093,"xml":9094,"market":9095,"##au":9096,"##71":9097,"999":9098,"##04":9099,"what":9100,"gl":9101,"##95":9102,"##age":9103,"tips":9104,"##68":9105,"book":9106,"##ting":9107,"mysql":9108,"can":9109,"1959":9110,"230":9111,"##ung":9112,"wonderland":9113,"watch":9114,"10℃":9115,"##ction":9116,"9000":9117,"mar":9118,"mobile":9119,"1946":9120,"1962":9121,"article":9122,"##db":9123,"part":9124,"▲top":9125,"party":9126,"って":9127,"1967":9128,"1964":9129,"1948":9130,"##07":9131,"##ore":9132,"##op":9133,"この":9134,"dj":9135,"##78":9136,"##38":9137,"010":9138,"main":9139,"225":9140,"1965":9141,"##ong":9142,"art":9143,"320":9144,"ad":9145,"134":9146,"020":9147,"##73":9148,"117":9149,"pm2":9150,"japan":9151,"228":9152,"##08":9153,"ts":9154,"1963":9155,"##ica":9156,"der":9157,"sm":9158,"##36":9159,"2019":9160,"##wa":9161,"ct":9162,"##7":9163,"##や":9164,"##64":9165,"1937":9166,"homemesh":9167,"search":9168,"##85":9169,"##れは":9170,"##tv":9171,"##di":9172,"macbook":9173,"##9":9174,"##くたさい":9175,"service":9176,"##♥":9177,"type":9178,"った":9179,"750":9180,"##ier":9181,"##si":9182,"##75":9183,"##います":9184,"##ok":9185,"best":9186,"##ット":9187,"goris":9188,"lock":9189,"##った":9190,"cf":9191,"3m":9192,"big":9193,"##ut":9194,"ftp":9195,"carol":9196,"##vi":9197,"10":9198,"1961":9199,"happy":9200,"sd":9201,"##ac":9202,"122":9203,"anti":9204,"pe":9205,"cnn":9206,"iii":9207,"1920":9208,"138":9209,"##ラ":9210,"1940":9211,"esp":9212,"jan":9213,"tags":9214,"##98":9215,"##51":9216,"august":9217,"vol":9218,"##86":9219,"154":9220,"##™":9221,"##fs":9222,"##れ":9223,"##sion":9224,"design":9225,"ac":9226,"##ム":9227,"press":9228,"jordan":9229,"ppp":9230,"that":9231,"key":9232,"check":9233,"##6":9234,"##tt":9235,"##㎡":9236,"1080p":9237,"##lt":9238,"power":9239,"##42":9240,"1952":9241,"##bc":9242,"vivi":9243,"##ック":9244,"he":9245,"133":9246,"121":9247,"jpg":9248,"##rry":9249,"201":9250,"175":9251,"3500":9252,"1947":9253,"nb":9254,"##ted":9255,"##rn":9256,"しています":9257,"1954":9258,"usd":9259,"##t00":9260,"master":9261,"##ンク":9262,"001":9263,"model":9264,"##58":9265,"al":9266,"##09":9267,"1953":9268,"##34":9269,"ram":9270,"goo":9271,"ても":9272,"##ui":9273,"127":9274,"1930":9275,"red":9276,"##ary":9277,"rpg":9278,"item":9279,"##pm":9280,"##41":9281,"270":9282,"##za":9283,"project":9284,"##2012":9285,"hot":9286,"td":9287,"blogabstract":9288,"##ger":9289,"##62":9290,"650":9291,"##44":9292,"gr2":9293,"##します":9294,"##m":9295,"black":9296,"electronic":9297,"nfc":9298,"year":9299,"asus":9300,"また":9301,"html5":9302,"cindy":9303,"##hd":9304,"m3":9305,"132":9306,"esc":9307,"##od":9308,"booking":9309,"##53":9310,"fed":9311,"tvb":9312,"##81":9313,"##ina":9314,"mit":9315,"165":9316,"##いる":9317,"chan":9318,"192":9319,"distribution":9320,"next":9321,"になる":9322,"peter":9323,"bios":9324,"steam":9325,"cm":9326,"1941":9327,"にも":9328,"pk10":9329,"##ix":9330,"##65":9331,"##91":9332,"dec":9333,"nasa":9334,"##ana":9335,"icecat":9336,"00z":9337,"b1":9338,"will":9339,"##46":9340,"li":9341,"se":9342,"##ji":9343,"##み":9344,"##ard":9345,"oct":9346,"##ain":9347,"jp":9348,"##ze":9349,"##bi":9350,"cio":9351,"##56":9352,"smart":9353,"h5":9354,"##39":9355,"##port":9356,"curve":9357,"vpn":9358,"##nm":9359,"##dia":9360,"utc":9361,"##あり":9362,"12345678910":9363,"##52":9364,"rmvb":9365,"chanel":9366,"a4":9367,"miss":9368,"##and":9369,"##im":9370,"media":9371,"who":9372,"##63":9373,"she":9374,"girl":9375,"5s":9376,"124":9377,"vera":9378,"##して":9379,"class":9380,"vivo":9381,"king":9382,"##フ":9383,"##ei":9384,"national":9385,"ab":9386,"1951":9387,"5cm":9388,"888":9389,"145":9390,"ipod":9391,"ap":9392,"1100":9393,"5mm":9394,"211":9395,"ms":9396,"2756":9397,"##69":9398,"mp4":9399,"msci":9400,"##po":9401,"##89":9402,"131":9403,"mg":9404,"index":9405,"380":9406,"##bit":9407,"##out":9408,"##zz":9409,"##97":9410,"##67":9411,"158":9412,"apec":9413,"##8":9414,"photoshop":9415,"opec":9416,"¥799":9417,"ては":9418,"##96":9419,"##tes":9420,"##ast":9421,"2g":9422,"○○":9423,"##ール":9424,"¥2899":9425,"##ling":9426,"##よ":9427,"##ory":9428,"1938":9429,"##ical":9430,"kitty":9431,"content":9432,"##43":9433,"step3":9434,"##cn":9435,"win8":9436,"155":9437,"vc":9438,"1400":9439,"iphone7":9440,"robert":9441,"##した":9442,"tcl":9443,"137":9444,"beauty":9445,"##87":9446,"en":9447,"dollars":9448,"##ys":9449,"##oc":9450,"step":9451,"pay":9452,"yy":9453,"a1":9454,"##2011":9455,"##lly":9456,"##ks":9457,"##♪":9458,"1939":9459,"188":9460,"download":9461,"1944":9462,"sep":9463,"exe":9464,"ph":9465,"います":9466,"school":9467,"gb":9468,"center":9469,"pr":9470,"street":9471,"##board":9472,"uv":9473,"##37":9474,"##lan":9475,"winrar":9476,"##que":9477,"##ua":9478,"##com":9479,"1942":9480,"1936":9481,"480":9482,"gpu":9483,"##4":9484,"ettoday":9485,"fu":9486,"tom":9487,"##54":9488,"##ren":9489,"##via":9490,"149":9491,"##72":9492,"b2b":9493,"144":9494,"##79":9495,"##tch":9496,"rose":9497,"arm":9498,"mb":9499,"##49":9500,"##ial":9501,"##nn":9502,"nvidia":9503,"step4":9504,"mvp":9505,"00㎡":9506,"york":9507,"156":9508,"##イ":9509,"how":9510,"cpi":9511,"591":9512,"2765":9513,"gov":9514,"kg":9515,"joe":9516,"##xx":9517,"mandy":9518,"pa":9519,"##ser":9520,"copyright":9521,"fashion":9522,"1935":9523,"don":9524,"##け":9525,"ecu":9526,"##ist":9527,"##art":9528,"erp":9529,"wap":9530,"have":9531,"##lm":9532,"talk":9533,"##ek":9534,"##ning":9535,"##if":9536,"ch":9537,"##ite":9538,"video":9539,"1943":9540,"cs":9541,"san":9542,"iot":9543,"look":9544,"##84":9545,"##2010":9546,"##ku":9547,"october":9548,"##ux":9549,"trump":9550,"##hs":9551,"##ide":9552,"box":9553,"141":9554,"first":9555,"##ins":9556,"april":9557,"##ight":9558,"##83":9559,"185":9560,"angel":9561,"protected":9562,"aa":9563,"151":9564,"162":9565,"x1":9566,"m2":9567,"##fe":9568,"##×":9569,"##ho":9570,"size":9571,"143":9572,"min":9573,"ofo":9574,"fun":9575,"gomaji":9576,"ex":9577,"hdmi":9578,"food":9579,"dns":9580,"march":9581,"chris":9582,"kevin":9583,"##のか":9584,"##lla":9585,"##pp":9586,"##ec":9587,"ag":9588,"ems":9589,"6s":9590,"720p":9591,"##rm":9592,"##ham":9593,"off":9594,"##92":9595,"asp":9596,"team":9597,"fandom":9598,"ed":9599,"299":9600,"▌♥":9601,"##ell":9602,"info":9603,"されています":9604,"##82":9605,"sina":9606,"4066":9607,"161":9608,"##able":9609,"##ctor":9610,"330":9611,"399":9612,"315":9613,"dll":9614,"rights":9615,"ltd":9616,"idc":9617,"jul":9618,"3kg":9619,"1927":9620,"142":9621,"ma":9622,"surface":9623,"##76":9624,"##ク":9625,"~~~":9626,"304":9627,"mall":9628,"eps":9629,"146":9630,"green":9631,"##59":9632,"map":9633,"space":9634,"donald":9635,"v2":9636,"sodu":9637,"##light":9638,"1931":9639,"148":9640,"1700":9641,"まて":9642,"310":9643,"reserved":9644,"htm":9645,"##han":9646,"##57":9647,"2d":9648,"178":9649,"mod":9650,"##ise":9651,"##tions":9652,"152":9653,"ti":9654,"##shi":9655,"doc":9656,"1933":9657,"icp":9658,"055":9659,"wang":9660,"##ram":9661,"shopping":9662,"aug":9663,"##pi":9664,"##well":9665,"now":9666,"wam":9667,"b2":9668,"からお":9669,"##hu":9670,"236":9671,"1928":9672,"##gb":9673,"266":9674,"f2":9675,"##93":9676,"153":9677,"mix":9678,"##ef":9679,"##uan":9680,"bwl":9681,"##plus":9682,"##res":9683,"core":9684,"##ess":9685,"tea":9686,"5℃":9687,"hktvmall":9688,"nhk":9689,"##ate":9690,"list":9691,"##ese":9692,"301":9693,"feb":9694,"4m":9695,"inn":9696,"ての":9697,"nov":9698,"159":9699,"12345":9700,"daniel":9701,"##ci":9702,"pass":9703,"##bet":9704,"##nk":9705,"coffee":9706,"202":9707,"ssl":9708,"airbnb":9709,"##ute":9710,"fbi":9711,"woshipm":9712,"skype":9713,"ea":9714,"cg":9715,"sp":9716,"##fc":9717,"##www":9718,"yes":9719,"edge":9720,"alt":9721,"007":9722,"##94":9723,"fpga":9724,"##ght":9725,"##gs":9726,"iso9001":9727,"さい":9728,"##ile":9729,"##wood":9730,"##uo":9731,"image":9732,"lin":9733,"icon":9734,"american":9735,"##em":9736,"1932":9737,"set":9738,"says":9739,"##king":9740,"##tive":9741,"blogger":9742,"##74":9743,"なと":9744,"256":9745,"147":9746,"##ox":9747,"##zy":9748,"##red":9749,"##ium":9750,"##lf":9751,"nokia":9752,"claire":9753,"##リ":9754,"##ding":9755,"november":9756,"lohas":9757,"##500":9758,"##tic":9759,"##マ":9760,"##cs":9761,"##ある":9762,"##che":9763,"##ire":9764,"##gy":9765,"##ult":9766,"db":9767,"january":9768,"win":9769,"##カ":9770,"166":9771,"road":9772,"ptt":9773,"##ま":9774,"##つ":9775,"198":9776,"##fa":9777,"##mer":9778,"anna":9779,"pchome":9780,"はい":9781,"udn":9782,"ef":9783,"420":9784,"##time":9785,"##tte":9786,"2030":9787,"##ア":9788,"g20":9789,"white":9790,"かかります":9791,"1929":9792,"308":9793,"garden":9794,"eleven":9795,"di":9796,"##おります":9797,"chen":9798,"309b":9799,"777":9800,"172":9801,"young":9802,"cosplay":9803,"ちてない":9804,"4500":9805,"bat":9806,"##123":9807,"##tra":9808,"##ては":9809,"kindle":9810,"npc":9811,"steve":9812,"etc":9813,"##ern":9814,"##|":9815,"call":9816,"xperia":9817,"ces":9818,"travel":9819,"sk":9820,"s7":9821,"##ous":9822,"1934":9823,"##int":9824,"みいたたけます":9825,"183":9826,"edu":9827,"file":9828,"cho":9829,"qr":9830,"##car":9831,"##our":9832,"186":9833,"##ant":9834,"##d":9835,"eric":9836,"1914":9837,"rends":9838,"##jo":9839,"##する":9840,"mastercard":9841,"##2000":9842,"kb":9843,"##min":9844,"290":9845,"##ino":9846,"vista":9847,"##ris":9848,"##ud":9849,"jack":9850,"2400":9851,"##set":9852,"169":9853,"pos":9854,"1912":9855,"##her":9856,"##ou":9857,"taipei":9858,"しく":9859,"205":9860,"beta":9861,"##ませんか":9862,"232":9863,"##fi":9864,"express":9865,"255":9866,"body":9867,"##ill":9868,"aphojoy":9869,"user":9870,"december":9871,"meiki":9872,"##ick":9873,"tweet":9874,"richard":9875,"##av":9876,"##ᆫ":9877,"iphone6":9878,"##dd":9879,"ちてすか":9880,"views":9881,"##mark":9882,"321":9883,"pd":9884,"##00":9885,"times":9886,"##▲":9887,"level":9888,"##ash":9889,"10g":9890,"point":9891,"5l":9892,"##ome":9893,"208":9894,"koreanmall":9895,"##ak":9896,"george":9897,"q2":9898,"206":9899,"wma":9900,"tcp":9901,"##200":9902,"スタッフ":9903,"full":9904,"mlb":9905,"##lle":9906,"##watch":9907,"tm":9908,"run":9909,"179":9910,"911":9911,"smith":9912,"business":9913,"##und":9914,"1919":9915,"color":9916,"##tal":9917,"222":9918,"171":9919,"##less":9920,"moon":9921,"4399":9922,"##rl":9923,"update":9924,"pcb":9925,"shop":9926,"499":9927,"157":9928,"little":9929,"なし":9930,"end":9931,"##mhz":9932,"van":9933,"dsp":9934,"easy":9935,"660":9936,"##house":9937,"##key":9938,"history":9939,"##o":9940,"oh":9941,"##001":9942,"##hy":9943,"##web":9944,"oem":9945,"let":9946,"was":9947,"##2009":9948,"##gg":9949,"review":9950,"##wan":9951,"182":9952,"##°c":9953,"203":9954,"uc":9955,"title":9956,"##val":9957,"united":9958,"233":9959,"2021":9960,"##ons":9961,"doi":9962,"trivago":9963,"overdope":9964,"sbs":9965,"##ance":9966,"##ち":9967,"grand":9968,"special":9969,"573032185":9970,"imf":9971,"216":9972,"wx17house":9973,"##so":9974,"##ーム":9975,"audi":9976,"##he":9977,"london":9978,"william":9979,"##rp":9980,"##ake":9981,"science":9982,"beach":9983,"cfa":9984,"amp":9985,"ps4":9986,"880":9987,"##800":9988,"##link":9989,"##hp":9990,"crm":9991,"ferragamo":9992,"bell":9993,"make":9994,"##eng":9995,"195":9996,"under":9997,"zh":9998,"photos":9999,"2300":10000,"##style":10001,"##ント":10002,"via":10003,"176":10004,"da":10005,"##gi":10006,"company":10007,"i7":10008,"##ray":10009,"thomas":10010,"370":10011,"ufo":10012,"i5":10013,"##max":10014,"plc":10015,"ben":10016,"back":10017,"research":10018,"8g":10019,"173":10020,"mike":10021,"##pc":10022,"##ッフ":10023,"september":10024,"189":10025,"##ace":10026,"vps":10027,"february":10028,"167":10029,"pantos":10030,"wp":10031,"lisa":10032,"1921":10033,"★★":10034,"jquery":10035,"night":10036,"long":10037,"offer":10038,"##berg":10039,"##news":10040,"1911":10041,"##いて":10042,"ray":10043,"fks":10044,"wto":10045,"せます":10046,"over":10047,"164":10048,"340":10049,"##all":10050,"##rus":10051,"1924":10052,"##888":10053,"##works":10054,"blogtitle":10055,"loftpermalink":10056,"##→":10057,"187":10058,"martin":10059,"test":10060,"ling":10061,"km":10062,"##め":10063,"15000":10064,"fda":10065,"v3":10066,"##ja":10067,"##ロ":10068,"wedding":10069,"かある":10070,"outlet":10071,"family":10072,"##ea":10073,"をこ":10074,"##top":10075,"story":10076,"##ness":10077,"salvatore":10078,"##lu":10079,"204":10080,"swift":10081,"215":10082,"room":10083,"している":10084,"oracle":10085,"##ul":10086,"1925":10087,"sam":10088,"b2c":10089,"week":10090,"pi":10091,"rock":10092,"##のは":10093,"##a":10094,"##けと":10095,"##ean":10096,"##300":10097,"##gle":10098,"cctv":10099,"after":10100,"chinese":10101,"##back":10102,"powered":10103,"x2":10104,"##tan":10105,"1918":10106,"##nes":10107,"##イン":10108,"canon":10109,"only":10110,"181":10111,"##zi":10112,"##las":10113,"say":10114,"##oe":10115,"184":10116,"##sd":10117,"221":10118,"##bot":10119,"##world":10120,"##zo":10121,"sky":10122,"made":10123,"top100":10124,"just":10125,"1926":10126,"pmi":10127,"802":10128,"234":10129,"gap":10130,"##vr":10131,"177":10132,"les":10133,"174":10134,"▲topoct":10135,"ball":10136,"vogue":10137,"vi":10138,"ing":10139,"ofweek":10140,"cos":10141,"##list":10142,"##ort":10143,"▲topmay":10144,"##なら":10145,"##lon":10146,"として":10147,"last":10148,"##tc":10149,"##of":10150,"##bus":10151,"##gen":10152,"real":10153,"eva":10154,"##コ":10155,"a3":10156,"nas":10157,"##lie":10158,"##ria":10159,"##coin":10160,"##bt":10161,"▲topapr":10162,"his":10163,"212":10164,"cat":10165,"nata":10166,"vive":10167,"health":10168,"⋯⋯":10169,"drive":10170,"sir":10171,"▲topmar":10172,"du":10173,"cup":10174,"##カー":10175,"##ook":10176,"##よう":10177,"##sy":10178,"alex":10179,"msg":10180,"tour":10181,"しました":10182,"3ce":10183,"##word":10184,"193":10185,"ebooks":10186,"r8":10187,"block":10188,"318":10189,"##より":10190,"2200":10191,"nice":10192,"pvp":10193,"207":10194,"months":10195,"1905":10196,"rewards":10197,"##ther":10198,"1917":10199,"0800":10200,"##xi":10201,"##チ":10202,"##sc":10203,"micro":10204,"850":10205,"gg":10206,"blogfp":10207,"op":10208,"1922":10209,"daily":10210,"m1":10211,"264":10212,"true":10213,"##bb":10214,"ml":10215,"##tar":10216,"##のお":10217,"##ky":10218,"anthony":10219,"196":10220,"253":10221,"##yo":10222,"state":10223,"218":10224,"##ara":10225,"##aa":10226,"##rc":10227,"##tz":10228,"##ston":10229,"より":10230,"gear":10231,"##eo":10232,"##ade":10233,"ge":10234,"see":10235,"1923":10236,"##win":10237,"##ura":10238,"ss":10239,"heart":10240,"##den":10241,"##ita":10242,"down":10243,"##sm":10244,"el":10245,"png":10246,"2100":10247,"610":10248,"rakuten":10249,"whatsapp":10250,"bay":10251,"dream":10252,"add":10253,"##use":10254,"680":10255,"311":10256,"pad":10257,"gucci":10258,"mpv":10259,"##ode":10260,"##fo":10261,"island":10262,"▲topjun":10263,"##▼":10264,"223":10265,"jason":10266,"214":10267,"chicago":10268,"##❤":10269,"しの":10270,"##hone":10271,"io":10272,"##れる":10273,"##ことか":10274,"sogo":10275,"be2":10276,"##ology":10277,"990":10278,"cloud":10279,"vcd":10280,"##con":10281,"2~3":10282,"##ford":10283,"##joy":10284,"##kb":10285,"##こさいます":10286,"##rade":10287,"but":10288,"##ach":10289,"docker":10290,"##ful":10291,"rfid":10292,"ul":10293,"##ase":10294,"hit":10295,"ford":10296,"##star":10297,"580":10298,"##○":10299,"11":10300,"a2":10301,"sdk":10302,"reading":10303,"edited":10304,"##are":10305,"cmos":10306,"##mc":10307,"238":10308,"siri":10309,"light":10310,"##ella":10311,"##ため":10312,"bloomberg":10313,"##read":10314,"pizza":10315,"##ison":10316,"jimmy":10317,"##vm":10318,"college":10319,"node":10320,"journal":10321,"ba":10322,"18k":10323,"##play":10324,"245":10325,"##cer":10326,"20":10327,"magic":10328,"##yu":10329,"191":10330,"jump":10331,"288":10332,"tt":10333,"##ings":10334,"asr":10335,"##lia":10336,"3200":10337,"step5":10338,"network":10339,"##cd":10340,"mc":10341,"いします":10342,"1234":10343,"pixstyleme":10344,"273":10345,"##600":10346,"2800":10347,"money":10348,"★★★★★":10349,"1280":10350,"12":10351,"430":10352,"bl":10353,"みの":10354,"act":10355,"##tus":10356,"tokyo":10357,"##rial":10358,"##life":10359,"emba":10360,"##ae":10361,"saas":10362,"tcs":10363,"##rk":10364,"##wang":10365,"summer":10366,"##sp":10367,"ko":10368,"##ving":10369,"390":10370,"premium":10371,"##その":10372,"netflix":10373,"##ヒ":10374,"uk":10375,"mt":10376,"##lton":10377,"right":10378,"frank":10379,"two":10380,"209":10381,"える":10382,"##ple":10383,"##cal":10384,"021":10385,"##んな":10386,"##sen":10387,"##ville":10388,"hold":10389,"nexus":10390,"dd":10391,"##ius":10392,"てお":10393,"##mah":10394,"##なく":10395,"tila":10396,"zero":10397,"820":10398,"ce":10399,"##tin":10400,"resort":10401,"##ws":10402,"charles":10403,"old":10404,"p10":10405,"5d":10406,"report":10407,"##360":10408,"##ru":10409,"##には":10410,"bus":10411,"vans":10412,"lt":10413,"##est":10414,"pv":10415,"##レ":10416,"links":10417,"rebecca":10418,"##ツ":10419,"##dm":10420,"azure":10421,"##365":10422,"きな":10423,"limited":10424,"bit":10425,"4gb":10426,"##mon":10427,"1910":10428,"moto":10429,"##eam":10430,"213":10431,"1913":10432,"var":10433,"eos":10434,"なとの":10435,"226":10436,"blogspot":10437,"された":10438,"699":10439,"e3":10440,"dos":10441,"dm":10442,"fc":10443,"##ments":10444,"##ik":10445,"##kw":10446,"boy":10447,"##bin":10448,"##ata":10449,"960":10450,"er":10451,"##せ":10452,"219":10453,"##vin":10454,"##tu":10455,"##ula":10456,"194":10457,"##∥":10458,"station":10459,"##ろ":10460,"##ature":10461,"835":10462,"files":10463,"zara":10464,"hdr":10465,"top10":10466,"nature":10467,"950":10468,"magazine":10469,"s6":10470,"marriott":10471,"##シ":10472,"avira":10473,"case":10474,"##っと":10475,"tab":10476,"##ran":10477,"tony":10478,"##home":10479,"oculus":10480,"im":10481,"##ral":10482,"jean":10483,"saint":10484,"cry":10485,"307":10486,"rosie":10487,"##force":10488,"##ini":10489,"ice":10490,"##bert":10491,"のある":10492,"##nder":10493,"##mber":10494,"pet":10495,"2600":10496,"##◆":10497,"plurk":10498,"▲topdec":10499,"##sis":10500,"00kg":10501,"▲topnov":10502,"720":10503,"##ence":10504,"tim":10505,"##ω":10506,"##nc":10507,"##ても":10508,"##name":10509,"log":10510,"ips":10511,"great":10512,"ikea":10513,"malaysia":10514,"unix":10515,"##イト":10516,"3600":10517,"##ncy":10518,"##nie":10519,"12000":10520,"akb48":10521,"##ye":10522,"##oid":10523,"404":10524,"##chi":10525,"##いた":10526,"oa":10527,"xuehai":10528,"##1000":10529,"##orm":10530,"##rf":10531,"275":10532,"さん":10533,"##ware":10534,"##リー":10535,"980":10536,"ho":10537,"##pro":10538,"text":10539,"##era":10540,"560":10541,"bob":10542,"227":10543,"##ub":10544,"##2008":10545,"8891":10546,"scp":10547,"avi":10548,"##zen":10549,"2022":10550,"mi":10551,"wu":10552,"museum":10553,"qvod":10554,"apache":10555,"lake":10556,"jcb":10557,"▲topaug":10558,"★★★":10559,"ni":10560,"##hr":10561,"hill":10562,"302":10563,"ne":10564,"weibo":10565,"490":10566,"ruby":10567,"##ーシ":10568,"##ヶ":10569,"##row":10570,"4d":10571,"▲topjul":10572,"iv":10573,"##ish":10574,"github":10575,"306":10576,"mate":10577,"312":10578,"##スト":10579,"##lot":10580,"##ane":10581,"andrew":10582,"のハイト":10583,"##tina":10584,"t1":10585,"rf":10586,"ed2k":10587,"##vel":10588,"##900":10589,"way":10590,"final":10591,"りの":10592,"ns":10593,"5a":10594,"705":10595,"197":10596,"##メ":10597,"sweet":10598,"bytes":10599,"##ene":10600,"▲topjan":10601,"231":10602,"##cker":10603,"##2007":10604,"##px":10605,"100g":10606,"topapp":10607,"229":10608,"helpapp":10609,"rs":10610,"low":10611,"14k":10612,"g4g":10613,"care":10614,"630":10615,"ldquo":10616,"あり":10617,"##fork":10618,"leave":10619,"rm":10620,"edition":10621,"##gan":10622,"##zon":10623,"##qq":10624,"▲topsep":10625,"##google":10626,"##ism":10627,"gold":10628,"224":10629,"explorer":10630,"##zer":10631,"toyota":10632,"category":10633,"select":10634,"visual":10635,"##labels":10636,"restaurant":10637,"##md":10638,"posts":10639,"s1":10640,"##ico":10641,"もっと":10642,"angelababy":10643,"123456":10644,"217":10645,"sports":10646,"s3":10647,"mbc":10648,"1915":10649,"してくたさい":10650,"shell":10651,"x86":10652,"candy":10653,"##new":10654,"kbs":10655,"face":10656,"xl":10657,"470":10658,"##here":10659,"4a":10660,"swissinfo":10661,"v8":10662,"▲topfeb":10663,"dram":10664,"##ual":10665,"##vice":10666,"3a":10667,"##wer":10668,"sport":10669,"q1":10670,"ios10":10671,"public":10672,"int":10673,"card":10674,"##c":10675,"ep":10676,"au":10677,"rt":10678,"##れた":10679,"1080":10680,"bill":10681,"##mll":10682,"kim":10683,"30":10684,"460":10685,"wan":10686,"##uk":10687,"##ミ":10688,"x3":10689,"298":10690,"0t":10691,"scott":10692,"##ming":10693,"239":10694,"e5":10695,"##3d":10696,"h7n9":10697,"worldcat":10698,"brown":10699,"##あります":10700,"##vo":10701,"##led":10702,"##580":10703,"##ax":10704,"249":10705,"410":10706,"##ert":10707,"paris":10708,"##~6":10709,"polo":10710,"925":10711,"##lr":10712,"599":10713,"##ナ":10714,"capital":10715,"##hing":10716,"bank":10717,"cv":10718,"1g":10719,"##chat":10720,"##s":10721,"##たい":10722,"adc":10723,"##ule":10724,"2m":10725,"##e":10726,"digital":10727,"hotmail":10728,"268":10729,"##pad":10730,"870":10731,"bbq":10732,"quot":10733,"##ring":10734,"before":10735,"wali":10736,"##まて":10737,"mcu":10738,"2k":10739,"2b":10740,"という":10741,"costco":10742,"316":10743,"north":10744,"333":10745,"switch":10746,"##city":10747,"##p":10748,"philips":10749,"##mann":10750,"management":10751,"panasonic":10752,"##cl":10753,"##vd":10754,"##ping":10755,"##rge":10756,"alice":10757,"##lk":10758,"##ましょう":10759,"css3":10760,"##ney":10761,"vision":10762,"alpha":10763,"##ular":10764,"##400":10765,"##tter":10766,"lz":10767,"にお":10768,"##ありません":10769,"mode":10770,"gre":10771,"1916":10772,"pci":10773,"##tm":10774,"237":10775,"1~2":10776,"##yan":10777,"##そ":10778,"について":10779,"##let":10780,"##キ":10781,"work":10782,"war":10783,"coach":10784,"ah":10785,"mary":10786,"##ᅵ":10787,"huang":10788,"##pt":10789,"a8":10790,"pt":10791,"follow":10792,"##berry":10793,"1895":10794,"##ew":10795,"a5":10796,"ghost":10797,"##ション":10798,"##wn":10799,"##og":10800,"south":10801,"##code":10802,"girls":10803,"##rid":10804,"action":10805,"villa":10806,"git":10807,"r11":10808,"table":10809,"games":10810,"##cket":10811,"error":10812,"##anonymoussaid":10813,"##ag":10814,"here":10815,"##ame":10816,"##gc":10817,"qa":10818,"##■":10819,"##lis":10820,"gmp":10821,"##gin":10822,"vmalife":10823,"##cher":10824,"yu":10825,"wedding":10826,"##tis":10827,"demo":10828,"dragon":10829,"530":10830,"soho":10831,"social":10832,"bye":10833,"##rant":10834,"river":10835,"orz":10836,"acer":10837,"325":10838,"##↑":10839,"##ース":10840,"##ats":10841,"261":10842,"del":10843,"##ven":10844,"440":10845,"ups":10846,"##ように":10847,"##ター":10848,"305":10849,"value":10850,"macd":10851,"yougou":10852,"##dn":10853,"661":10854,"##ano":10855,"ll":10856,"##urt":10857,"##rent":10858,"continue":10859,"script":10860,"##wen":10861,"##ect":10862,"paper":10863,"263":10864,"319":10865,"shift":10866,"##chel":10867,"##フト":10868,"##cat":10869,"258":10870,"x5":10871,"fox":10872,"243":10873,"##さん":10874,"car":10875,"aaa":10876,"##blog":10877,"loading":10878,"##yn":10879,"##tp":10880,"kuso":10881,"799":10882,"si":10883,"sns":10884,"イカせるテンマ":10885,"ヒンクテンマ3":10886,"rmb":10887,"vdc":10888,"forest":10889,"central":10890,"prime":10891,"help":10892,"ultra":10893,"##rmb":10894,"##ような":10895,"241":10896,"square":10897,"688":10898,"##しい":10899,"のないフロクに":10900,"##field":10901,"##reen":10902,"##ors":10903,"##ju":10904,"c1":10905,"start":10906,"510":10907,"##air":10908,"##map":10909,"cdn":10910,"##wo":10911,"cba":10912,"stephen":10913,"m8":10914,"100km":10915,"##get":10916,"opera":10917,"##base":10918,"##ood":10919,"vsa":10920,"com™":10921,"##aw":10922,"##ail":10923,"251":10924,"なのて":10925,"count":10926,"t2":10927,"##ᅡ":10928,"##een":10929,"2700":10930,"hop":10931,"##gp":10932,"vsc":10933,"tree":10934,"##eg":10935,"##ose":10936,"816":10937,"285":10938,"##ories":10939,"##shop":10940,"alphago":10941,"v4":10942,"1909":10943,"simon":10944,"##ᆼ":10945,"fluke62max":10946,"zip":10947,"スホンサー":10948,"##sta":10949,"louis":10950,"cr":10951,"bas":10952,"##~10":10953,"bc":10954,"##yer":10955,"hadoop":10956,"##ube":10957,"##wi":10958,"1906":10959,"0755":10960,"hola":10961,"##low":10962,"place":10963,"centre":10964,"5v":10965,"d3":10966,"##fer":10967,"252":10968,"##750":10969,"##media":10970,"281":10971,"540":10972,"0l":10973,"exchange":10974,"262":10975,"series":10976,"##ハー":10977,"##san":10978,"eb":10979,"##bank":10980,"##k":10981,"q3":10982,"##nge":10983,"##mail":10984,"take":10985,"##lp":10986,"259":10987,"1888":10988,"client":10989,"east":10990,"cache":10991,"event":10992,"vincent":10993,"##ールを":10994,"きを":10995,"##nse":10996,"sui":10997,"855":10998,"adchoice":10999,"##и":11000,"##stry":11001,"##なたの":11002,"246":11003,"##zone":11004,"ga":11005,"apps":11006,"sea":11007,"##ab":11008,"248":11009,"cisco":11010,"##タ":11011,"##rner":11012,"kymco":11013,"##care":11014,"dha":11015,"##pu":11016,"##yi":11017,"minkoff":11018,"royal":11019,"p1":11020,"への":11021,"annie":11022,"269":11023,"collection":11024,"kpi":11025,"playstation":11026,"257":11027,"になります":11028,"866":11029,"bh":11030,"##bar":11031,"queen":11032,"505":11033,"radio":11034,"1904":11035,"andy":11036,"armani":11037,"##xy":11038,"manager":11039,"iherb":11040,"##ery":11041,"##share":11042,"spring":11043,"raid":11044,"johnson":11045,"1908":11046,"##ob":11047,"volvo":11048,"hall":11049,"##ball":11050,"v6":11051,"our":11052,"taylor":11053,"##hk":11054,"bi":11055,"242":11056,"##cp":11057,"kate":11058,"bo":11059,"water":11060,"technology":11061,"##rie":11062,"サイトは":11063,"277":11064,"##ona":11065,"##sl":11066,"hpv":11067,"303":11068,"gtx":11069,"hip":11070,"rdquo":11071,"jayz":11072,"stone":11073,"##lex":11074,"##rum":11075,"namespace":11076,"##やり":11077,"620":11078,"##ale":11079,"##atic":11080,"des":11081,"##erson":11082,"##ql":11083,"##ves":11084,"##type":11085,"enter":11086,"##この":11087,"##てきます":11088,"d2":11089,"##168":11090,"##mix":11091,"##bian":11092,"との":11093,"a9":11094,"jj":11095,"ky":11096,"##lc":11097,"access":11098,"movie":11099,"##hc":11100,"リストに":11101,"tower":11102,"##ration":11103,"##mit":11104,"ます":11105,"##nch":11106,"ua":11107,"tel":11108,"prefix":11109,"##o2":11110,"1907":11111,"##point":11112,"1901":11113,"ott":11114,"~10":11115,"##http":11116,"##ury":11117,"baidu":11118,"##ink":11119,"member":11120,"##logy":11121,"bigbang":11122,"nownews":11123,"##js":11124,"##shot":11125,"##tb":11126,"##こと":11127,"247":11128,"eba":11129,"##tics":11130,"##lus":11131,"ける":11132,"v5":11133,"spark":11134,"##ama":11135,"there":11136,"##ions":11137,"god":11138,"##lls":11139,"##down":11140,"hiv":11141,"##ress":11142,"burberry":11143,"day2":11144,"##kv":11145,"◆◆":11146,"jeff":11147,"related":11148,"film":11149,"edit":11150,"joseph":11151,"283":11152,"##ark":11153,"cx":11154,"32gb":11155,"order":11156,"g9":11157,"30000":11158,"##ans":11159,"##tty":11160,"s5":11161,"##bee":11162,"かあります":11163,"thread":11164,"xr":11165,"buy":11166,"sh":11167,"005":11168,"land":11169,"spotify":11170,"mx":11171,"##ari":11172,"276":11173,"##verse":11174,"×email":11175,"sf":11176,"why":11177,"##ことて":11178,"244":11179,"7headlines":11180,"nego":11181,"sunny":11182,"dom":11183,"exo":11184,"401":11185,"666":11186,"positioning":11187,"fit":11188,"rgb":11189,"##tton":11190,"278":11191,"kiss":11192,"alexa":11193,"adam":11194,"lp":11195,"みリストを":11196,"##g":11197,"mp":11198,"##ties":11199,"##llow":11200,"amy":11201,"##du":11202,"np":11203,"002":11204,"institute":11205,"271":11206,"##rth":11207,"##lar":11208,"2345":11209,"590":11210,"##des":11211,"sidebar":11212,"15":11213,"imax":11214,"site":11215,"##cky":11216,"##kit":11217,"##ime":11218,"##009":11219,"season":11220,"323":11221,"##fun":11222,"##ンター":11223,"##ひ":11224,"gogoro":11225,"a7":11226,"pu":11227,"lily":11228,"fire":11229,"twd600":11230,"##ッセーシを":11231,"いて":11232,"##vis":11233,"30ml":11234,"##cture":11235,"##をお":11236,"information":11237,"##オ":11238,"close":11239,"friday":11240,"##くれる":11241,"yi":11242,"nick":11243,"てすか":11244,"##tta":11245,"##tel":11246,"6500":11247,"##lock":11248,"cbd":11249,"economy":11250,"254":11251,"かお":11252,"267":11253,"tinker":11254,"double":11255,"375":11256,"8gb":11257,"voice":11258,"##app":11259,"oops":11260,"channel":11261,"today":11262,"985":11263,"##right":11264,"raw":11265,"xyz":11266,"##+":11267,"jim":11268,"edm":11269,"##cent":11270,"7500":11271,"supreme":11272,"814":11273,"ds":11274,"##its":11275,"##asia":11276,"dropbox":11277,"##てすか":11278,"##tti":11279,"books":11280,"272":11281,"100ml":11282,"##tle":11283,"##ller":11284,"##ken":11285,"##more":11286,"##boy":11287,"sex":11288,"309":11289,"##dom":11290,"t3":11291,"##ider":11292,"##なります":11293,"##unch":11294,"1903":11295,"810":11296,"feel":11297,"5500":11298,"##かった":11299,"##put":11300,"により":11301,"s2":11302,"mo":11303,"##gh":11304,"men":11305,"ka":11306,"amoled":11307,"div":11308,"##tr":11309,"##n1":11310,"port":11311,"howard":11312,"##tags":11313,"ken":11314,"dnf":11315,"##nus":11316,"adsense":11317,"##а":11318,"ide":11319,"##へ":11320,"buff":11321,"thunder":11322,"##town":11323,"##ique":11324,"has":11325,"##body":11326,"auto":11327,"pin":11328,"##erry":11329,"tee":11330,"てした":11331,"295":11332,"number":11333,"##the":11334,"##013":11335,"object":11336,"psp":11337,"cool":11338,"udnbkk":11339,"16gb":11340,"##mic":11341,"miui":11342,"##tro":11343,"most":11344,"r2":11345,"##alk":11346,"##nity":11347,"1880":11348,"±0":11349,"##いました":11350,"428":11351,"s4":11352,"law":11353,"version":11354,"##oa":11355,"n1":11356,"sgs":11357,"docomo":11358,"##tf":11359,"##ack":11360,"henry":11361,"fc2":11362,"##ded":11363,"##sco":11364,"##014":11365,"##rite":11366,"286":11367,"0mm":11368,"linkedin":11369,"##ada":11370,"##now":11371,"wii":11372,"##ndy":11373,"ucbug":11374,"##◎":11375,"sputniknews":11376,"legalminer":11377,"##ika":11378,"##xp":11379,"2gb":11380,"##bu":11381,"q10":11382,"oo":11383,"b6":11384,"come":11385,"##rman":11386,"cheese":11387,"ming":11388,"maker":11389,"##gm":11390,"nikon":11391,"##fig":11392,"ppi":11393,"kelly":11394,"##ります":11395,"jchere":11396,"てきます":11397,"ted":11398,"md":11399,"003":11400,"fgo":11401,"tech":11402,"##tto":11403,"dan":11404,"soc":11405,"##gl":11406,"##len":11407,"hair":11408,"earth":11409,"640":11410,"521":11411,"img":11412,"##pper":11413,"##a1":11414,"##てきる":11415,"##ロク":11416,"acca":11417,"##ition":11418,"##ference":11419,"suite":11420,"##ig":11421,"outlook":11422,"##mond":11423,"##cation":11424,"398":11425,"##pr":11426,"279":11427,"101vip":11428,"358":11429,"##999":11430,"282":11431,"64gb":11432,"3800":11433,"345":11434,"airport":11435,"##over":11436,"284":11437,"##おり":11438,"jones":11439,"##ith":11440,"lab":11441,"##su":11442,"##いるのて":11443,"co2":11444,"town":11445,"piece":11446,"##llo":11447,"no1":11448,"vmware":11449,"24h":11450,"##qi":11451,"focus":11452,"reader":11453,"##admin":11454,"##ora":11455,"tb":11456,"false":11457,"##log":11458,"1898":11459,"know":11460,"lan":11461,"838":11462,"##ces":11463,"f4":11464,"##ume":11465,"motel":11466,"stop":11467,"##oper":11468,"na":11469,"flickr":11470,"netcomponents":11471,"##af":11472,"##─":11473,"pose":11474,"williams":11475,"local":11476,"##ound":11477,"##cg":11478,"##site":11479,"##iko":11480,"いお":11481,"274":11482,"5m":11483,"gsm":11484,"con":11485,"##ath":11486,"1902":11487,"friends":11488,"##hip":11489,"cell":11490,"317":11491,"##rey":11492,"780":11493,"cream":11494,"##cks":11495,"012":11496,"##dp":11497,"facebooktwitterpinterestgoogle":11498,"sso":11499,"324":11500,"shtml":11501,"song":11502,"swiss":11503,"##mw":11504,"##キンク":11505,"lumia":11506,"xdd":11507,"string":11508,"tiffany":11509,"522":11510,"marc":11511,"られた":11512,"insee":11513,"russell":11514,"sc":11515,"dell":11516,"##ations":11517,"ok":11518,"camera":11519,"289":11520,"##vs":11521,"##flow":11522,"##late":11523,"classic":11524,"287":11525,"##nter":11526,"stay":11527,"g1":11528,"mtv":11529,"512":11530,"##ever":11531,"##lab":11532,"##nger":11533,"qe":11534,"sata":11535,"ryan":11536,"d1":11537,"50ml":11538,"cms":11539,"##cing":11540,"su":11541,"292":11542,"3300":11543,"editor":11544,"296":11545,"##nap":11546,"security":11547,"sunday":11548,"association":11549,"##ens":11550,"##700":11551,"##bra":11552,"acg":11553,"##かり":11554,"sofascore":11555,"とは":11556,"mkv":11557,"##ign":11558,"jonathan":11559,"gary":11560,"build":11561,"labels":11562,"##oto":11563,"tesla":11564,"moba":11565,"qi":11566,"gohappy":11567,"general":11568,"ajax":11569,"1024":11570,"##かる":11571,"サイト":11572,"society":11573,"##test":11574,"##urs":11575,"wps":11576,"fedora":11577,"##ich":11578,"mozilla":11579,"328":11580,"##480":11581,"##dr":11582,"usa":11583,"urn":11584,"##lina":11585,"##r":11586,"grace":11587,"##die":11588,"##try":11589,"##ader":11590,"1250":11591,"##なり":11592,"elle":11593,"570":11594,"##chen":11595,"##ᆯ":11596,"price":11597,"##ten":11598,"uhz":11599,"##ough":11600,"eq":11601,"##hen":11602,"states":11603,"push":11604,"session":11605,"balance":11606,"wow":11607,"506":11608,"##cus":11609,"##py":11610,"when":11611,"##ward":11612,"##ep":11613,"34e":11614,"wong":11615,"library":11616,"prada":11617,"##サイト":11618,"##cle":11619,"running":11620,"##ree":11621,"313":11622,"ck":11623,"date":11624,"q4":11625,"##ctive":11626,"##ool":11627,"##>":11628,"mk":11629,"##ira":11630,"##163":11631,"388":11632,"die":11633,"secret":11634,"rq":11635,"dota":11636,"buffet":11637,"は1ヶ":11638,"e6":11639,"##ez":11640,"pan":11641,"368":11642,"ha":11643,"##card":11644,"##cha":11645,"2a":11646,"##さ":11647,"alan":11648,"day3":11649,"eye":11650,"f3":11651,"##end":11652,"france":11653,"keep":11654,"adi":11655,"rna":11656,"tvbs":11657,"##ala":11658,"solo":11659,"nova":11660,"##え":11661,"##tail":11662,"##ょう":11663,"support":11664,"##ries":11665,"##なる":11666,"##ved":11667,"base":11668,"copy":11669,"iis":11670,"fps":11671,"##ways":11672,"hero":11673,"hgih":11674,"profile":11675,"fish":11676,"mu":11677,"ssh":11678,"entertainment":11679,"chang":11680,"##wd":11681,"click":11682,"cake":11683,"##ond":11684,"pre":11685,"##tom":11686,"kic":11687,"pixel":11688,"##ov":11689,"##fl":11690,"product":11691,"6a":11692,"##pd":11693,"dear":11694,"##gate":11695,"es":11696,"yumi":11697,"audio":11698,"##²":11699,"##sky":11700,"echo":11701,"bin":11702,"where":11703,"##ture":11704,"329":11705,"##ape":11706,"find":11707,"sap":11708,"isis":11709,"##なと":11710,"nand":11711,"##101":11712,"##load":11713,"##ream":11714,"band":11715,"a6":11716,"525":11717,"never":11718,"##post":11719,"festival":11720,"50cm":11721,"##we":11722,"555":11723,"guide":11724,"314":11725,"zenfone":11726,"##ike":11727,"335":11728,"gd":11729,"forum":11730,"jessica":11731,"strong":11732,"alexander":11733,"##ould":11734,"software":11735,"allen":11736,"##ious":11737,"program":11738,"360°":11739,"else":11740,"lohasthree":11741,"##gar":11742,"することかてきます":11743,"please":11744,"##れます":11745,"rc":11746,"##ggle":11747,"##ric":11748,"bim":11749,"50000":11750,"##own":11751,"eclipse":11752,"355":11753,"brian":11754,"3ds":11755,"##side":11756,"061":11757,"361":11758,"##other":11759,"##ける":11760,"##tech":11761,"##ator":11762,"485":11763,"engine":11764,"##ged":11765,"##t":11766,"plaza":11767,"##fit":11768,"cia":11769,"ngo":11770,"westbrook":11771,"shi":11772,"tbs":11773,"50mm":11774,"##みませんか":11775,"sci":11776,"291":11777,"reuters":11778,"##ily":11779,"contextlink":11780,"##hn":11781,"af":11782,"##cil":11783,"bridge":11784,"very":11785,"##cel":11786,"1890":11787,"cambridge":11788,"##ize":11789,"15g":11790,"##aid":11791,"##data":11792,"790":11793,"frm":11794,"##head":11795,"award":11796,"butler":11797,"##sun":11798,"meta":11799,"##mar":11800,"america":11801,"ps3":11802,"puma":11803,"pmid":11804,"##すか":11805,"lc":11806,"670":11807,"kitchen":11808,"##lic":11809,"オーフン5":11810,"きなしソフトサーヒス":11811,"そして":11812,"day1":11813,"future":11814,"★★★★":11815,"##text":11816,"##page":11817,"##rris":11818,"pm1":11819,"##ket":11820,"fans":11821,"##っています":11822,"1001":11823,"christian":11824,"bot":11825,"kids":11826,"trackback":11827,"##hai":11828,"c3":11829,"display":11830,"##hl":11831,"n2":11832,"1896":11833,"idea":11834,"さんも":11835,"##sent":11836,"airmail":11837,"##ug":11838,"##men":11839,"pwm":11840,"けます":11841,"028":11842,"##lution":11843,"369":11844,"852":11845,"awards":11846,"schemas":11847,"354":11848,"asics":11849,"wikipedia":11850,"font":11851,"##tional":11852,"##vy":11853,"c2":11854,"293":11855,"##れている":11856,"##dget":11857,"##ein":11858,"っている":11859,"contact":11860,"pepper":11861,"スキル":11862,"339":11863,"##~5":11864,"294":11865,"##uel":11866,"##ument":11867,"730":11868,"##hang":11869,"みてす":11870,"q5":11871,"##sue":11872,"rain":11873,"##ndi":11874,"wei":11875,"swatch":11876,"##cept":11877,"わせ":11878,"331":11879,"popular":11880,"##ste":11881,"##tag":11882,"p2":11883,"501":11884,"trc":11885,"1899":11886,"##west":11887,"##live":11888,"justin":11889,"honda":11890,"ping":11891,"messenger":11892,"##rap":11893,"v9":11894,"543":11895,"##とは":11896,"unity":11897,"appqq":11898,"はすへて":11899,"025":11900,"leo":11901,"##tone":11902,"##テ":11903,"##ass":11904,"uniqlo":11905,"##010":11906,"502":11907,"her":11908,"jane":11909,"memory":11910,"moneydj":11911,"##tical":11912,"human":11913,"12306":11914,"していると":11915,"##m2":11916,"coc":11917,"miacare":11918,"##mn":11919,"tmt":11920,"##core":11921,"vim":11922,"kk":11923,"##may":11924,"fan":11925,"target":11926,"use":11927,"too":11928,"338":11929,"435":11930,"2050":11931,"867":11932,"737":11933,"fast":11934,"##2c":11935,"services":11936,"##ope":11937,"omega":11938,"energy":11939,"##わ":11940,"pinkoi":11941,"1a":11942,"##なから":11943,"##rain":11944,"jackson":11945,"##ement":11946,"##シャンルの":11947,"374":11948,"366":11949,"そんな":11950,"p9":11951,"rd":11952,"##ᆨ":11953,"1111":11954,"##tier":11955,"##vic":11956,"zone":11957,"##│":11958,"385":11959,"690":11960,"dl":11961,"isofix":11962,"cpa":11963,"m4":11964,"322":11965,"kimi":11966,"めて":11967,"davis":11968,"##lay":11969,"lulu":11970,"##uck":11971,"050":11972,"weeks":11973,"qs":11974,"##hop":11975,"920":11976,"##n":11977,"ae":11978,"##ear":11979,"~5":11980,"eia":11981,"405":11982,"##fly":11983,"korea":11984,"jpeg":11985,"boost":11986,"##ship":11987,"small":11988,"##リア":11989,"1860":11990,"eur":11991,"297":11992,"425":11993,"valley":11994,"##iel":11995,"simple":11996,"##ude":11997,"rn":11998,"k2":11999,"##ena":12000,"されます":12001,"non":12002,"patrick":12003,"しているから":12004,"##ナー":12005,"feed":12006,"5757":12007,"30g":12008,"process":12009,"well":12010,"qqmei":12011,"##thing":12012,"they":12013,"aws":12014,"lu":12015,"pink":12016,"##ters":12017,"##kin":12018,"または":12019,"board":12020,"##vertisement":12021,"wine":12022,"##ien":12023,"unicode":12024,"##dge":12025,"r1":12026,"359":12027,"##tant":12028,"いを":12029,"##twitter":12030,"##3c":12031,"cool1":12032,"される":12033,"##れて":12034,"##l":12035,"isp":12036,"##012":12037,"standard":12038,"45㎡2":12039,"402":12040,"##150":12041,"matt":12042,"##fu":12043,"326":12044,"##iner":12045,"googlemsn":12046,"pixnetfacebookyahoo":12047,"##ラン":12048,"x7":12049,"886":12050,"##uce":12051,"メーカー":12052,"sao":12053,"##ev":12054,"##きました":12055,"##file":12056,"9678":12057,"403":12058,"xddd":12059,"shirt":12060,"6l":12061,"##rio":12062,"##hat":12063,"3mm":12064,"givenchy":12065,"ya":12066,"bang":12067,"##lio":12068,"monday":12069,"crystal":12070,"ロクイン":12071,"##abc":12072,"336":12073,"head":12074,"890":12075,"ubuntuforumwikilinuxpastechat":12076,"##vc":12077,"##~20":12078,"##rity":12079,"cnc":12080,"7866":12081,"ipv6":12082,"null":12083,"1897":12084,"##ost":12085,"yang":12086,"imsean":12087,"tiger":12088,"##fet":12089,"##ンス":12090,"352":12091,"##=":12092,"dji":12093,"327":12094,"ji":12095,"maria":12096,"##come":12097,"##んて":12098,"foundation":12099,"3100":12100,"##beth":12101,"##なった":12102,"1m":12103,"601":12104,"active":12105,"##aft":12106,"##don":12107,"3p":12108,"sr":12109,"349":12110,"emma":12111,"##khz":12112,"living":12113,"415":12114,"353":12115,"1889":12116,"341":12117,"709":12118,"457":12119,"sas":12120,"x6":12121,"##face":12122,"pptv":12123,"x4":12124,"##mate":12125,"han":12126,"sophie":12127,"##jing":12128,"337":12129,"fifa":12130,"##mand":12131,"other":12132,"sale":12133,"inwedding":12134,"##gn":12135,"てきちゃいます":12136,"##mmy":12137,"##pmlast":12138,"bad":12139,"nana":12140,"nbc":12141,"してみてくたさいね":12142,"なとはお":12143,"##wu":12144,"##かあります":12145,"##あ":12146,"note7":12147,"single":12148,"##340":12149,"せからこ":12150,"してくたさい♪この":12151,"しにはとんとんワークケートを":12152,"するとあなたにもっとマッチした":12153,"ならワークケートへ":12154,"もみつかっちゃうかも":12155,"ワークケートの":12156,"##bel":12157,"window":12158,"##dio":12159,"##ht":12160,"union":12161,"age":12162,"382":12163,"14":12164,"##ivity":12165,"##y":12166,"コメント":12167,"domain":12168,"neo":12169,"##isa":12170,"##lter":12171,"5k":12172,"f5":12173,"steven":12174,"##cts":12175,"powerpoint":12176,"tft":12177,"self":12178,"g2":12179,"ft":12180,"##テル":12181,"zol":12182,"##act":12183,"mwc":12184,"381":12185,"343":12186,"もう":12187,"nbapop":12188,"408":12189,"てある":12190,"eds":12191,"ace":12192,"##room":12193,"previous":12194,"author":12195,"tomtom":12196,"il":12197,"##ets":12198,"hu":12199,"financial":12200,"☆☆☆":12201,"っています":12202,"bp":12203,"5t":12204,"chi":12205,"1gb":12206,"##hg":12207,"fairmont":12208,"cross":12209,"008":12210,"gay":12211,"h2":12212,"function":12213,"##けて":12214,"356":12215,"also":12216,"1b":12217,"625":12218,"##ータ":12219,"##raph":12220,"1894":12221,"3~5":12222,"##ils":12223,"i3":12224,"334":12225,"avenue":12226,"##host":12227,"による":12228,"##bon":12229,"##tsu":12230,"message":12231,"navigation":12232,"50g":12233,"fintech":12234,"h6":12235,"##ことを":12236,"8cm":12237,"##ject":12238,"##vas":12239,"##firm":12240,"credit":12241,"##wf":12242,"xxxx":12243,"form":12244,"##nor":12245,"##space":12246,"huawei":12247,"plan":12248,"json":12249,"sbl":12250,"##dc":12251,"machine":12252,"921":12253,"392":12254,"wish":12255,"##120":12256,"##sol":12257,"windows7":12258,"edward":12259,"##ために":12260,"development":12261,"washington":12262,"##nsis":12263,"lo":12264,"818":12265,"##sio":12266,"##ym":12267,"##bor":12268,"planet":12269,"##~8":12270,"##wt":12271,"ieee":12272,"gpa":12273,"##めて":12274,"camp":12275,"ann":12276,"gm":12277,"##tw":12278,"##oka":12279,"connect":12280,"##rss":12281,"##work":12282,"##atus":12283,"wall":12284,"chicken":12285,"soul":12286,"2mm":12287,"##times":12288,"fa":12289,"##ather":12290,"##cord":12291,"009":12292,"##eep":12293,"hitachi":12294,"gui":12295,"harry":12296,"##pan":12297,"e1":12298,"disney":12299,"##press":12300,"##ーション":12301,"wind":12302,"386":12303,"frigidaire":12304,"##tl":12305,"liu":12306,"hsu":12307,"332":12308,"basic":12309,"von":12310,"ev":12311,"いた":12312,"てきる":12313,"スホンサーサイト":12314,"learning":12315,"##ull":12316,"expedia":12317,"archives":12318,"change":12319,"##wei":12320,"santa":12321,"cut":12322,"ins":12323,"6gb":12324,"turbo":12325,"brand":12326,"cf1":12327,"508":12328,"004":12329,"return":12330,"747":12331,"##rip":12332,"h1":12333,"##nis":12334,"##をこ":12335,"128gb":12336,"##にお":12337,"3t":12338,"application":12339,"しており":12340,"emc":12341,"rx":12342,"##oon":12343,"384":12344,"quick":12345,"412":12346,"15058":12347,"wilson":12348,"wing":12349,"chapter":12350,"##bug":12351,"beyond":12352,"##cms":12353,"##dar":12354,"##oh":12355,"zoom":12356,"e2":12357,"trip":12358,"sb":12359,"##nba":12360,"rcep":12361,"342":12362,"aspx":12363,"ci":12364,"080":12365,"gc":12366,"gnu":12367,"める":12368,"##count":12369,"advanced":12370,"dance":12371,"dv":12372,"##url":12373,"##ging":12374,"367":12375,"8591":12376,"am09":12377,"shadow":12378,"battle":12379,"346":12380,"##i":12381,"##cia":12382,"##という":12383,"emily":12384,"##のてす":12385,"##tation":12386,"host":12387,"ff":12388,"techorz":12389,"sars":12390,"##mini":12391,"##mporary":12392,"##ering":12393,"nc":12394,"4200":12395,"798":12396,"##next":12397,"cma":12398,"##mbps":12399,"##gas":12400,"##ift":12401,"##dot":12402,"##ィ":12403,"455":12404,"##~17":12405,"amana":12406,"##りの":12407,"426":12408,"##ros":12409,"ir":12410,"00㎡1":12411,"##eet":12412,"##ible":12413,"##↓":12414,"710":12415,"ˋ▽ˊ":12416,"##aka":12417,"dcs":12418,"iq":12419,"##v":12420,"l1":12421,"##lor":12422,"maggie":12423,"##011":12424,"##iu":12425,"588":12426,"##~1":12427,"830":12428,"##gt":12429,"1tb":12430,"articles":12431,"create":12432,"##burg":12433,"##iki":12434,"database":12435,"fantasy":12436,"##rex":12437,"##cam":12438,"dlc":12439,"dean":12440,"##you":12441,"hard":12442,"path":12443,"gaming":12444,"victoria":12445,"maps":12446,"cb":12447,"##lee":12448,"##itor":12449,"overchicstoretvhome":12450,"systems":12451,"##xt":12452,"416":12453,"p3":12454,"sarah":12455,"760":12456,"##nan":12457,"407":12458,"486":12459,"x9":12460,"install":12461,"second":12462,"626":12463,"##ann":12464,"##ph":12465,"##rcle":12466,"##nic":12467,"860":12468,"##nar":12469,"ec":12470,"##とう":12471,"768":12472,"metro":12473,"chocolate":12474,"##rian":12475,"~4":12476,"##table":12477,"##しています":12478,"skin":12479,"##sn":12480,"395":12481,"mountain":12482,"##0mm":12483,"inparadise":12484,"6m":12485,"7x24":12486,"ib":12487,"4800":12488,"##jia":12489,"eeworld":12490,"creative":12491,"g5":12492,"g3":12493,"357":12494,"parker":12495,"ecfa":12496,"village":12497,"からの":12498,"18000":12499,"sylvia":12500,"サーヒス":12501,"hbl":12502,"##ques":12503,"##onsored":12504,"##x2":12505,"##きます":12506,"##v4":12507,"##tein":12508,"ie6":12509,"383":12510,"##stack":12511,"389":12512,"ver":12513,"##ads":12514,"##baby":12515,"sound":12516,"bbe":12517,"##110":12518,"##lone":12519,"##uid":12520,"ads":12521,"022":12522,"gundam":12523,"351":12524,"thinkpad":12525,"006":12526,"scrum":12527,"match":12528,"##ave":12529,"mems":12530,"##470":12531,"##oy":12532,"##なりました":12533,"##talk":12534,"glass":12535,"lamigo":12536,"span":12537,"##eme":12538,"job":12539,"##a5":12540,"jay":12541,"wade":12542,"kde":12543,"498":12544,"##lace":12545,"ocean":12546,"tvg":12547,"##covery":12548,"##r3":12549,"##ners":12550,"##rea":12551,"junior":12552,"think":12553,"##aine":12554,"cover":12555,"##ision":12556,"##sia":12557,"↓↓":12558,"##bow":12559,"msi":12560,"413":12561,"458":12562,"406":12563,"##love":12564,"711":12565,"801":12566,"soft":12567,"z2":12568,"##pl":12569,"456":12570,"1840":12571,"mobil":12572,"mind":12573,"##uy":12574,"427":12575,"nginx":12576,"##oi":12577,"めた":12578,"##rr":12579,"6221":12580,"##mple":12581,"##sson":12582,"##ーシてす":12583,"371":12584,"##nts":12585,"91tv":12586,"comhd":12587,"crv3000":12588,"##uard":12589,"1868":12590,"397":12591,"deep":12592,"lost":12593,"field":12594,"gallery":12595,"##bia":12596,"rate":12597,"spf":12598,"redis":12599,"traction":12600,"930":12601,"icloud":12602,"011":12603,"なら":12604,"fe":12605,"jose":12606,"372":12607,"##tory":12608,"into":12609,"sohu":12610,"fx":12611,"899":12612,"379":12613,"kicstart2":12614,"##hia":12615,"すく":12616,"##~3":12617,"##sit":12618,"ra":12619,"24":12620,"##walk":12621,"##xure":12622,"500g":12623,"##pact":12624,"pacific":12625,"xa":12626,"natural":12627,"carlo":12628,"##250":12629,"##walker":12630,"1850":12631,"##can":12632,"cto":12633,"gigi":12634,"516":12635,"##サー":12636,"pen":12637,"##hoo":12638,"ob":12639,"matlab":12640,"##b":12641,"##yy":12642,"13913459":12643,"##iti":12644,"mango":12645,"##bbs":12646,"sense":12647,"c5":12648,"oxford":12649,"##ニア":12650,"walker":12651,"jennifer":12652,"##ola":12653,"course":12654,"##bre":12655,"701":12656,"##pus":12657,"##rder":12658,"lucky":12659,"075":12660,"##ぁ":12661,"ivy":12662,"なお":12663,"##nia":12664,"sotheby":12665,"side":12666,"##ugh":12667,"joy":12668,"##orage":12669,"##ush":12670,"##bat":12671,"##dt":12672,"364":12673,"r9":12674,"##2d":12675,"##gio":12676,"511":12677,"country":12678,"wear":12679,"##lax":12680,"##~7":12681,"##moon":12682,"393":12683,"seven":12684,"study":12685,"411":12686,"348":12687,"lonzo":12688,"8k":12689,"##ェ":12690,"evolution":12691,"##イフ":12692,"##kk":12693,"gs":12694,"kd":12695,"##レス":12696,"arduino":12697,"344":12698,"b12":12699,"##lux":12700,"arpg":12701,"##rdon":12702,"cook":12703,"##x5":12704,"dark":12705,"five":12706,"##als":12707,"##ida":12708,"とても":12709,"sign":12710,"362":12711,"##ちの":12712,"something":12713,"20mm":12714,"##nda":12715,"387":12716,"##posted":12717,"fresh":12718,"tf":12719,"1870":12720,"422":12721,"cam":12722,"##mine":12723,"##skip":12724,"##form":12725,"##ssion":12726,"education":12727,"394":12728,"##tee":12729,"dyson":12730,"stage":12731,"##jie":12732,"want":12733,"##night":12734,"epson":12735,"pack":12736,"あります":12737,"##ppy":12738,"テリヘル":12739,"##█":12740,"wd":12741,"##eh":12742,"##rence":12743,"left":12744,"##lvin":12745,"golden":12746,"mhz":12747,"discovery":12748,"##trix":12749,"##n2":12750,"loft":12751,"##uch":12752,"##dra":12753,"##sse":12754,"speed":12755,"~1":12756,"1mdb":12757,"sorry":12758,"welcome":12759,"##urn":12760,"wave":12761,"gaga":12762,"##lmer":12763,"teddy":12764,"##160":12765,"トラックハック":12766,"せよ":12767,"611":12768,"##f2016":12769,"378":12770,"rp":12771,"##sha":12772,"rar":12773,"##あなたに":12774,"##きた":12775,"840":12776,"holiday":12777,"##ュー":12778,"373":12779,"074":12780,"##vg":12781,"##nos":12782,"##rail":12783,"gartner":12784,"gi":12785,"6p":12786,"##dium":12787,"kit":12788,"488":12789,"b3":12790,"eco":12791,"##ろう":12792,"20g":12793,"sean":12794,"##stone":12795,"autocad":12796,"nu":12797,"##np":12798,"f16":12799,"write":12800,"029":12801,"m5":12802,"##ias":12803,"images":12804,"atp":12805,"##dk":12806,"fsm":12807,"504":12808,"1350":12809,"ve":12810,"52kb":12811,"##xxx":12812,"##のに":12813,"##cake":12814,"414":12815,"unit":12816,"lim":12817,"ru":12818,"1v":12819,"##ification":12820,"published":12821,"angela":12822,"16g":12823,"analytics":12824,"ak":12825,"##q":12826,"##nel":12827,"gmt":12828,"##icon":12829,"again":12830,"##₂":12831,"##bby":12832,"ios11":12833,"445":12834,"かこさいます":12835,"waze":12836,"いてす":12837,"##ハ":12838,"9985":12839,"##ust":12840,"##ティー":12841,"framework":12842,"##007":12843,"iptv":12844,"delete":12845,"52sykb":12846,"cl":12847,"wwdc":12848,"027":12849,"30cm":12850,"##fw":12851,"##ての":12852,"1389":12853,"##xon":12854,"brandt":12855,"##ses":12856,"##dragon":12857,"tc":12858,"vetements":12859,"anne":12860,"monte":12861,"modern":12862,"official":12863,"##へて":12864,"##ere":12865,"##nne":12866,"##oud":12867,"もちろん":12868,"50":12869,"etnews":12870,"##a2":12871,"##graphy":12872,"421":12873,"863":12874,"##ちゃん":12875,"444":12876,"##rtex":12877,"##てお":12878,"l2":12879,"##gma":12880,"mount":12881,"ccd":12882,"たと":12883,"archive":12884,"morning":12885,"tan":12886,"ddos":12887,"e7":12888,"##ホ":12889,"day4":12890,"##ウ":12891,"gis":12892,"453":12893,"its":12894,"495":12895,"factory":12896,"bruce":12897,"pg":12898,"##ito":12899,"ってくたさい":12900,"guest":12901,"cdma":12902,"##lling":12903,"536":12904,"n3":12905,"しかし":12906,"3~4":12907,"mega":12908,"eyes":12909,"ro":12910,"13":12911,"women":12912,"dac":12913,"church":12914,"##jun":12915,"singapore":12916,"##facebook":12917,"6991":12918,"starbucks":12919,"##tos":12920,"##stin":12921,"##shine":12922,"zen":12923,"##mu":12924,"tina":12925,"20℃":12926,"1893":12927,"##たけて":12928,"503":12929,"465":12930,"request":12931,"##gence":12932,"qt":12933,"##っ":12934,"1886":12935,"347":12936,"363":12937,"q7":12938,"##zzi":12939,"diary":12940,"##tore":12941,"409":12942,"##ead":12943,"468":12944,"cst":12945,"##osa":12946,"canada":12947,"agent":12948,"va":12949,"##jiang":12950,"##ちは":12951,"##ーク":12952,"##lam":12953,"sg":12954,"##nix":12955,"##sday":12956,"##よって":12957,"g6":12958,"##master":12959,"bing":12960,"##zl":12961,"charlie":12962,"16":12963,"8mm":12964,"nb40":12965,"##ーン":12966,"thai":12967,"##ルフ":12968,"ln284ct":12969,"##itz":12970,"##2f":12971,"bonnie":12972,"##food":12973,"##lent":12974,"originals":12975,"##stro":12976,"##lts":12977,"418":12978,"∟∣":12979,"##bscribe":12980,"children":12981,"ntd":12982,"yesstyle":12983,"##かも":12984,"hmv":12985,"##tment":12986,"d5":12987,"2cm":12988,"arts":12989,"sms":12990,"##pn":12991,"##я":12992,"##いい":12993,"topios9":12994,"539":12995,"lifestyle":12996,"virtual":12997,"##ague":12998,"xz":12999,"##deo":13000,"muji":13001,"024":13002,"unt":13003,"##nnis":13004,"##ᅩ":13005,"faq1":13006,"1884":13007,"396":13008,"##ette":13009,"fly":13010,"64㎡":13011,"はしめまして":13012,"441":13013,"curry":13014,"##pop":13015,"のこ":13016,"release":13017,"##←":13018,"##◆◆":13019,"##cast":13020,"073":13021,"ありな":13022,"500ml":13023,"##ews":13024,"5c":13025,"##stle":13026,"ios7":13027,"##ima":13028,"787":13029,"dog":13030,"lenovo":13031,"##r4":13032,"roger":13033,"013":13034,"cbs":13035,"vornado":13036,"100m":13037,"417":13038,"##desk":13039,"##クok":13040,"##ald":13041,"1867":13042,"9595":13043,"2900":13044,"##van":13045,"oil":13046,"##x":13047,"some":13048,"break":13049,"common":13050,"##jy":13051,"##lines":13052,"g7":13053,"twice":13054,"419":13055,"ella":13056,"nano":13057,"belle":13058,"にこ":13059,"##mes":13060,"##self":13061,"##note":13062,"jb":13063,"##ことかてきます":13064,"benz":13065,"##との":13066,"##ova":13067,"451":13068,"save":13069,"##wing":13070,"##ますのて":13071,"kai":13072,"りは":13073,"##hua":13074,"##rect":13075,"rainer":13076,"##unge":13077,"448":13078,"##0m":13079,"adsl":13080,"##かな":13081,"guestname":13082,"##uma":13083,"##kins":13084,"##zu":13085,"tokichoi":13086,"##price":13087,"county":13088,"##med":13089,"##mus":13090,"rmk":13091,"391":13092,"address":13093,"vm":13094,"えて":13095,"openload":13096,"##group":13097,"##hin":13098,"##iginal":13099,"amg":13100,"urban":13101,"##oz":13102,"jobs":13103,"emi":13104,"##public":13105,"beautiful":13106,"##sch":13107,"album":13108,"##dden":13109,"##bell":13110,"jerry":13111,"works":13112,"hostel":13113,"miller":13114,"##drive":13115,"##rmin":13116,"##10":13117,"376":13118,"boot":13119,"828":13120,"##370":13121,"##fx":13122,"##cm~":13123,"1885":13124,"##nome":13125,"##ctionary":13126,"##oman":13127,"##lish":13128,"##cr":13129,"##hm":13130,"433":13131,"##how":13132,"432":13133,"francis":13134,"xi":13135,"c919":13136,"b5":13137,"evernote":13138,"##uc":13139,"vga":13140,"##3000":13141,"coupe":13142,"##urg":13143,"##cca":13144,"##uality":13145,"019":13146,"6g":13147,"れる":13148,"multi":13149,"##また":13150,"##ett":13151,"em":13152,"hey":13153,"##ani":13154,"##tax":13155,"##rma":13156,"inside":13157,"than":13158,"740":13159,"leonnhurt":13160,"##jin":13161,"ict":13162,"れた":13163,"bird":13164,"notes":13165,"200mm":13166,"くの":13167,"##dical":13168,"##lli":13169,"result":13170,"442":13171,"iu":13172,"ee":13173,"438":13174,"smap":13175,"gopro":13176,"##last":13177,"yin":13178,"pure":13179,"998":13180,"32g":13181,"けた":13182,"5kg":13183,"##dan":13184,"##rame":13185,"mama":13186,"##oot":13187,"bean":13188,"marketing":13189,"##hur":13190,"2l":13191,"bella":13192,"sync":13193,"xuite":13194,"##ground":13195,"515":13196,"discuz":13197,"##getrelax":13198,"##ince":13199,"##bay":13200,"##5s":13201,"cj":13202,"##イス":13203,"gmat":13204,"apt":13205,"##pass":13206,"jing":13207,"##rix":13208,"c4":13209,"rich":13210,"##とても":13211,"niusnews":13212,"##ello":13213,"bag":13214,"770":13215,"##eting":13216,"##mobile":13217,"18":13218,"culture":13219,"015":13220,"##のてすか":13221,"377":13222,"1020":13223,"area":13224,"##ience":13225,"616":13226,"details":13227,"gp":13228,"universal":13229,"silver":13230,"dit":13231,"はお":13232,"private":13233,"ddd":13234,"u11":13235,"kanshu":13236,"##ified":13237,"fung":13238,"##nny":13239,"dx":13240,"##520":13241,"tai":13242,"475":13243,"023":13244,"##fr":13245,"##lean":13246,"3s":13247,"##pin":13248,"429":13249,"##rin":13250,"25000":13251,"ly":13252,"rick":13253,"##bility":13254,"usb3":13255,"banner":13256,"##baru":13257,"##gion":13258,"metal":13259,"dt":13260,"vdf":13261,"1871":13262,"karl":13263,"qualcomm":13264,"bear":13265,"1010":13266,"oldid":13267,"ian":13268,"jo":13269,"##tors":13270,"population":13271,"##ernel":13272,"1882":13273,"mmorpg":13274,"##mv":13275,"##bike":13276,"603":13277,"##©":13278,"ww":13279,"friend":13280,"##ager":13281,"exhibition":13282,"##del":13283,"##pods":13284,"fpx":13285,"structure":13286,"##free":13287,"##tings":13288,"kl":13289,"##rley":13290,"##copyright":13291,"##mma":13292,"california":13293,"3400":13294,"orange":13295,"yoga":13296,"4l":13297,"canmake":13298,"honey":13299,"##anda":13300,"##コメント":13301,"595":13302,"nikkie":13303,"##ルハイト":13304,"dhl":13305,"publishing":13306,"##mall":13307,"##gnet":13308,"20cm":13309,"513":13310,"##クセス":13311,"##┅":13312,"e88":13313,"970":13314,"##dog":13315,"fishbase":13316,"##!":13317,"##\"":13318,"###":13319,"##$":13320,"##%":13321,"##&":13322,"##'":13323,"##(":13324,"##)":13325,"##*":13326,"##+":13327,"##,":13328,"##-":13329,"##.":13330,"##/":13331,"##:":13332,"##;":13333,"##<":13334,"##=":13335,"##>":13336,"##?":13337,"##@":13338,"##[":13339,"##\\":13340,"##]":13341,"##^":13342,"##_":13343,"##{":13344,"##|":13345,"##}":13346,"##~":13347,"##£":13348,"##¤":13349,"##¥":13350,"##§":13351,"##«":13352,"##±":13353,"##³":13354,"##µ":13355,"##·":13356,"##¹":13357,"##º":13358,"##»":13359,"##¼":13360,"##ß":13361,"##æ":13362,"##÷":13363,"##ø":13364,"##đ":13365,"##ŋ":13366,"##ɔ":13367,"##ə":13368,"##ɡ":13369,"##ʰ":13370,"##ˇ":13371,"##ˈ":13372,"##ˊ":13373,"##ˋ":13374,"##ˍ":13375,"##ː":13376,"##˙":13377,"##˚":13378,"##ˢ":13379,"##α":13380,"##β":13381,"##γ":13382,"##δ":13383,"##ε":13384,"##η":13385,"##θ":13386,"##ι":13387,"##κ":13388,"##λ":13389,"##μ":13390,"##ν":13391,"##ο":13392,"##π":13393,"##ρ":13394,"##ς":13395,"##σ":13396,"##τ":13397,"##υ":13398,"##φ":13399,"##χ":13400,"##ψ":13401,"##б":13402,"##в":13403,"##г":13404,"##д":13405,"##е":13406,"##ж":13407,"##з":13408,"##к":13409,"##л":13410,"##м":13411,"##н":13412,"##о":13413,"##п":13414,"##р":13415,"##с":13416,"##т":13417,"##у":13418,"##ф":13419,"##х":13420,"##ц":13421,"##ч":13422,"##ш":13423,"##ы":13424,"##ь":13425,"##і":13426,"##ا":13427,"##ب":13428,"##ة":13429,"##ت":13430,"##د":13431,"##ر":13432,"##س":13433,"##ع":13434,"##ل":13435,"##م":13436,"##ن":13437,"##ه":13438,"##و":13439,"##ي":13440,"##۩":13441,"##ก":13442,"##ง":13443,"##น":13444,"##ม":13445,"##ย":13446,"##ร":13447,"##อ":13448,"##า":13449,"##เ":13450,"##๑":13451,"##་":13452,"##ღ":13453,"##ᄀ":13454,"##ᄁ":13455,"##ᄂ":13456,"##ᄃ":13457,"##ᄅ":13458,"##ᄆ":13459,"##ᄇ":13460,"##ᄈ":13461,"##ᄉ":13462,"##ᄋ":13463,"##ᄌ":13464,"##ᄎ":13465,"##ᄏ":13466,"##ᄐ":13467,"##ᄑ":13468,"##ᄒ":13469,"##ᅢ":13470,"##ᅣ":13471,"##ᅥ":13472,"##ᅦ":13473,"##ᅧ":13474,"##ᅨ":13475,"##ᅪ":13476,"##ᅬ":13477,"##ᅭ":13478,"##ᅮ":13479,"##ᅯ":13480,"##ᅲ":13481,"##ᅳ":13482,"##ᅴ":13483,"##ᆷ":13484,"##ᆸ":13485,"##ᆺ":13486,"##ᆻ":13487,"##ᗜ":13488,"##ᵃ":13489,"##ᵉ":13490,"##ᵍ":13491,"##ᵏ":13492,"##ᵐ":13493,"##ᵒ":13494,"##ᵘ":13495,"##‖":13496,"##„":13497,"##†":13498,"##•":13499,"##‥":13500,"##‧":13501,"##
":13502,"##‰":13503,"##′":13504,"##″":13505,"##‹":13506,"##›":13507,"##※":13508,"##‿":13509,"##⁄":13510,"##ⁱ":13511,"##⁺":13512,"##ⁿ":13513,"##₁":13514,"##₃":13515,"##₄":13516,"##€":13517,"##№":13518,"##ⅰ":13519,"##ⅱ":13520,"##ⅲ":13521,"##ⅳ":13522,"##ⅴ":13523,"##↔":13524,"##↗":13525,"##↘":13526,"##⇒":13527,"##∀":13528,"##−":13529,"##∕":13530,"##∙":13531,"##√":13532,"##∞":13533,"##∟":13534,"##∠":13535,"##∣":13536,"##∩":13537,"##∮":13538,"##∶":13539,"##∼":13540,"##∽":13541,"##≈":13542,"##≒":13543,"##≡":13544,"##≤":13545,"##≥":13546,"##≦":13547,"##≧":13548,"##≪":13549,"##≫":13550,"##⊙":13551,"##⋅":13552,"##⋈":13553,"##⋯":13554,"##⌒":13555,"##①":13556,"##②":13557,"##③":13558,"##④":13559,"##⑤":13560,"##⑥":13561,"##⑦":13562,"##⑧":13563,"##⑨":13564,"##⑩":13565,"##⑴":13566,"##⑵":13567,"##⑶":13568,"##⑷":13569,"##⑸":13570,"##⒈":13571,"##⒉":13572,"##⒊":13573,"##⒋":13574,"##ⓒ":13575,"##ⓔ":13576,"##ⓘ":13577,"##━":13578,"##┃":13579,"##┆":13580,"##┊":13581,"##┌":13582,"##└":13583,"##├":13584,"##┣":13585,"##═":13586,"##║":13587,"##╚":13588,"##╞":13589,"##╠":13590,"##╭":13591,"##╮":13592,"##╯":13593,"##╰":13594,"##╱":13595,"##╳":13596,"##▂":13597,"##▃":13598,"##▅":13599,"##▇":13600,"##▉":13601,"##▋":13602,"##▌":13603,"##▍":13604,"##▎":13605,"##□":13606,"##▪":13607,"##▫":13608,"##▬":13609,"##△":13610,"##▶":13611,"##►":13612,"##▽":13613,"##◇":13614,"##◕":13615,"##◠":13616,"##◢":13617,"##◤":13618,"##☀":13619,"##☕":13620,"##☞":13621,"##☺":13622,"##☼":13623,"##♀":13624,"##♂":13625,"##♠":13626,"##♡":13627,"##♣":13628,"##♦":13629,"##♫":13630,"##♬":13631,"##✈":13632,"##✔":13633,"##✕":13634,"##✖":13635,"##✦":13636,"##✨":13637,"##✪":13638,"##✰":13639,"##✿":13640,"##❀":13641,"##➜":13642,"##➤":13643,"##⦿":13644,"##、":13645,"##。":13646,"##〃":13647,"##々":13648,"##〇":13649,"##〈":13650,"##〉":13651,"##《":13652,"##》":13653,"##「":13654,"##」":13655,"##『":13656,"##』":13657,"##【":13658,"##】":13659,"##〓":13660,"##〔":13661,"##〕":13662,"##〖":13663,"##〗":13664,"##〜":13665,"##〝":13666,"##〞":13667,"##ぃ":13668,"##ぇ":13669,"##ぬ":13670,"##ふ":13671,"##ほ":13672,"##む":13673,"##ゃ":13674,"##ゅ":13675,"##ゆ":13676,"##ょ":13677,"##゜":13678,"##ゝ":13679,"##ァ":13680,"##ゥ":13681,"##エ":13682,"##ォ":13683,"##ケ":13684,"##サ":13685,"##セ":13686,"##ソ":13687,"##ッ":13688,"##ニ":13689,"##ヌ":13690,"##ネ":13691,"##ノ":13692,"##ヘ":13693,"##モ":13694,"##ャ":13695,"##ヤ":13696,"##ュ":13697,"##ユ":13698,"##ョ":13699,"##ヨ":13700,"##ワ":13701,"##ヲ":13702,"##・":13703,"##ヽ":13704,"##ㄅ":13705,"##ㄆ":13706,"##ㄇ":13707,"##ㄉ":13708,"##ㄋ":13709,"##ㄌ":13710,"##ㄍ":13711,"##ㄎ":13712,"##ㄏ":13713,"##ㄒ":13714,"##ㄚ":13715,"##ㄛ":13716,"##ㄞ":13717,"##ㄟ":13718,"##ㄢ":13719,"##ㄤ":13720,"##ㄥ":13721,"##ㄧ":13722,"##ㄨ":13723,"##ㆍ":13724,"##㈦":13725,"##㊣":13726,"##㗎":13727,"##一":13728,"##丁":13729,"##七":13730,"##万":13731,"##丈":13732,"##三":13733,"##上":13734,"##下":13735,"##不":13736,"##与":13737,"##丐":13738,"##丑":13739,"##专":13740,"##且":13741,"##丕":13742,"##世":13743,"##丘":13744,"##丙":13745,"##业":13746,"##丛":13747,"##东":13748,"##丝":13749,"##丞":13750,"##丟":13751,"##両":13752,"##丢":13753,"##两":13754,"##严":13755,"##並":13756,"##丧":13757,"##丨":13758,"##个":13759,"##丫":13760,"##中":13761,"##丰":13762,"##串":13763,"##临":13764,"##丶":13765,"##丸":13766,"##丹":13767,"##为":13768,"##主":13769,"##丼":13770,"##丽":13771,"##举":13772,"##丿":13773,"##乂":13774,"##乃":13775,"##久":13776,"##么":13777,"##义":13778,"##之":13779,"##乌":13780,"##乍":13781,"##乎":13782,"##乏":13783,"##乐":13784,"##乒":13785,"##乓":13786,"##乔":13787,"##乖":13788,"##乗":13789,"##乘":13790,"##乙":13791,"##乜":13792,"##九":13793,"##乞":13794,"##也":13795,"##习":13796,"##乡":13797,"##书":13798,"##乩":13799,"##买":13800,"##乱":13801,"##乳":13802,"##乾":13803,"##亀":13804,"##亂":13805,"##了":13806,"##予":13807,"##争":13808,"##事":13809,"##二":13810,"##于":13811,"##亏":13812,"##云":13813,"##互":13814,"##五":13815,"##井":13816,"##亘":13817,"##亙":13818,"##亚":13819,"##些":13820,"##亜":13821,"##亞":13822,"##亟":13823,"##亡":13824,"##亢":13825,"##交":13826,"##亥":13827,"##亦":13828,"##产":13829,"##亨":13830,"##亩":13831,"##享":13832,"##京":13833,"##亭":13834,"##亮":13835,"##亲":13836,"##亳":13837,"##亵":13838,"##人":13839,"##亿":13840,"##什":13841,"##仁":13842,"##仃":13843,"##仄":13844,"##仅":13845,"##仆":13846,"##仇":13847,"##今":13848,"##介":13849,"##仍":13850,"##从":13851,"##仏":13852,"##仑":13853,"##仓":13854,"##仔":13855,"##仕":13856,"##他":13857,"##仗":13858,"##付":13859,"##仙":13860,"##仝":13861,"##仞":13862,"##仟":13863,"##代":13864,"##令":13865,"##以":13866,"##仨":13867,"##仪":13868,"##们":13869,"##仮":13870,"##仰":13871,"##仲":13872,"##件":13873,"##价":13874,"##任":13875,"##份":13876,"##仿":13877,"##企":13878,"##伉":13879,"##伊":13880,"##伍":13881,"##伎":13882,"##伏":13883,"##伐":13884,"##休":13885,"##伕":13886,"##众":13887,"##优":13888,"##伙":13889,"##会":13890,"##伝":13891,"##伞":13892,"##伟":13893,"##传":13894,"##伢":13895,"##伤":13896,"##伦":13897,"##伪":13898,"##伫":13899,"##伯":13900,"##估":13901,"##伴":13902,"##伶":13903,"##伸":13904,"##伺":13905,"##似":13906,"##伽":13907,"##佃":13908,"##但":13909,"##佇":13910,"##佈":13911,"##位":13912,"##低":13913,"##住":13914,"##佐":13915,"##佑":13916,"##体":13917,"##佔":13918,"##何":13919,"##佗":13920,"##佘":13921,"##余":13922,"##佚":13923,"##佛":13924,"##作":13925,"##佝":13926,"##佞":13927,"##佟":13928,"##你":13929,"##佢":13930,"##佣":13931,"##佤":13932,"##佥":13933,"##佩":13934,"##佬":13935,"##佯":13936,"##佰":13937,"##佳":13938,"##併":13939,"##佶":13940,"##佻":13941,"##佼":13942,"##使":13943,"##侃":13944,"##侄":13945,"##來":13946,"##侈":13947,"##例":13948,"##侍":13949,"##侏":13950,"##侑":13951,"##侖":13952,"##侗":13953,"##供":13954,"##依":13955,"##侠":13956,"##価":13957,"##侣":13958,"##侥":13959,"##侦":13960,"##侧":13961,"##侨":13962,"##侬":13963,"##侮":13964,"##侯":13965,"##侵":13966,"##侶":13967,"##侷":13968,"##便":13969,"##係":13970,"##促":13971,"##俄":13972,"##俊":13973,"##俎":13974,"##俏":13975,"##俐":13976,"##俑":13977,"##俗":13978,"##俘":13979,"##俚":13980,"##保":13981,"##俞":13982,"##俟":13983,"##俠":13984,"##信":13985,"##俨":13986,"##俩":13987,"##俪":13988,"##俬":13989,"##俭":13990,"##修":13991,"##俯":13992,"##俱":13993,"##俳":13994,"##俸":13995,"##俺":13996,"##俾":13997,"##倆":13998,"##倉":13999,"##個":14000,"##倌":14001,"##倍":14002,"##倏":14003,"##們":14004,"##倒":14005,"##倔":14006,"##倖":14007,"##倘":14008,"##候":14009,"##倚":14010,"##倜":14011,"##借":14012,"##倡":14013,"##値":14014,"##倦":14015,"##倩":14016,"##倪":14017,"##倫":14018,"##倬":14019,"##倭":14020,"##倶":14021,"##债":14022,"##值":14023,"##倾":14024,"##偃":14025,"##假":14026,"##偈":14027,"##偉":14028,"##偌":14029,"##偎":14030,"##偏":14031,"##偕":14032,"##做":14033,"##停":14034,"##健":14035,"##側":14036,"##偵":14037,"##偶":14038,"##偷":14039,"##偻":14040,"##偽":14041,"##偿":14042,"##傀":14043,"##傅":14044,"##傍":14045,"##傑":14046,"##傘":14047,"##備":14048,"##傚":14049,"##傢":14050,"##傣":14051,"##傥":14052,"##储":14053,"##傩":14054,"##催":14055,"##傭":14056,"##傲":14057,"##傳":14058,"##債":14059,"##傷":14060,"##傻":14061,"##傾":14062,"##僅":14063,"##働":14064,"##像":14065,"##僑":14066,"##僕":14067,"##僖":14068,"##僚":14069,"##僥":14070,"##僧":14071,"##僭":14072,"##僮":14073,"##僱":14074,"##僵":14075,"##價":14076,"##僻":14077,"##儀":14078,"##儂":14079,"##億":14080,"##儆":14081,"##儉":14082,"##儋":14083,"##儒":14084,"##儕":14085,"##儘":14086,"##償":14087,"##儡":14088,"##優":14089,"##儲":14090,"##儷":14091,"##儼":14092,"##儿":14093,"##兀":14094,"##允":14095,"##元":14096,"##兄":14097,"##充":14098,"##兆":14099,"##兇":14100,"##先":14101,"##光":14102,"##克":14103,"##兌":14104,"##免":14105,"##児":14106,"##兑":14107,"##兒":14108,"##兔":14109,"##兖":14110,"##党":14111,"##兜":14112,"##兢":14113,"##入":14114,"##內":14115,"##全":14116,"##兩":14117,"##八":14118,"##公":14119,"##六":14120,"##兮":14121,"##兰":14122,"##共":14123,"##兲":14124,"##关":14125,"##兴":14126,"##兵":14127,"##其":14128,"##具":14129,"##典":14130,"##兹":14131,"##养":14132,"##兼":14133,"##兽":14134,"##冀":14135,"##内":14136,"##円":14137,"##冇":14138,"##冈":14139,"##冉":14140,"##冊":14141,"##册":14142,"##再":14143,"##冏":14144,"##冒":14145,"##冕":14146,"##冗":14147,"##写":14148,"##军":14149,"##农":14150,"##冠":14151,"##冢":14152,"##冤":14153,"##冥":14154,"##冨":14155,"##冪":14156,"##冬":14157,"##冯":14158,"##冰":14159,"##冲":14160,"##决":14161,"##况":14162,"##冶":14163,"##冷":14164,"##冻":14165,"##冼":14166,"##冽":14167,"##冾":14168,"##净":14169,"##凄":14170,"##准":14171,"##凇":14172,"##凈":14173,"##凉":14174,"##凋":14175,"##凌":14176,"##凍":14177,"##减":14178,"##凑":14179,"##凛":14180,"##凜":14181,"##凝":14182,"##几":14183,"##凡":14184,"##凤":14185,"##処":14186,"##凪":14187,"##凭":14188,"##凯":14189,"##凰":14190,"##凱":14191,"##凳":14192,"##凶":14193,"##凸":14194,"##凹":14195,"##出":14196,"##击":14197,"##函":14198,"##凿":14199,"##刀":14200,"##刁":14201,"##刃":14202,"##分":14203,"##切":14204,"##刈":14205,"##刊":14206,"##刍":14207,"##刎":14208,"##刑":14209,"##划":14210,"##列":14211,"##刘":14212,"##则":14213,"##刚":14214,"##创":14215,"##初":14216,"##删":14217,"##判":14218,"##別":14219,"##刨":14220,"##利":14221,"##刪":14222,"##别":14223,"##刮":14224,"##到":14225,"##制":14226,"##刷":14227,"##券":14228,"##刹":14229,"##刺":14230,"##刻":14231,"##刽":14232,"##剁":14233,"##剂":14234,"##剃":14235,"##則":14236,"##剉":14237,"##削":14238,"##剋":14239,"##剌":14240,"##前":14241,"##剎":14242,"##剐":14243,"##剑":14244,"##剔":14245,"##剖":14246,"##剛":14247,"##剜":14248,"##剝":14249,"##剣":14250,"##剤":14251,"##剥":14252,"##剧":14253,"##剩":14254,"##剪":14255,"##副":14256,"##割":14257,"##創":14258,"##剷":14259,"##剽":14260,"##剿":14261,"##劃":14262,"##劇":14263,"##劈":14264,"##劉":14265,"##劊":14266,"##劍":14267,"##劏":14268,"##劑":14269,"##力":14270,"##劝":14271,"##办":14272,"##功":14273,"##加":14274,"##务":14275,"##劣":14276,"##动":14277,"##助":14278,"##努":14279,"##劫":14280,"##劭":14281,"##励":14282,"##劲":14283,"##劳":14284,"##労":14285,"##劵":14286,"##効":14287,"##劾":14288,"##势":14289,"##勁":14290,"##勃":14291,"##勇":14292,"##勉":14293,"##勋":14294,"##勐":14295,"##勒":14296,"##動":14297,"##勖":14298,"##勘":14299,"##務":14300,"##勛":14301,"##勝":14302,"##勞":14303,"##募":14304,"##勢":14305,"##勤":14306,"##勧":14307,"##勳":14308,"##勵":14309,"##勸":14310,"##勺":14311,"##勻":14312,"##勾":14313,"##勿":14314,"##匀":14315,"##包":14316,"##匆":14317,"##匈":14318,"##匍":14319,"##匐":14320,"##匕":14321,"##化":14322,"##北":14323,"##匙":14324,"##匝":14325,"##匠":14326,"##匡":14327,"##匣":14328,"##匪":14329,"##匮":14330,"##匯":14331,"##匱":14332,"##匹":14333,"##区":14334,"##医":14335,"##匾":14336,"##匿":14337,"##區":14338,"##十":14339,"##千":14340,"##卅":14341,"##升":14342,"##午":14343,"##卉":14344,"##半":14345,"##卍":14346,"##华":14347,"##协":14348,"##卑":14349,"##卒":14350,"##卓":14351,"##協":14352,"##单":14353,"##卖":14354,"##南":14355,"##単":14356,"##博":14357,"##卜":14358,"##卞":14359,"##卟":14360,"##占":14361,"##卡":14362,"##卢":14363,"##卤":14364,"##卦":14365,"##卧":14366,"##卫":14367,"##卮":14368,"##卯":14369,"##印":14370,"##危":14371,"##即":14372,"##却":14373,"##卵":14374,"##卷":14375,"##卸":14376,"##卻":14377,"##卿":14378,"##厂":14379,"##厄":14380,"##厅":14381,"##历":14382,"##厉":14383,"##压":14384,"##厌":14385,"##厕":14386,"##厘":14387,"##厚":14388,"##厝":14389,"##原":14390,"##厢":14391,"##厥":14392,"##厦":14393,"##厨":14394,"##厩":14395,"##厭":14396,"##厮":14397,"##厲":14398,"##厳":14399,"##去":14400,"##县":14401,"##叁":14402,"##参":14403,"##參":14404,"##又":14405,"##叉":14406,"##及":14407,"##友":14408,"##双":14409,"##反":14410,"##収":14411,"##发":14412,"##叔":14413,"##取":14414,"##受":14415,"##变":14416,"##叙":14417,"##叛":14418,"##叟":14419,"##叠":14420,"##叡":14421,"##叢":14422,"##口":14423,"##古":14424,"##句":14425,"##另":14426,"##叨":14427,"##叩":14428,"##只":14429,"##叫":14430,"##召":14431,"##叭":14432,"##叮":14433,"##可":14434,"##台":14435,"##叱":14436,"##史":14437,"##右":14438,"##叵":14439,"##叶":14440,"##号":14441,"##司":14442,"##叹":14443,"##叻":14444,"##叼":14445,"##叽":14446,"##吁":14447,"##吃":14448,"##各":14449,"##吆":14450,"##合":14451,"##吉":14452,"##吊":14453,"##吋":14454,"##同":14455,"##名":14456,"##后":14457,"##吏":14458,"##吐":14459,"##向":14460,"##吒":14461,"##吓":14462,"##吕":14463,"##吖":14464,"##吗":14465,"##君":14466,"##吝":14467,"##吞":14468,"##吟":14469,"##吠":14470,"##吡":14471,"##否":14472,"##吧":14473,"##吨":14474,"##吩":14475,"##含":14476,"##听":14477,"##吭":14478,"##吮":14479,"##启":14480,"##吱":14481,"##吳":14482,"##吴":14483,"##吵":14484,"##吶":14485,"##吸":14486,"##吹":14487,"##吻":14488,"##吼":14489,"##吽":14490,"##吾":14491,"##呀":14492,"##呂":14493,"##呃":14494,"##呆":14495,"##呈":14496,"##告":14497,"##呋":14498,"##呎":14499,"##呐":14500,"##呓":14501,"##呕":14502,"##呗":14503,"##员":14504,"##呛":14505,"##呜":14506,"##呢":14507,"##呤":14508,"##呦":14509,"##周":14510,"##呱":14511,"##呲":14512,"##味":14513,"##呵":14514,"##呷":14515,"##呸":14516,"##呻":14517,"##呼":14518,"##命":14519,"##咀":14520,"##咁":14521,"##咂":14522,"##咄":14523,"##咆":14524,"##咋":14525,"##和":14526,"##咎":14527,"##咏":14528,"##咐":14529,"##咒":14530,"##咔":14531,"##咕":14532,"##咖":14533,"##咗":14534,"##咘":14535,"##咙":14536,"##咚":14537,"##咛":14538,"##咣":14539,"##咤":14540,"##咦":14541,"##咧":14542,"##咨":14543,"##咩":14544,"##咪":14545,"##咫":14546,"##咬":14547,"##咭":14548,"##咯":14549,"##咱":14550,"##咲":14551,"##咳":14552,"##咸":14553,"##咻":14554,"##咽":14555,"##咿":14556,"##哀":14557,"##品":14558,"##哂":14559,"##哄":14560,"##哆":14561,"##哇":14562,"##哈":14563,"##哉":14564,"##哋":14565,"##哌":14566,"##响":14567,"##哎":14568,"##哏":14569,"##哐":14570,"##哑":14571,"##哒":14572,"##哔":14573,"##哗":14574,"##哟":14575,"##員":14576,"##哥":14577,"##哦":14578,"##哧":14579,"##哨":14580,"##哩":14581,"##哪":14582,"##哭":14583,"##哮":14584,"##哲":14585,"##哺":14586,"##哼":14587,"##哽":14588,"##唁":14589,"##唄":14590,"##唆":14591,"##唇":14592,"##唉":14593,"##唏":14594,"##唐":14595,"##唑":14596,"##唔":14597,"##唠":14598,"##唤":14599,"##唧":14600,"##唬":14601,"##售":14602,"##唯":14603,"##唰":14604,"##唱":14605,"##唳":14606,"##唷":14607,"##唸":14608,"##唾":14609,"##啃":14610,"##啄":14611,"##商":14612,"##啉":14613,"##啊":14614,"##問":14615,"##啓":14616,"##啕":14617,"##啖":14618,"##啜":14619,"##啞":14620,"##啟":14621,"##啡":14622,"##啤":14623,"##啥":14624,"##啦":14625,"##啧":14626,"##啪":14627,"##啫":14628,"##啬":14629,"##啮":14630,"##啰":14631,"##啱":14632,"##啲":14633,"##啵":14634,"##啶":14635,"##啷":14636,"##啸":14637,"##啻":14638,"##啼":14639,"##啾":14640,"##喀":14641,"##喂":14642,"##喃":14643,"##善":14644,"##喆":14645,"##喇":14646,"##喉":14647,"##喊":14648,"##喋":14649,"##喎":14650,"##喏":14651,"##喔":14652,"##喘":14653,"##喙":14654,"##喚":14655,"##喜":14656,"##喝":14657,"##喟":14658,"##喧":14659,"##喪":14660,"##喫":14661,"##喬":14662,"##單":14663,"##喰":14664,"##喱":14665,"##喲":14666,"##喳":14667,"##喵":14668,"##営":14669,"##喷":14670,"##喹":14671,"##喺":14672,"##喻":14673,"##喽":14674,"##嗅":14675,"##嗆":14676,"##嗇":14677,"##嗎":14678,"##嗑":14679,"##嗒":14680,"##嗓":14681,"##嗔":14682,"##嗖":14683,"##嗚":14684,"##嗜":14685,"##嗝":14686,"##嗟":14687,"##嗡":14688,"##嗣":14689,"##嗤":14690,"##嗦":14691,"##嗨":14692,"##嗪":14693,"##嗬":14694,"##嗯":14695,"##嗰":14696,"##嗲":14697,"##嗳":14698,"##嗶":14699,"##嗷":14700,"##嗽":14701,"##嘀":14702,"##嘅":14703,"##嘆":14704,"##嘈":14705,"##嘉":14706,"##嘌":14707,"##嘍":14708,"##嘎":14709,"##嘔":14710,"##嘖":14711,"##嘗":14712,"##嘘":14713,"##嘚":14714,"##嘛":14715,"##嘜":14716,"##嘞":14717,"##嘟":14718,"##嘢":14719,"##嘣":14720,"##嘤":14721,"##嘧":14722,"##嘩":14723,"##嘭":14724,"##嘮":14725,"##嘯":14726,"##嘰":14727,"##嘱":14728,"##嘲":14729,"##嘴":14730,"##嘶":14731,"##嘸":14732,"##嘹":14733,"##嘻":14734,"##嘿":14735,"##噁":14736,"##噌":14737,"##噎":14738,"##噓":14739,"##噔":14740,"##噗":14741,"##噙":14742,"##噜":14743,"##噠":14744,"##噢":14745,"##噤":14746,"##器":14747,"##噩":14748,"##噪":14749,"##噬":14750,"##噱":14751,"##噴":14752,"##噶":14753,"##噸":14754,"##噹":14755,"##噻":14756,"##噼":14757,"##嚀":14758,"##嚇":14759,"##嚎":14760,"##嚏":14761,"##嚐":14762,"##嚓":14763,"##嚕":14764,"##嚟":14765,"##嚣":14766,"##嚥":14767,"##嚨":14768,"##嚮":14769,"##嚴":14770,"##嚷":14771,"##嚼":14772,"##囂":14773,"##囉":14774,"##囊":14775,"##囍":14776,"##囑":14777,"##囔":14778,"##囗":14779,"##囚":14780,"##四":14781,"##囝":14782,"##回":14783,"##囟":14784,"##因":14785,"##囡":14786,"##团":14787,"##団":14788,"##囤":14789,"##囧":14790,"##囪":14791,"##囫":14792,"##园":14793,"##困":14794,"##囱":14795,"##囲":14796,"##図":14797,"##围":14798,"##囹":14799,"##固":14800,"##国":14801,"##图":14802,"##囿":14803,"##圃":14804,"##圄":14805,"##圆":14806,"##圈":14807,"##國":14808,"##圍":14809,"##圏":14810,"##園":14811,"##圓":14812,"##圖":14813,"##團":14814,"##圜":14815,"##土":14816,"##圣":14817,"##圧":14818,"##在":14819,"##圩":14820,"##圭":14821,"##地":14822,"##圳":14823,"##场":14824,"##圻":14825,"##圾":14826,"##址":14827,"##坂":14828,"##均":14829,"##坊":14830,"##坍":14831,"##坎":14832,"##坏":14833,"##坐":14834,"##坑":14835,"##块":14836,"##坚":14837,"##坛":14838,"##坝":14839,"##坞":14840,"##坟":14841,"##坠":14842,"##坡":14843,"##坤":14844,"##坦":14845,"##坨":14846,"##坪":14847,"##坯":14848,"##坳":14849,"##坵":14850,"##坷":14851,"##垂":14852,"##垃":14853,"##垄":14854,"##型":14855,"##垒":14856,"##垚":14857,"##垛":14858,"##垠":14859,"##垢":14860,"##垣":14861,"##垦":14862,"##垩":14863,"##垫":14864,"##垭":14865,"##垮":14866,"##垵":14867,"##埂":14868,"##埃":14869,"##埋":14870,"##城":14871,"##埔":14872,"##埕":14873,"##埗":14874,"##域":14875,"##埠":14876,"##埤":14877,"##埵":14878,"##執":14879,"##埸":14880,"##培":14881,"##基":14882,"##埼":14883,"##堀":14884,"##堂":14885,"##堃":14886,"##堅":14887,"##堆":14888,"##堇":14889,"##堑":14890,"##堕":14891,"##堙":14892,"##堡":14893,"##堤":14894,"##堪":14895,"##堯":14896,"##堰":14897,"##報":14898,"##場":14899,"##堵":14900,"##堺":14901,"##堿":14902,"##塊":14903,"##塌":14904,"##塑":14905,"##塔":14906,"##塗":14907,"##塘":14908,"##塚":14909,"##塞":14910,"##塢":14911,"##塩":14912,"##填":14913,"##塬":14914,"##塭":14915,"##塵":14916,"##塾":14917,"##墀":14918,"##境":14919,"##墅":14920,"##墉":14921,"##墊":14922,"##墒":14923,"##墓":14924,"##増":14925,"##墘":14926,"##墙":14927,"##墜":14928,"##增":14929,"##墟":14930,"##墨":14931,"##墩":14932,"##墮":14933,"##墳":14934,"##墻":14935,"##墾":14936,"##壁":14937,"##壅":14938,"##壆":14939,"##壇":14940,"##壊":14941,"##壑":14942,"##壓":14943,"##壕":14944,"##壘":14945,"##壞":14946,"##壟":14947,"##壢":14948,"##壤":14949,"##壩":14950,"##士":14951,"##壬":14952,"##壮":14953,"##壯":14954,"##声":14955,"##売":14956,"##壳":14957,"##壶":14958,"##壹":14959,"##壺":14960,"##壽":14961,"##处":14962,"##备":14963,"##変":14964,"##复":14965,"##夏":14966,"##夔":14967,"##夕":14968,"##外":14969,"##夙":14970,"##多":14971,"##夜":14972,"##够":14973,"##夠":14974,"##夢":14975,"##夥":14976,"##大":14977,"##天":14978,"##太":14979,"##夫":14980,"##夭":14981,"##央":14982,"##夯":14983,"##失":14984,"##头":14985,"##夷":14986,"##夸":14987,"##夹":14988,"##夺":14989,"##夾":14990,"##奂":14991,"##奄":14992,"##奇":14993,"##奈":14994,"##奉":14995,"##奋":14996,"##奎":14997,"##奏":14998,"##奐":14999,"##契":15000,"##奔":15001,"##奕":15002,"##奖":15003,"##套":15004,"##奘":15005,"##奚":15006,"##奠":15007,"##奢":15008,"##奥":15009,"##奧":15010,"##奪":15011,"##奬":15012,"##奮":15013,"##女":15014,"##奴":15015,"##奶":15016,"##奸":15017,"##她":15018,"##好":15019,"##如":15020,"##妃":15021,"##妄":15022,"##妆":15023,"##妇":15024,"##妈":15025,"##妊":15026,"##妍":15027,"##妒":15028,"##妓":15029,"##妖":15030,"##妘":15031,"##妙":15032,"##妝":15033,"##妞":15034,"##妣":15035,"##妤":15036,"##妥":15037,"##妨":15038,"##妩":15039,"##妪":15040,"##妮":15041,"##妲":15042,"##妳":15043,"##妹":15044,"##妻":15045,"##妾":15046,"##姆":15047,"##姉":15048,"##姊":15049,"##始":15050,"##姍":15051,"##姐":15052,"##姑":15053,"##姒":15054,"##姓":15055,"##委":15056,"##姗":15057,"##姚":15058,"##姜":15059,"##姝":15060,"##姣":15061,"##姥":15062,"##姦":15063,"##姨":15064,"##姪":15065,"##姫":15066,"##姬":15067,"##姹":15068,"##姻":15069,"##姿":15070,"##威":15071,"##娃":15072,"##娄":15073,"##娅":15074,"##娆":15075,"##娇":15076,"##娉":15077,"##娑":15078,"##娓":15079,"##娘":15080,"##娛":15081,"##娜":15082,"##娟":15083,"##娠":15084,"##娣":15085,"##娥":15086,"##娩":15087,"##娱":15088,"##娲":15089,"##娴":15090,"##娶":15091,"##娼":15092,"##婀":15093,"##婁":15094,"##婆":15095,"##婉":15096,"##婊":15097,"##婕":15098,"##婚":15099,"##婢":15100,"##婦":15101,"##婧":15102,"##婪":15103,"##婭":15104,"##婴":15105,"##婵":15106,"##婶":15107,"##婷":15108,"##婺":15109,"##婿":15110,"##媒":15111,"##媚":15112,"##媛":15113,"##媞":15114,"##媧":15115,"##媲":15116,"##媳":15117,"##媽":15118,"##媾":15119,"##嫁":15120,"##嫂":15121,"##嫉":15122,"##嫌":15123,"##嫑":15124,"##嫔":15125,"##嫖":15126,"##嫘":15127,"##嫚":15128,"##嫡":15129,"##嫣":15130,"##嫦":15131,"##嫩":15132,"##嫲":15133,"##嫵":15134,"##嫻":15135,"##嬅":15136,"##嬉":15137,"##嬌":15138,"##嬗":15139,"##嬛":15140,"##嬢":15141,"##嬤":15142,"##嬪":15143,"##嬰":15144,"##嬴":15145,"##嬷":15146,"##嬸":15147,"##嬿":15148,"##孀":15149,"##孃":15150,"##子":15151,"##孑":15152,"##孔":15153,"##孕":15154,"##孖":15155,"##字":15156,"##存":15157,"##孙":15158,"##孚":15159,"##孛":15160,"##孜":15161,"##孝":15162,"##孟":15163,"##孢":15164,"##季":15165,"##孤":15166,"##学":15167,"##孩":15168,"##孪":15169,"##孫":15170,"##孬":15171,"##孰":15172,"##孱":15173,"##孳":15174,"##孵":15175,"##學":15176,"##孺":15177,"##孽":15178,"##孿":15179,"##宁":15180,"##它":15181,"##宅":15182,"##宇":15183,"##守":15184,"##安":15185,"##宋":15186,"##完":15187,"##宏":15188,"##宓":15189,"##宕":15190,"##宗":15191,"##官":15192,"##宙":15193,"##定":15194,"##宛":15195,"##宜":15196,"##宝":15197,"##实":15198,"##実":15199,"##宠":15200,"##审":15201,"##客":15202,"##宣":15203,"##室":15204,"##宥":15205,"##宦":15206,"##宪":15207,"##宫":15208,"##宮":15209,"##宰":15210,"##害":15211,"##宴":15212,"##宵":15213,"##家":15214,"##宸":15215,"##容":15216,"##宽":15217,"##宾":15218,"##宿":15219,"##寂":15220,"##寄":15221,"##寅":15222,"##密":15223,"##寇":15224,"##富":15225,"##寐":15226,"##寒":15227,"##寓":15228,"##寛":15229,"##寝":15230,"##寞":15231,"##察":15232,"##寡":15233,"##寢":15234,"##寥":15235,"##實":15236,"##寧":15237,"##寨":15238,"##審":15239,"##寫":15240,"##寬":15241,"##寮":15242,"##寰":15243,"##寵":15244,"##寶":15245,"##寸":15246,"##对":15247,"##寺":15248,"##寻":15249,"##导":15250,"##対":15251,"##寿":15252,"##封":15253,"##専":15254,"##射":15255,"##将":15256,"##將":15257,"##專":15258,"##尉":15259,"##尊":15260,"##尋":15261,"##對":15262,"##導":15263,"##小":15264,"##少":15265,"##尔":15266,"##尕":15267,"##尖":15268,"##尘":15269,"##尚":15270,"##尝":15271,"##尤":15272,"##尧":15273,"##尬":15274,"##就":15275,"##尴":15276,"##尷":15277,"##尸":15278,"##尹":15279,"##尺":15280,"##尻":15281,"##尼":15282,"##尽":15283,"##尾":15284,"##尿":15285,"##局":15286,"##屁":15287,"##层":15288,"##屄":15289,"##居":15290,"##屆":15291,"##屈":15292,"##屉":15293,"##届":15294,"##屋":15295,"##屌":15296,"##屍":15297,"##屎":15298,"##屏":15299,"##屐":15300,"##屑":15301,"##展":15302,"##屜":15303,"##属":15304,"##屠":15305,"##屡":15306,"##屢":15307,"##層":15308,"##履":15309,"##屬":15310,"##屯":15311,"##山":15312,"##屹":15313,"##屿":15314,"##岀":15315,"##岁":15316,"##岂":15317,"##岌":15318,"##岐":15319,"##岑":15320,"##岔":15321,"##岖":15322,"##岗":15323,"##岘":15324,"##岙":15325,"##岚":15326,"##岛":15327,"##岡":15328,"##岩":15329,"##岫":15330,"##岬":15331,"##岭":15332,"##岱":15333,"##岳":15334,"##岷":15335,"##岸":15336,"##峇":15337,"##峋":15338,"##峒":15339,"##峙":15340,"##峡":15341,"##峤":15342,"##峥":15343,"##峦":15344,"##峨":15345,"##峪":15346,"##峭":15347,"##峯":15348,"##峰":15349,"##峴":15350,"##島":15351,"##峻":15352,"##峽":15353,"##崁":15354,"##崂":15355,"##崆":15356,"##崇":15357,"##崎":15358,"##崑":15359,"##崔":15360,"##崖":15361,"##崗":15362,"##崙":15363,"##崛":15364,"##崧":15365,"##崩":15366,"##崭":15367,"##崴":15368,"##崽":15369,"##嵇":15370,"##嵊":15371,"##嵋":15372,"##嵌":15373,"##嵐":15374,"##嵘":15375,"##嵩":15376,"##嵬":15377,"##嵯":15378,"##嶂":15379,"##嶄":15380,"##嶇":15381,"##嶋":15382,"##嶙":15383,"##嶺":15384,"##嶼":15385,"##嶽":15386,"##巅":15387,"##巍":15388,"##巒":15389,"##巔":15390,"##巖":15391,"##川":15392,"##州":15393,"##巡":15394,"##巢":15395,"##工":15396,"##左":15397,"##巧":15398,"##巨":15399,"##巩":15400,"##巫":15401,"##差":15402,"##己":15403,"##已":15404,"##巳":15405,"##巴":15406,"##巷":15407,"##巻":15408,"##巽":15409,"##巾":15410,"##巿":15411,"##币":15412,"##市":15413,"##布":15414,"##帅":15415,"##帆":15416,"##师":15417,"##希":15418,"##帐":15419,"##帑":15420,"##帕":15421,"##帖":15422,"##帘":15423,"##帚":15424,"##帛":15425,"##帜":15426,"##帝":15427,"##帥":15428,"##带":15429,"##帧":15430,"##師":15431,"##席":15432,"##帮":15433,"##帯":15434,"##帰":15435,"##帳":15436,"##帶":15437,"##帷":15438,"##常":15439,"##帼":15440,"##帽":15441,"##幀":15442,"##幂":15443,"##幄":15444,"##幅":15445,"##幌":15446,"##幔":15447,"##幕":15448,"##幟":15449,"##幡":15450,"##幢":15451,"##幣":15452,"##幫":15453,"##干":15454,"##平":15455,"##年":15456,"##并":15457,"##幸":15458,"##幹":15459,"##幺":15460,"##幻":15461,"##幼":15462,"##幽":15463,"##幾":15464,"##广":15465,"##庁":15466,"##広":15467,"##庄":15468,"##庆":15469,"##庇":15470,"##床":15471,"##序":15472,"##庐":15473,"##库":15474,"##应":15475,"##底":15476,"##庖":15477,"##店":15478,"##庙":15479,"##庚":15480,"##府":15481,"##庞":15482,"##废":15483,"##庠":15484,"##度":15485,"##座":15486,"##庫":15487,"##庭":15488,"##庵":15489,"##庶":15490,"##康":15491,"##庸":15492,"##庹":15493,"##庾":15494,"##廁":15495,"##廂":15496,"##廃":15497,"##廈":15498,"##廉":15499,"##廊":15500,"##廓":15501,"##廖":15502,"##廚":15503,"##廝":15504,"##廟":15505,"##廠":15506,"##廢":15507,"##廣":15508,"##廬":15509,"##廳":15510,"##延":15511,"##廷":15512,"##建":15513,"##廿":15514,"##开":15515,"##弁":15516,"##异":15517,"##弃":15518,"##弄":15519,"##弈":15520,"##弊":15521,"##弋":15522,"##式":15523,"##弑":15524,"##弒":15525,"##弓":15526,"##弔":15527,"##引":15528,"##弗":15529,"##弘":15530,"##弛":15531,"##弟":15532,"##张":15533,"##弥":15534,"##弦":15535,"##弧":15536,"##弩":15537,"##弭":15538,"##弯":15539,"##弱":15540,"##張":15541,"##強":15542,"##弹":15543,"##强":15544,"##弼":15545,"##弾":15546,"##彅":15547,"##彆":15548,"##彈":15549,"##彌":15550,"##彎":15551,"##归":15552,"##当":15553,"##录":15554,"##彗":15555,"##彙":15556,"##彝":15557,"##形":15558,"##彤":15559,"##彥":15560,"##彦":15561,"##彧":15562,"##彩":15563,"##彪":15564,"##彫":15565,"##彬":15566,"##彭":15567,"##彰":15568,"##影":15569,"##彷":15570,"##役":15571,"##彻":15572,"##彼":15573,"##彿":15574,"##往":15575,"##征":15576,"##径":15577,"##待":15578,"##徇":15579,"##很":15580,"##徉":15581,"##徊":15582,"##律":15583,"##後":15584,"##徐":15585,"##徑":15586,"##徒":15587,"##従":15588,"##徕":15589,"##得":15590,"##徘":15591,"##徙":15592,"##徜":15593,"##從":15594,"##徠":15595,"##御":15596,"##徨":15597,"##復":15598,"##循":15599,"##徬":15600,"##微":15601,"##徳":15602,"##徴":15603,"##徵":15604,"##德":15605,"##徹":15606,"##徼":15607,"##徽":15608,"##心":15609,"##必":15610,"##忆":15611,"##忌":15612,"##忍":15613,"##忏":15614,"##忐":15615,"##忑":15616,"##忒":15617,"##忖":15618,"##志":15619,"##忘":15620,"##忙":15621,"##応":15622,"##忠":15623,"##忡":15624,"##忤":15625,"##忧":15626,"##忪":15627,"##快":15628,"##忱":15629,"##念":15630,"##忻":15631,"##忽":15632,"##忿":15633,"##怀":15634,"##态":15635,"##怂":15636,"##怅":15637,"##怆":15638,"##怎":15639,"##怏":15640,"##怒":15641,"##怔":15642,"##怕":15643,"##怖":15644,"##怙":15645,"##怜":15646,"##思":15647,"##怠":15648,"##怡":15649,"##急":15650,"##怦":15651,"##性":15652,"##怨":15653,"##怪":15654,"##怯":15655,"##怵":15656,"##总":15657,"##怼":15658,"##恁":15659,"##恃":15660,"##恆":15661,"##恋":15662,"##恍":15663,"##恐":15664,"##恒":15665,"##恕":15666,"##恙":15667,"##恚":15668,"##恢":15669,"##恣":15670,"##恤":15671,"##恥":15672,"##恨":15673,"##恩":15674,"##恪":15675,"##恫":15676,"##恬":15677,"##恭":15678,"##息":15679,"##恰":15680,"##恳":15681,"##恵":15682,"##恶":15683,"##恸":15684,"##恺":15685,"##恻":15686,"##恼":15687,"##恿":15688,"##悄":15689,"##悅":15690,"##悉":15691,"##悌":15692,"##悍":15693,"##悔":15694,"##悖":15695,"##悚":15696,"##悟":15697,"##悠":15698,"##患":15699,"##悦":15700,"##您":15701,"##悩":15702,"##悪":15703,"##悬":15704,"##悯":15705,"##悱":15706,"##悲":15707,"##悴":15708,"##悵":15709,"##悶":15710,"##悸":15711,"##悻":15712,"##悼":15713,"##悽":15714,"##情":15715,"##惆":15716,"##惇":15717,"##惊":15718,"##惋":15719,"##惑":15720,"##惕":15721,"##惘":15722,"##惚":15723,"##惜":15724,"##惟":15725,"##惠":15726,"##惡":15727,"##惦":15728,"##惧":15729,"##惨":15730,"##惩":15731,"##惫":15732,"##惬":15733,"##惭":15734,"##惮":15735,"##惯":15736,"##惰":15737,"##惱":15738,"##想":15739,"##惴":15740,"##惶":15741,"##惹":15742,"##惺":15743,"##愁":15744,"##愆":15745,"##愈":15746,"##愉":15747,"##愍":15748,"##意":15749,"##愕":15750,"##愚":15751,"##愛":15752,"##愜":15753,"##感":15754,"##愣":15755,"##愤":15756,"##愧":15757,"##愫":15758,"##愷":15759,"##愿":15760,"##慄":15761,"##慈":15762,"##態":15763,"##慌":15764,"##慎":15765,"##慑":15766,"##慕":15767,"##慘":15768,"##慚":15769,"##慟":15770,"##慢":15771,"##慣":15772,"##慧":15773,"##慨":15774,"##慫":15775,"##慮":15776,"##慰":15777,"##慳":15778,"##慵":15779,"##慶":15780,"##慷":15781,"##慾":15782,"##憂":15783,"##憊":15784,"##憋":15785,"##憎":15786,"##憐":15787,"##憑":15788,"##憔":15789,"##憚":15790,"##憤":15791,"##憧":15792,"##憨":15793,"##憩":15794,"##憫":15795,"##憬":15796,"##憲":15797,"##憶":15798,"##憾":15799,"##懂":15800,"##懇":15801,"##懈":15802,"##應":15803,"##懊":15804,"##懋":15805,"##懑":15806,"##懒":15807,"##懦":15808,"##懲":15809,"##懵":15810,"##懶":15811,"##懷":15812,"##懸":15813,"##懺":15814,"##懼":15815,"##懾":15816,"##懿":15817,"##戀":15818,"##戈":15819,"##戊":15820,"##戌":15821,"##戍":15822,"##戎":15823,"##戏":15824,"##成":15825,"##我":15826,"##戒":15827,"##戕":15828,"##或":15829,"##战":15830,"##戚":15831,"##戛":15832,"##戟":15833,"##戡":15834,"##戦":15835,"##截":15836,"##戬":15837,"##戮":15838,"##戰":15839,"##戲":15840,"##戳":15841,"##戴":15842,"##戶":15843,"##户":15844,"##戸":15845,"##戻":15846,"##戾":15847,"##房":15848,"##所":15849,"##扁":15850,"##扇":15851,"##扈":15852,"##扉":15853,"##手":15854,"##才":15855,"##扎":15856,"##扑":15857,"##扒":15858,"##打":15859,"##扔":15860,"##払":15861,"##托":15862,"##扛":15863,"##扣":15864,"##扦":15865,"##执":15866,"##扩":15867,"##扪":15868,"##扫":15869,"##扬":15870,"##扭":15871,"##扮":15872,"##扯":15873,"##扰":15874,"##扱":15875,"##扳":15876,"##扶":15877,"##批":15878,"##扼":15879,"##找":15880,"##承":15881,"##技":15882,"##抄":15883,"##抉":15884,"##把":15885,"##抑":15886,"##抒":15887,"##抓":15888,"##投":15889,"##抖":15890,"##抗":15891,"##折":15892,"##抚":15893,"##抛":15894,"##抜":15895,"##択":15896,"##抟":15897,"##抠":15898,"##抡":15899,"##抢":15900,"##护":15901,"##报":15902,"##抨":15903,"##披":15904,"##抬":15905,"##抱":15906,"##抵":15907,"##抹":15908,"##押":15909,"##抽":15910,"##抿":15911,"##拂":15912,"##拄":15913,"##担":15914,"##拆":15915,"##拇":15916,"##拈":15917,"##拉":15918,"##拋":15919,"##拌":15920,"##拍":15921,"##拎":15922,"##拐":15923,"##拒":15924,"##拓":15925,"##拔":15926,"##拖":15927,"##拗":15928,"##拘":15929,"##拙":15930,"##拚":15931,"##招":15932,"##拜":15933,"##拟":15934,"##拡":15935,"##拢":15936,"##拣":15937,"##拥":15938,"##拦":15939,"##拧":15940,"##拨":15941,"##择":15942,"##括":15943,"##拭":15944,"##拮":15945,"##拯":15946,"##拱":15947,"##拳":15948,"##拴":15949,"##拷":15950,"##拼":15951,"##拽":15952,"##拾":15953,"##拿":15954,"##持":15955,"##挂":15956,"##指":15957,"##挈":15958,"##按":15959,"##挎":15960,"##挑":15961,"##挖":15962,"##挙":15963,"##挚":15964,"##挛":15965,"##挝":15966,"##挞":15967,"##挟":15968,"##挠":15969,"##挡":15970,"##挣":15971,"##挤":15972,"##挥":15973,"##挨":15974,"##挪":15975,"##挫":15976,"##振":15977,"##挲":15978,"##挹":15979,"##挺":15980,"##挽":15981,"##挾":15982,"##捂":15983,"##捅":15984,"##捆":15985,"##捉":15986,"##捋":15987,"##捌":15988,"##捍":15989,"##捎":15990,"##捏":15991,"##捐":15992,"##捕":15993,"##捞":15994,"##损":15995,"##捡":15996,"##换":15997,"##捣":15998,"##捧":15999,"##捨":16000,"##捩":16001,"##据":16002,"##捱":16003,"##捲":16004,"##捶":16005,"##捷":16006,"##捺":16007,"##捻":16008,"##掀":16009,"##掂":16010,"##掃":16011,"##掇":16012,"##授":16013,"##掉":16014,"##掌":16015,"##掏":16016,"##掐":16017,"##排":16018,"##掖":16019,"##掘":16020,"##掙":16021,"##掛":16022,"##掠":16023,"##採":16024,"##探":16025,"##掣":16026,"##接":16027,"##控":16028,"##推":16029,"##掩":16030,"##措":16031,"##掬":16032,"##掰":16033,"##掲":16034,"##掳":16035,"##掴":16036,"##掷":16037,"##掸":16038,"##掺":16039,"##揀":16040,"##揃":16041,"##揄":16042,"##揆":16043,"##揉":16044,"##揍":16045,"##描":16046,"##提":16047,"##插":16048,"##揖":16049,"##揚":16050,"##換":16051,"##握":16052,"##揣":16053,"##揩":16054,"##揪":16055,"##揭":16056,"##揮":16057,"##援":16058,"##揶":16059,"##揸":16060,"##揹":16061,"##揽":16062,"##搀":16063,"##搁":16064,"##搂":16065,"##搅":16066,"##損":16067,"##搏":16068,"##搐":16069,"##搓":16070,"##搔":16071,"##搖":16072,"##搗":16073,"##搜":16074,"##搞":16075,"##搡":16076,"##搪":16077,"##搬":16078,"##搭":16079,"##搵":16080,"##搶":16081,"##携":16082,"##搽":16083,"##摀":16084,"##摁":16085,"##摄":16086,"##摆":16087,"##摇":16088,"##摈":16089,"##摊":16090,"##摒":16091,"##摔":16092,"##摘":16093,"##摞":16094,"##摟":16095,"##摧":16096,"##摩":16097,"##摯":16098,"##摳":16099,"##摸":16100,"##摹":16101,"##摺":16102,"##摻":16103,"##撂":16104,"##撃":16105,"##撅":16106,"##撇":16107,"##撈":16108,"##撐":16109,"##撑":16110,"##撒":16111,"##撓":16112,"##撕":16113,"##撚":16114,"##撞":16115,"##撤":16116,"##撥":16117,"##撩":16118,"##撫":16119,"##撬":16120,"##播":16121,"##撮":16122,"##撰":16123,"##撲":16124,"##撵":16125,"##撷":16126,"##撸":16127,"##撻":16128,"##撼":16129,"##撿":16130,"##擀":16131,"##擁":16132,"##擂":16133,"##擄":16134,"##擅":16135,"##擇":16136,"##擊":16137,"##擋":16138,"##操":16139,"##擎":16140,"##擒":16141,"##擔":16142,"##擘":16143,"##據":16144,"##擞":16145,"##擠":16146,"##擡":16147,"##擢":16148,"##擦":16149,"##擬":16150,"##擰":16151,"##擱":16152,"##擲":16153,"##擴":16154,"##擷":16155,"##擺":16156,"##擼":16157,"##擾":16158,"##攀":16159,"##攏":16160,"##攒":16161,"##攔":16162,"##攘":16163,"##攙":16164,"##攜":16165,"##攝":16166,"##攞":16167,"##攢":16168,"##攣":16169,"##攤":16170,"##攥":16171,"##攪":16172,"##攫":16173,"##攬":16174,"##支":16175,"##收":16176,"##攸":16177,"##改":16178,"##攻":16179,"##放":16180,"##政":16181,"##故":16182,"##效":16183,"##敌":16184,"##敍":16185,"##敎":16186,"##敏":16187,"##救":16188,"##敕":16189,"##敖":16190,"##敗":16191,"##敘":16192,"##教":16193,"##敛":16194,"##敝":16195,"##敞":16196,"##敢":16197,"##散":16198,"##敦":16199,"##敬":16200,"##数":16201,"##敲":16202,"##整":16203,"##敵":16204,"##敷":16205,"##數":16206,"##斂":16207,"##斃":16208,"##文":16209,"##斋":16210,"##斌":16211,"##斎":16212,"##斐":16213,"##斑":16214,"##斓":16215,"##斗":16216,"##料":16217,"##斛":16218,"##斜":16219,"##斟":16220,"##斡":16221,"##斤":16222,"##斥":16223,"##斧":16224,"##斩":16225,"##斫":16226,"##斬":16227,"##断":16228,"##斯":16229,"##新":16230,"##斷":16231,"##方":16232,"##於":16233,"##施":16234,"##旁":16235,"##旃":16236,"##旅":16237,"##旋":16238,"##旌":16239,"##旎":16240,"##族":16241,"##旖":16242,"##旗":16243,"##无":16244,"##既":16245,"##日":16246,"##旦":16247,"##旧":16248,"##旨":16249,"##早":16250,"##旬":16251,"##旭":16252,"##旮":16253,"##旱":16254,"##时":16255,"##旷":16256,"##旺":16257,"##旻":16258,"##昀":16259,"##昂":16260,"##昆":16261,"##昇":16262,"##昉":16263,"##昊":16264,"##昌":16265,"##明":16266,"##昏":16267,"##易":16268,"##昔":16269,"##昕":16270,"##昙":16271,"##星":16272,"##映":16273,"##春":16274,"##昧":16275,"##昨":16276,"##昭":16277,"##是":16278,"##昱":16279,"##昴":16280,"##昵":16281,"##昶":16282,"##昼":16283,"##显":16284,"##晁":16285,"##時":16286,"##晃":16287,"##晉":16288,"##晋":16289,"##晌":16290,"##晏":16291,"##晒":16292,"##晓":16293,"##晔":16294,"##晕":16295,"##晖":16296,"##晗":16297,"##晚":16298,"##晝":16299,"##晞":16300,"##晟":16301,"##晤":16302,"##晦":16303,"##晨":16304,"##晩":16305,"##普":16306,"##景":16307,"##晰":16308,"##晴":16309,"##晶":16310,"##晷":16311,"##智":16312,"##晾":16313,"##暂":16314,"##暄":16315,"##暇":16316,"##暈":16317,"##暉":16318,"##暌":16319,"##暐":16320,"##暑":16321,"##暖":16322,"##暗":16323,"##暝":16324,"##暢":16325,"##暧":16326,"##暨":16327,"##暫":16328,"##暮":16329,"##暱":16330,"##暴":16331,"##暸":16332,"##暹":16333,"##曄":16334,"##曆":16335,"##曇":16336,"##曉":16337,"##曖":16338,"##曙":16339,"##曜":16340,"##曝":16341,"##曠":16342,"##曦":16343,"##曬":16344,"##曰":16345,"##曲":16346,"##曳":16347,"##更":16348,"##書":16349,"##曹":16350,"##曼":16351,"##曾":16352,"##替":16353,"##最":16354,"##會":16355,"##月":16356,"##有":16357,"##朋":16358,"##服":16359,"##朐":16360,"##朔":16361,"##朕":16362,"##朗":16363,"##望":16364,"##朝":16365,"##期":16366,"##朦":16367,"##朧":16368,"##木":16369,"##未":16370,"##末":16371,"##本":16372,"##札":16373,"##朮":16374,"##术":16375,"##朱":16376,"##朴":16377,"##朵":16378,"##机":16379,"##朽":16380,"##杀":16381,"##杂":16382,"##权":16383,"##杆":16384,"##杈":16385,"##杉":16386,"##李":16387,"##杏":16388,"##材":16389,"##村":16390,"##杓":16391,"##杖":16392,"##杜":16393,"##杞":16394,"##束":16395,"##杠":16396,"##条":16397,"##来":16398,"##杨":16399,"##杭":16400,"##杯":16401,"##杰":16402,"##東":16403,"##杳":16404,"##杵":16405,"##杷":16406,"##杼":16407,"##松":16408,"##板":16409,"##极":16410,"##构":16411,"##枇":16412,"##枉":16413,"##枋":16414,"##析":16415,"##枕":16416,"##林":16417,"##枚":16418,"##果":16419,"##枝":16420,"##枢":16421,"##枣":16422,"##枪":16423,"##枫":16424,"##枭":16425,"##枯":16426,"##枰":16427,"##枱":16428,"##枳":16429,"##架":16430,"##枷":16431,"##枸":16432,"##柄":16433,"##柏":16434,"##某":16435,"##柑":16436,"##柒":16437,"##染":16438,"##柔":16439,"##柘":16440,"##柚":16441,"##柜":16442,"##柞":16443,"##柠":16444,"##柢":16445,"##查":16446,"##柩":16447,"##柬":16448,"##柯":16449,"##柱":16450,"##柳":16451,"##柴":16452,"##柵":16453,"##査":16454,"##柿":16455,"##栀":16456,"##栃":16457,"##栄":16458,"##栅":16459,"##标":16460,"##栈":16461,"##栉":16462,"##栋":16463,"##栎":16464,"##栏":16465,"##树":16466,"##栓":16467,"##栖":16468,"##栗":16469,"##校":16470,"##栩":16471,"##株":16472,"##样":16473,"##核":16474,"##根":16475,"##格":16476,"##栽":16477,"##栾":16478,"##桀":16479,"##桁":16480,"##桂":16481,"##桃":16482,"##桅":16483,"##框":16484,"##案":16485,"##桉":16486,"##桌":16487,"##桎":16488,"##桐":16489,"##桑":16490,"##桓":16491,"##桔":16492,"##桜":16493,"##桠":16494,"##桡":16495,"##桢":16496,"##档":16497,"##桥":16498,"##桦":16499,"##桧":16500,"##桨":16501,"##桩":16502,"##桶":16503,"##桿":16504,"##梁":16505,"##梅":16506,"##梆":16507,"##梏":16508,"##梓":16509,"##梗":16510,"##條":16511,"##梟":16512,"##梢":16513,"##梦":16514,"##梧":16515,"##梨":16516,"##梭":16517,"##梯":16518,"##械":16519,"##梳":16520,"##梵":16521,"##梶":16522,"##检":16523,"##棂":16524,"##棄":16525,"##棉":16526,"##棋":16527,"##棍":16528,"##棒":16529,"##棕":16530,"##棗":16531,"##棘":16532,"##棚":16533,"##棟":16534,"##棠":16535,"##棣":16536,"##棧":16537,"##森":16538,"##棱":16539,"##棲":16540,"##棵":16541,"##棹":16542,"##棺":16543,"##椁":16544,"##椅":16545,"##椋":16546,"##植":16547,"##椎":16548,"##椒":16549,"##検":16550,"##椪":16551,"##椭":16552,"##椰":16553,"##椹":16554,"##椽":16555,"##椿":16556,"##楂":16557,"##楊":16558,"##楓":16559,"##楔":16560,"##楚":16561,"##楝":16562,"##楞":16563,"##楠":16564,"##楣":16565,"##楨":16566,"##楫":16567,"##業":16568,"##楮":16569,"##極":16570,"##楷":16571,"##楸":16572,"##楹":16573,"##楼":16574,"##楽":16575,"##概":16576,"##榄":16577,"##榆":16578,"##榈":16579,"##榉":16580,"##榔":16581,"##榕":16582,"##榖":16583,"##榛":16584,"##榜":16585,"##榨":16586,"##榫":16587,"##榭":16588,"##榮":16589,"##榱":16590,"##榴":16591,"##榷":16592,"##榻":16593,"##槁":16594,"##槃":16595,"##構":16596,"##槌":16597,"##槍":16598,"##槎":16599,"##槐":16600,"##槓":16601,"##様":16602,"##槛":16603,"##槟":16604,"##槤":16605,"##槭":16606,"##槲":16607,"##槳":16608,"##槻":16609,"##槽":16610,"##槿":16611,"##樁":16612,"##樂":16613,"##樊":16614,"##樑":16615,"##樓":16616,"##標":16617,"##樞":16618,"##樟":16619,"##模":16620,"##樣":16621,"##権":16622,"##横":16623,"##樫":16624,"##樯":16625,"##樱":16626,"##樵":16627,"##樸":16628,"##樹":16629,"##樺":16630,"##樽":16631,"##樾":16632,"##橄":16633,"##橇":16634,"##橋":16635,"##橐":16636,"##橘":16637,"##橙":16638,"##機":16639,"##橡":16640,"##橢":16641,"##橫":16642,"##橱":16643,"##橹":16644,"##橼":16645,"##檀":16646,"##檄":16647,"##檎":16648,"##檐":16649,"##檔":16650,"##檗":16651,"##檜":16652,"##檢":16653,"##檬":16654,"##檯":16655,"##檳":16656,"##檸":16657,"##檻":16658,"##櫃":16659,"##櫚":16660,"##櫛":16661,"##櫥":16662,"##櫸":16663,"##櫻":16664,"##欄":16665,"##權":16666,"##欒":16667,"##欖":16668,"##欠":16669,"##次":16670,"##欢":16671,"##欣":16672,"##欧":16673,"##欲":16674,"##欸":16675,"##欺":16676,"##欽":16677,"##款":16678,"##歆":16679,"##歇":16680,"##歉":16681,"##歌":16682,"##歎":16683,"##歐":16684,"##歓":16685,"##歙":16686,"##歛":16687,"##歡":16688,"##止":16689,"##正":16690,"##此":16691,"##步":16692,"##武":16693,"##歧":16694,"##歩":16695,"##歪":16696,"##歯":16697,"##歲":16698,"##歳":16699,"##歴":16700,"##歷":16701,"##歸":16702,"##歹":16703,"##死":16704,"##歼":16705,"##殁":16706,"##殃":16707,"##殆":16708,"##殇":16709,"##殉":16710,"##殊":16711,"##残":16712,"##殒":16713,"##殓":16714,"##殖":16715,"##殘":16716,"##殞":16717,"##殡":16718,"##殤":16719,"##殭":16720,"##殯":16721,"##殲":16722,"##殴":16723,"##段":16724,"##殷":16725,"##殺":16726,"##殼":16727,"##殿":16728,"##毀":16729,"##毁":16730,"##毂":16731,"##毅":16732,"##毆":16733,"##毋":16734,"##母":16735,"##毎":16736,"##每":16737,"##毒":16738,"##毓":16739,"##比":16740,"##毕":16741,"##毗":16742,"##毘":16743,"##毙":16744,"##毛":16745,"##毡":16746,"##毫":16747,"##毯":16748,"##毽":16749,"##氈":16750,"##氏":16751,"##氐":16752,"##民":16753,"##氓":16754,"##气":16755,"##氖":16756,"##気":16757,"##氙":16758,"##氛":16759,"##氟":16760,"##氡":16761,"##氢":16762,"##氣":16763,"##氤":16764,"##氦":16765,"##氧":16766,"##氨":16767,"##氪":16768,"##氫":16769,"##氮":16770,"##氯":16771,"##氰":16772,"##氲":16773,"##水":16774,"##氷":16775,"##永":16776,"##氹":16777,"##氾":16778,"##汀":16779,"##汁":16780,"##求":16781,"##汆":16782,"##汇":16783,"##汉":16784,"##汎":16785,"##汐":16786,"##汕":16787,"##汗":16788,"##汙":16789,"##汛":16790,"##汝":16791,"##汞":16792,"##江":16793,"##池":16794,"##污":16795,"##汤":16796,"##汨":16797,"##汩":16798,"##汪":16799,"##汰":16800,"##汲":16801,"##汴":16802,"##汶":16803,"##汹":16804,"##決":16805,"##汽":16806,"##汾":16807,"##沁":16808,"##沂":16809,"##沃":16810,"##沅":16811,"##沈":16812,"##沉":16813,"##沌":16814,"##沏":16815,"##沐":16816,"##沒":16817,"##沓":16818,"##沖":16819,"##沙":16820,"##沛":16821,"##沟":16822,"##没":16823,"##沢":16824,"##沣":16825,"##沥":16826,"##沦":16827,"##沧":16828,"##沪":16829,"##沫":16830,"##沭":16831,"##沮":16832,"##沱":16833,"##河":16834,"##沸":16835,"##油":16836,"##治":16837,"##沼":16838,"##沽":16839,"##沾":16840,"##沿":16841,"##況":16842,"##泄":16843,"##泉":16844,"##泊":16845,"##泌":16846,"##泓":16847,"##法":16848,"##泗":16849,"##泛":16850,"##泞":16851,"##泠":16852,"##泡":16853,"##波":16854,"##泣":16855,"##泥":16856,"##注":16857,"##泪":16858,"##泫":16859,"##泮":16860,"##泯":16861,"##泰":16862,"##泱":16863,"##泳":16864,"##泵":16865,"##泷":16866,"##泸":16867,"##泻":16868,"##泼":16869,"##泽":16870,"##泾":16871,"##洁":16872,"##洄":16873,"##洋":16874,"##洒":16875,"##洗":16876,"##洙":16877,"##洛":16878,"##洞":16879,"##津":16880,"##洩":16881,"##洪":16882,"##洮":16883,"##洱":16884,"##洲":16885,"##洵":16886,"##洶":16887,"##洸":16888,"##洹":16889,"##活":16890,"##洼":16891,"##洽":16892,"##派":16893,"##流":16894,"##浃":16895,"##浄":16896,"##浅":16897,"##浆":16898,"##浇":16899,"##浊":16900,"##测":16901,"##济":16902,"##浏":16903,"##浑":16904,"##浒":16905,"##浓":16906,"##浔":16907,"##浙":16908,"##浚":16909,"##浜":16910,"##浣":16911,"##浦":16912,"##浩":16913,"##浪":16914,"##浬":16915,"##浮":16916,"##浯":16917,"##浴":16918,"##海":16919,"##浸":16920,"##涂":16921,"##涅":16922,"##涇":16923,"##消":16924,"##涉":16925,"##涌":16926,"##涎":16927,"##涓":16928,"##涔":16929,"##涕":16930,"##涙":16931,"##涛":16932,"##涝":16933,"##涞":16934,"##涟":16935,"##涠":16936,"##涡":16937,"##涣":16938,"##涤":16939,"##润":16940,"##涧":16941,"##涨":16942,"##涩":16943,"##涪":16944,"##涮":16945,"##涯":16946,"##液":16947,"##涵":16948,"##涸":16949,"##涼":16950,"##涿":16951,"##淀":16952,"##淄":16953,"##淅":16954,"##淆":16955,"##淇":16956,"##淋":16957,"##淌":16958,"##淑":16959,"##淒":16960,"##淖":16961,"##淘":16962,"##淙":16963,"##淚":16964,"##淞":16965,"##淡":16966,"##淤":16967,"##淦":16968,"##淨":16969,"##淩":16970,"##淪":16971,"##淫":16972,"##淬":16973,"##淮":16974,"##深":16975,"##淳":16976,"##淵":16977,"##混":16978,"##淹":16979,"##淺":16980,"##添":16981,"##淼":16982,"##清":16983,"##済":16984,"##渉":16985,"##渊":16986,"##渋":16987,"##渍":16988,"##渎":16989,"##渐":16990,"##渔":16991,"##渗":16992,"##渙":16993,"##渚":16994,"##減":16995,"##渝":16996,"##渠":16997,"##渡":16998,"##渣":16999,"##渤":17000,"##渥":17001,"##渦":17002,"##温":17003,"##測":17004,"##渭":17005,"##港":17006,"##渲":17007,"##渴":17008,"##游":17009,"##渺":17010,"##渾":17011,"##湃":17012,"##湄":17013,"##湊":17014,"##湍":17015,"##湖":17016,"##湘":17017,"##湛":17018,"##湟":17019,"##湧":17020,"##湫":17021,"##湮":17022,"##湯":17023,"##湳":17024,"##湾":17025,"##湿":17026,"##満":17027,"##溃":17028,"##溅":17029,"##溉":17030,"##溏":17031,"##源":17032,"##準":17033,"##溜":17034,"##溝":17035,"##溟":17036,"##溢":17037,"##溥":17038,"##溧":17039,"##溪":17040,"##溫":17041,"##溯":17042,"##溱":17043,"##溴":17044,"##溶":17045,"##溺":17046,"##溼":17047,"##滁":17048,"##滂":17049,"##滄":17050,"##滅":17051,"##滇":17052,"##滋":17053,"##滌":17054,"##滑":17055,"##滓":17056,"##滔":17057,"##滕":17058,"##滙":17059,"##滚":17060,"##滝":17061,"##滞":17062,"##滟":17063,"##满":17064,"##滢":17065,"##滤":17066,"##滥":17067,"##滦":17068,"##滨":17069,"##滩":17070,"##滬":17071,"##滯":17072,"##滲":17073,"##滴":17074,"##滷":17075,"##滸":17076,"##滾":17077,"##滿":17078,"##漁":17079,"##漂":17080,"##漆":17081,"##漉":17082,"##漏":17083,"##漓":17084,"##演":17085,"##漕":17086,"##漠":17087,"##漢":17088,"##漣":17089,"##漩":17090,"##漪":17091,"##漫":17092,"##漬":17093,"##漯":17094,"##漱":17095,"##漲":17096,"##漳":17097,"##漸":17098,"##漾":17099,"##漿":17100,"##潆":17101,"##潇":17102,"##潋":17103,"##潍":17104,"##潑":17105,"##潔":17106,"##潘":17107,"##潛":17108,"##潜":17109,"##潞":17110,"##潟":17111,"##潢":17112,"##潤":17113,"##潦":17114,"##潧":17115,"##潭":17116,"##潮":17117,"##潰":17118,"##潴":17119,"##潸":17120,"##潺":17121,"##潼":17122,"##澀":17123,"##澄":17124,"##澆":17125,"##澈":17126,"##澍":17127,"##澎":17128,"##澗":17129,"##澜":17130,"##澡":17131,"##澤":17132,"##澧":17133,"##澱":17134,"##澳":17135,"##澹":17136,"##激":17137,"##濁":17138,"##濂":17139,"##濃":17140,"##濑":17141,"##濒":17142,"##濕":17143,"##濘":17144,"##濛":17145,"##濟":17146,"##濠":17147,"##濡":17148,"##濤":17149,"##濫":17150,"##濬":17151,"##濮":17152,"##濯":17153,"##濱":17154,"##濺":17155,"##濾":17156,"##瀅":17157,"##瀆":17158,"##瀉":17159,"##瀋":17160,"##瀏":17161,"##瀑":17162,"##瀕":17163,"##瀘":17164,"##瀚":17165,"##瀛":17166,"##瀝":17167,"##瀞":17168,"##瀟":17169,"##瀧":17170,"##瀨":17171,"##瀬":17172,"##瀰":17173,"##瀾":17174,"##灌":17175,"##灏":17176,"##灑":17177,"##灘":17178,"##灝":17179,"##灞":17180,"##灣":17181,"##火":17182,"##灬":17183,"##灭":17184,"##灯":17185,"##灰":17186,"##灵":17187,"##灶":17188,"##灸":17189,"##灼":17190,"##災":17191,"##灾":17192,"##灿":17193,"##炀":17194,"##炁":17195,"##炅":17196,"##炉":17197,"##炊":17198,"##炎":17199,"##炒":17200,"##炔":17201,"##炕":17202,"##炖":17203,"##炙":17204,"##炜":17205,"##炫":17206,"##炬":17207,"##炭":17208,"##炮":17209,"##炯":17210,"##炳":17211,"##炷":17212,"##炸":17213,"##点":17214,"##為":17215,"##炼":17216,"##炽":17217,"##烁":17218,"##烂":17219,"##烃":17220,"##烈":17221,"##烊":17222,"##烏":17223,"##烘":17224,"##烙":17225,"##烛":17226,"##烟":17227,"##烤":17228,"##烦":17229,"##烧":17230,"##烨":17231,"##烩":17232,"##烫":17233,"##烬":17234,"##热":17235,"##烯":17236,"##烷":17237,"##烹":17238,"##烽":17239,"##焉":17240,"##焊":17241,"##焕":17242,"##焖":17243,"##焗":17244,"##焘":17245,"##焙":17246,"##焚":17247,"##焜":17248,"##無":17249,"##焦":17250,"##焯":17251,"##焰":17252,"##焱":17253,"##然":17254,"##焼":17255,"##煅":17256,"##煉":17257,"##煊":17258,"##煌":17259,"##煎":17260,"##煒":17261,"##煖":17262,"##煙":17263,"##煜":17264,"##煞":17265,"##煤":17266,"##煥":17267,"##煦":17268,"##照":17269,"##煨":17270,"##煩":17271,"##煮":17272,"##煲":17273,"##煸":17274,"##煽":17275,"##熄":17276,"##熊":17277,"##熏":17278,"##熒":17279,"##熔":17280,"##熙":17281,"##熟":17282,"##熠":17283,"##熨":17284,"##熬":17285,"##熱":17286,"##熵":17287,"##熹":17288,"##熾":17289,"##燁":17290,"##燃":17291,"##燄":17292,"##燈":17293,"##燉":17294,"##燊":17295,"##燎":17296,"##燒":17297,"##燔":17298,"##燕":17299,"##燙":17300,"##燜":17301,"##營":17302,"##燥":17303,"##燦":17304,"##燧":17305,"##燭":17306,"##燮":17307,"##燴":17308,"##燻":17309,"##燼":17310,"##燿":17311,"##爆":17312,"##爍":17313,"##爐":17314,"##爛":17315,"##爪":17316,"##爬":17317,"##爭":17318,"##爰":17319,"##爱":17320,"##爲":17321,"##爵":17322,"##父":17323,"##爷":17324,"##爸":17325,"##爹":17326,"##爺":17327,"##爻":17328,"##爽":17329,"##爾":17330,"##牆":17331,"##片":17332,"##版":17333,"##牌":17334,"##牍":17335,"##牒":17336,"##牙":17337,"##牛":17338,"##牝":17339,"##牟":17340,"##牠":17341,"##牡":17342,"##牢":17343,"##牦":17344,"##牧":17345,"##物":17346,"##牯":17347,"##牲":17348,"##牴":17349,"##牵":17350,"##特":17351,"##牺":17352,"##牽":17353,"##犀":17354,"##犁":17355,"##犄":17356,"##犊":17357,"##犍":17358,"##犒":17359,"##犢":17360,"##犧":17361,"##犬":17362,"##犯":17363,"##状":17364,"##犷":17365,"##犸":17366,"##犹":17367,"##狀":17368,"##狂":17369,"##狄":17370,"##狈":17371,"##狎":17372,"##狐":17373,"##狒":17374,"##狗":17375,"##狙":17376,"##狞":17377,"##狠":17378,"##狡":17379,"##狩":17380,"##独":17381,"##狭":17382,"##狮":17383,"##狰":17384,"##狱":17385,"##狸":17386,"##狹":17387,"##狼":17388,"##狽":17389,"##猎":17390,"##猕":17391,"##猖":17392,"##猗":17393,"##猙":17394,"##猛":17395,"##猜":17396,"##猝":17397,"##猥":17398,"##猩":17399,"##猪":17400,"##猫":17401,"##猬":17402,"##献":17403,"##猴":17404,"##猶":17405,"##猷":17406,"##猾":17407,"##猿":17408,"##獄":17409,"##獅":17410,"##獎":17411,"##獐":17412,"##獒":17413,"##獗":17414,"##獠":17415,"##獣":17416,"##獨":17417,"##獭":17418,"##獰":17419,"##獲":17420,"##獵":17421,"##獷":17422,"##獸":17423,"##獺":17424,"##獻":17425,"##獼":17426,"##獾":17427,"##玄":17428,"##率":17429,"##玉":17430,"##王":17431,"##玑":17432,"##玖":17433,"##玛":17434,"##玟":17435,"##玠":17436,"##玥":17437,"##玩":17438,"##玫":17439,"##玮":17440,"##环":17441,"##现":17442,"##玲":17443,"##玳":17444,"##玷":17445,"##玺":17446,"##玻":17447,"##珀":17448,"##珂":17449,"##珅":17450,"##珈":17451,"##珉":17452,"##珊":17453,"##珍":17454,"##珏":17455,"##珐":17456,"##珑":17457,"##珙":17458,"##珞":17459,"##珠":17460,"##珣":17461,"##珥":17462,"##珩":17463,"##珪":17464,"##班":17465,"##珮":17466,"##珲":17467,"##珺":17468,"##現":17469,"##球":17470,"##琅":17471,"##理":17472,"##琇":17473,"##琉":17474,"##琊":17475,"##琍":17476,"##琏":17477,"##琐":17478,"##琛":17479,"##琢":17480,"##琥":17481,"##琦":17482,"##琨":17483,"##琪":17484,"##琬":17485,"##琮":17486,"##琰":17487,"##琲":17488,"##琳":17489,"##琴":17490,"##琵":17491,"##琶":17492,"##琺":17493,"##琼":17494,"##瑀":17495,"##瑁":17496,"##瑄":17497,"##瑋":17498,"##瑕":17499,"##瑗":17500,"##瑙":17501,"##瑚":17502,"##瑛":17503,"##瑜":17504,"##瑞":17505,"##瑟":17506,"##瑠":17507,"##瑣":17508,"##瑤":17509,"##瑩":17510,"##瑪":17511,"##瑯":17512,"##瑰":17513,"##瑶":17514,"##瑾":17515,"##璀":17516,"##璁":17517,"##璃":17518,"##璇":17519,"##璉":17520,"##璋":17521,"##璎":17522,"##璐":17523,"##璜":17524,"##璞":17525,"##璟":17526,"##璧":17527,"##璨":17528,"##環":17529,"##璽":17530,"##璿":17531,"##瓊":17532,"##瓏":17533,"##瓒":17534,"##瓜":17535,"##瓢":17536,"##瓣":17537,"##瓤":17538,"##瓦":17539,"##瓮":17540,"##瓯":17541,"##瓴":17542,"##瓶":17543,"##瓷":17544,"##甄":17545,"##甌":17546,"##甕":17547,"##甘":17548,"##甙":17549,"##甚":17550,"##甜":17551,"##生":17552,"##產":17553,"##産":17554,"##甥":17555,"##甦":17556,"##用":17557,"##甩":17558,"##甫":17559,"##甬":17560,"##甭":17561,"##甯":17562,"##田":17563,"##由":17564,"##甲":17565,"##申":17566,"##电":17567,"##男":17568,"##甸":17569,"##町":17570,"##画":17571,"##甾":17572,"##畀":17573,"##畅":17574,"##界":17575,"##畏":17576,"##畑":17577,"##畔":17578,"##留":17579,"##畜":17580,"##畝":17581,"##畢":17582,"##略":17583,"##畦":17584,"##番":17585,"##畫":17586,"##異":17587,"##畲":17588,"##畳":17589,"##畴":17590,"##當":17591,"##畸":17592,"##畹":17593,"##畿":17594,"##疆":17595,"##疇":17596,"##疊":17597,"##疏":17598,"##疑":17599,"##疔":17600,"##疖":17601,"##疗":17602,"##疙":17603,"##疚":17604,"##疝":17605,"##疟":17606,"##疡":17607,"##疣":17608,"##疤":17609,"##疥":17610,"##疫":17611,"##疮":17612,"##疯":17613,"##疱":17614,"##疲":17615,"##疳":17616,"##疵":17617,"##疸":17618,"##疹":17619,"##疼":17620,"##疽":17621,"##疾":17622,"##痂":17623,"##病":17624,"##症":17625,"##痈":17626,"##痉":17627,"##痊":17628,"##痍":17629,"##痒":17630,"##痔":17631,"##痕":17632,"##痘":17633,"##痙":17634,"##痛":17635,"##痞":17636,"##痠":17637,"##痢":17638,"##痣":17639,"##痤":17640,"##痧":17641,"##痨":17642,"##痪":17643,"##痫":17644,"##痰":17645,"##痱":17646,"##痴":17647,"##痹":17648,"##痺":17649,"##痼":17650,"##痿":17651,"##瘀":17652,"##瘁":17653,"##瘋":17654,"##瘍":17655,"##瘓":17656,"##瘘":17657,"##瘙":17658,"##瘟":17659,"##瘠":17660,"##瘡":17661,"##瘢":17662,"##瘤":17663,"##瘦":17664,"##瘧":17665,"##瘩":17666,"##瘪":17667,"##瘫":17668,"##瘴":17669,"##瘸":17670,"##瘾":17671,"##療":17672,"##癇":17673,"##癌":17674,"##癒":17675,"##癖":17676,"##癜":17677,"##癞":17678,"##癡":17679,"##癢":17680,"##癣":17681,"##癥":17682,"##癫":17683,"##癬":17684,"##癮":17685,"##癱":17686,"##癲":17687,"##癸":17688,"##発":17689,"##登":17690,"##發":17691,"##白":17692,"##百":17693,"##皂":17694,"##的":17695,"##皆":17696,"##皇":17697,"##皈":17698,"##皋":17699,"##皎":17700,"##皑":17701,"##皓":17702,"##皖":17703,"##皙":17704,"##皚":17705,"##皮":17706,"##皰":17707,"##皱":17708,"##皴":17709,"##皺":17710,"##皿":17711,"##盂":17712,"##盃":17713,"##盅":17714,"##盆":17715,"##盈":17716,"##益":17717,"##盎":17718,"##盏":17719,"##盐":17720,"##监":17721,"##盒":17722,"##盔":17723,"##盖":17724,"##盗":17725,"##盘":17726,"##盛":17727,"##盜":17728,"##盞":17729,"##盟":17730,"##盡":17731,"##監":17732,"##盤":17733,"##盥":17734,"##盧":17735,"##盪":17736,"##目":17737,"##盯":17738,"##盱":17739,"##盲":17740,"##直":17741,"##相":17742,"##盹":17743,"##盼":17744,"##盾":17745,"##省":17746,"##眈":17747,"##眉":17748,"##看":17749,"##県":17750,"##眙":17751,"##眞":17752,"##真":17753,"##眠":17754,"##眦":17755,"##眨":17756,"##眩":17757,"##眯":17758,"##眶":17759,"##眷":17760,"##眸":17761,"##眺":17762,"##眼":17763,"##眾":17764,"##着":17765,"##睁":17766,"##睇":17767,"##睏":17768,"##睐":17769,"##睑":17770,"##睛":17771,"##睜":17772,"##睞":17773,"##睡":17774,"##睢":17775,"##督":17776,"##睥":17777,"##睦":17778,"##睨":17779,"##睪":17780,"##睫":17781,"##睬":17782,"##睹":17783,"##睽":17784,"##睾":17785,"##睿":17786,"##瞄":17787,"##瞅":17788,"##瞇":17789,"##瞋":17790,"##瞌":17791,"##瞎":17792,"##瞑":17793,"##瞒":17794,"##瞓":17795,"##瞞":17796,"##瞟":17797,"##瞠":17798,"##瞥":17799,"##瞧":17800,"##瞩":17801,"##瞪":17802,"##瞬":17803,"##瞭":17804,"##瞰":17805,"##瞳":17806,"##瞻":17807,"##瞼":17808,"##瞿":17809,"##矇":17810,"##矍":17811,"##矗":17812,"##矚":17813,"##矛":17814,"##矜":17815,"##矢":17816,"##矣":17817,"##知":17818,"##矩":17819,"##矫":17820,"##短":17821,"##矮":17822,"##矯":17823,"##石":17824,"##矶":17825,"##矽":17826,"##矾":17827,"##矿":17828,"##码":17829,"##砂":17830,"##砌":17831,"##砍":17832,"##砒":17833,"##研":17834,"##砖":17835,"##砗":17836,"##砚":17837,"##砝":17838,"##砣":17839,"##砥":17840,"##砧":17841,"##砭":17842,"##砰":17843,"##砲":17844,"##破":17845,"##砷":17846,"##砸":17847,"##砺":17848,"##砼":17849,"##砾":17850,"##础":17851,"##硅":17852,"##硐":17853,"##硒":17854,"##硕":17855,"##硝":17856,"##硫":17857,"##硬":17858,"##确":17859,"##硯":17860,"##硼":17861,"##碁":17862,"##碇":17863,"##碉":17864,"##碌":17865,"##碍":17866,"##碎":17867,"##碑":17868,"##碓":17869,"##碗":17870,"##碘":17871,"##碚":17872,"##碛":17873,"##碟":17874,"##碣":17875,"##碧":17876,"##碩":17877,"##碰":17878,"##碱":17879,"##碳":17880,"##碴":17881,"##確":17882,"##碼":17883,"##碾":17884,"##磁":17885,"##磅":17886,"##磊":17887,"##磋":17888,"##磐":17889,"##磕":17890,"##磚":17891,"##磡":17892,"##磨":17893,"##磬":17894,"##磯":17895,"##磲":17896,"##磷":17897,"##磺":17898,"##礁":17899,"##礎":17900,"##礙":17901,"##礡":17902,"##礦":17903,"##礪":17904,"##礫":17905,"##礴":17906,"##示":17907,"##礼":17908,"##社":17909,"##祀":17910,"##祁":17911,"##祂":17912,"##祇":17913,"##祈":17914,"##祉":17915,"##祎":17916,"##祐":17917,"##祕":17918,"##祖":17919,"##祗":17920,"##祚":17921,"##祛":17922,"##祜":17923,"##祝":17924,"##神":17925,"##祟":17926,"##祠":17927,"##祢":17928,"##祥":17929,"##票":17930,"##祭":17931,"##祯":17932,"##祷":17933,"##祸":17934,"##祺":17935,"##祿":17936,"##禀":17937,"##禁":17938,"##禄":17939,"##禅":17940,"##禍":17941,"##禎":17942,"##福":17943,"##禛":17944,"##禦":17945,"##禧":17946,"##禪":17947,"##禮":17948,"##禱":17949,"##禹":17950,"##禺":17951,"##离":17952,"##禽":17953,"##禾":17954,"##禿":17955,"##秀":17956,"##私":17957,"##秃":17958,"##秆":17959,"##秉":17960,"##秋":17961,"##种":17962,"##科":17963,"##秒":17964,"##秘":17965,"##租":17966,"##秣":17967,"##秤":17968,"##秦":17969,"##秧":17970,"##秩":17971,"##秭":17972,"##积":17973,"##称":17974,"##秸":17975,"##移":17976,"##秽":17977,"##稀":17978,"##稅":17979,"##程":17980,"##稍":17981,"##税":17982,"##稔":17983,"##稗":17984,"##稚":17985,"##稜":17986,"##稞":17987,"##稟":17988,"##稠":17989,"##稣":17990,"##種":17991,"##稱":17992,"##稲":17993,"##稳":17994,"##稷":17995,"##稹":17996,"##稻":17997,"##稼":17998,"##稽":17999,"##稿":18000,"##穀":18001,"##穂":18002,"##穆":18003,"##穌":18004,"##積":18005,"##穎":18006,"##穗":18007,"##穢":18008,"##穩":18009,"##穫":18010,"##穴":18011,"##究":18012,"##穷":18013,"##穹":18014,"##空":18015,"##穿":18016,"##突":18017,"##窃":18018,"##窄":18019,"##窈":18020,"##窍":18021,"##窑":18022,"##窒":18023,"##窓":18024,"##窕":18025,"##窖":18026,"##窗":18027,"##窘":18028,"##窜":18029,"##窝":18030,"##窟":18031,"##窠":18032,"##窥":18033,"##窦":18034,"##窨":18035,"##窩":18036,"##窪":18037,"##窮":18038,"##窯":18039,"##窺":18040,"##窿":18041,"##竄":18042,"##竅":18043,"##竇":18044,"##竊":18045,"##立":18046,"##竖":18047,"##站":18048,"##竜":18049,"##竞":18050,"##竟":18051,"##章":18052,"##竣":18053,"##童":18054,"##竭":18055,"##端":18056,"##競":18057,"##竹":18058,"##竺":18059,"##竽":18060,"##竿":18061,"##笃":18062,"##笆":18063,"##笈":18064,"##笋":18065,"##笏":18066,"##笑":18067,"##笔":18068,"##笙":18069,"##笛":18070,"##笞":18071,"##笠":18072,"##符":18073,"##笨":18074,"##第":18075,"##笹":18076,"##笺":18077,"##笼":18078,"##筆":18079,"##等":18080,"##筊":18081,"##筋":18082,"##筍":18083,"##筏":18084,"##筐":18085,"##筑":18086,"##筒":18087,"##答":18088,"##策":18089,"##筛":18090,"##筝":18091,"##筠":18092,"##筱":18093,"##筲":18094,"##筵":18095,"##筷":18096,"##筹":18097,"##签":18098,"##简":18099,"##箇":18100,"##箋":18101,"##箍":18102,"##箏":18103,"##箐":18104,"##箔":18105,"##箕":18106,"##算":18107,"##箝":18108,"##管":18109,"##箩":18110,"##箫":18111,"##箭":18112,"##箱":18113,"##箴":18114,"##箸":18115,"##節":18116,"##篁":18117,"##範":18118,"##篆":18119,"##篇":18120,"##築":18121,"##篑":18122,"##篓":18123,"##篙":18124,"##篝":18125,"##篠":18126,"##篡":18127,"##篤":18128,"##篩":18129,"##篪":18130,"##篮":18131,"##篱":18132,"##篷":18133,"##簇":18134,"##簌":18135,"##簍":18136,"##簡":18137,"##簦":18138,"##簧":18139,"##簪":18140,"##簫":18141,"##簷":18142,"##簸":18143,"##簽":18144,"##簾":18145,"##簿":18146,"##籁":18147,"##籃":18148,"##籌":18149,"##籍":18150,"##籐":18151,"##籟":18152,"##籠":18153,"##籤":18154,"##籬":18155,"##籮":18156,"##籲":18157,"##米":18158,"##类":18159,"##籼":18160,"##籽":18161,"##粄":18162,"##粉":18163,"##粑":18164,"##粒":18165,"##粕":18166,"##粗":18167,"##粘":18168,"##粟":18169,"##粤":18170,"##粥":18171,"##粧":18172,"##粪":18173,"##粮":18174,"##粱":18175,"##粲":18176,"##粳":18177,"##粵":18178,"##粹":18179,"##粼":18180,"##粽":18181,"##精":18182,"##粿":18183,"##糅":18184,"##糊":18185,"##糍":18186,"##糕":18187,"##糖":18188,"##糗":18189,"##糙":18190,"##糜":18191,"##糞":18192,"##糟":18193,"##糠":18194,"##糧":18195,"##糬":18196,"##糯":18197,"##糰":18198,"##糸":18199,"##系":18200,"##糾":18201,"##紀":18202,"##紂":18203,"##約":18204,"##紅":18205,"##紉":18206,"##紊":18207,"##紋":18208,"##納":18209,"##紐":18210,"##紓":18211,"##純":18212,"##紗":18213,"##紘":18214,"##紙":18215,"##級":18216,"##紛":18217,"##紜":18218,"##素":18219,"##紡":18220,"##索":18221,"##紧":18222,"##紫":18223,"##紮":18224,"##累":18225,"##細":18226,"##紳":18227,"##紹":18228,"##紺":18229,"##終":18230,"##絃":18231,"##組":18232,"##絆":18233,"##経":18234,"##結":18235,"##絕":18236,"##絞":18237,"##絡":18238,"##絢":18239,"##給":18240,"##絨":18241,"##絮":18242,"##統":18243,"##絲":18244,"##絳":18245,"##絵":18246,"##絶":18247,"##絹":18248,"##綁":18249,"##綏":18250,"##綑":18251,"##經":18252,"##継":18253,"##続":18254,"##綜":18255,"##綠":18256,"##綢":18257,"##綦":18258,"##綫":18259,"##綬":18260,"##維":18261,"##綱":18262,"##網":18263,"##綴":18264,"##綵":18265,"##綸":18266,"##綺":18267,"##綻":18268,"##綽":18269,"##綾":18270,"##綿":18271,"##緊":18272,"##緋":18273,"##総":18274,"##緑":18275,"##緒":18276,"##緘":18277,"##線":18278,"##緝":18279,"##緞":18280,"##締":18281,"##緣":18282,"##編":18283,"##緩":18284,"##緬":18285,"##緯":18286,"##練":18287,"##緹":18288,"##緻":18289,"##縁":18290,"##縄":18291,"##縈":18292,"##縛":18293,"##縝":18294,"##縣":18295,"##縫":18296,"##縮":18297,"##縱":18298,"##縴":18299,"##縷":18300,"##總":18301,"##績":18302,"##繁":18303,"##繃":18304,"##繆":18305,"##繇":18306,"##繋":18307,"##織":18308,"##繕":18309,"##繚":18310,"##繞":18311,"##繡":18312,"##繩":18313,"##繪":18314,"##繫":18315,"##繭":18316,"##繳":18317,"##繹":18318,"##繼":18319,"##繽":18320,"##纂":18321,"##續":18322,"##纍":18323,"##纏":18324,"##纓":18325,"##纔":18326,"##纖":18327,"##纜":18328,"##纠":18329,"##红":18330,"##纣":18331,"##纤":18332,"##约":18333,"##级":18334,"##纨":18335,"##纪":18336,"##纫":18337,"##纬":18338,"##纭":18339,"##纯":18340,"##纰":18341,"##纱":18342,"##纲":18343,"##纳":18344,"##纵":18345,"##纶":18346,"##纷":18347,"##纸":18348,"##纹":18349,"##纺":18350,"##纽":18351,"##纾":18352,"##线":18353,"##绀":18354,"##练":18355,"##组":18356,"##绅":18357,"##细":18358,"##织":18359,"##终":18360,"##绊":18361,"##绍":18362,"##绎":18363,"##经":18364,"##绑":18365,"##绒":18366,"##结":18367,"##绔":18368,"##绕":18369,"##绘":18370,"##给":18371,"##绚":18372,"##绛":18373,"##络":18374,"##绝":18375,"##绞":18376,"##统":18377,"##绡":18378,"##绢":18379,"##绣":18380,"##绥":18381,"##绦":18382,"##继":18383,"##绩":18384,"##绪":18385,"##绫":18386,"##续":18387,"##绮":18388,"##绯":18389,"##绰":18390,"##绳":18391,"##维":18392,"##绵":18393,"##绶":18394,"##绷":18395,"##绸":18396,"##绻":18397,"##综":18398,"##绽":18399,"##绾":18400,"##绿":18401,"##缀":18402,"##缄":18403,"##缅":18404,"##缆":18405,"##缇":18406,"##缈":18407,"##缉":18408,"##缎":18409,"##缓":18410,"##缔":18411,"##缕":18412,"##编":18413,"##缘":18414,"##缙":18415,"##缚":18416,"##缜":18417,"##缝":18418,"##缠":18419,"##缢":18420,"##缤":18421,"##缥":18422,"##缨":18423,"##缩":18424,"##缪":18425,"##缭":18426,"##缮":18427,"##缰":18428,"##缱":18429,"##缴":18430,"##缸":18431,"##缺":18432,"##缽":18433,"##罂":18434,"##罄":18435,"##罌":18436,"##罐":18437,"##网":18438,"##罔":18439,"##罕":18440,"##罗":18441,"##罚":18442,"##罡":18443,"##罢":18444,"##罩":18445,"##罪":18446,"##置":18447,"##罰":18448,"##署":18449,"##罵":18450,"##罷":18451,"##罹":18452,"##羁":18453,"##羅":18454,"##羈":18455,"##羊":18456,"##羌":18457,"##美":18458,"##羔":18459,"##羚":18460,"##羞":18461,"##羟":18462,"##羡":18463,"##羣":18464,"##群":18465,"##羥":18466,"##羧":18467,"##羨":18468,"##義":18469,"##羯":18470,"##羲":18471,"##羸":18472,"##羹":18473,"##羽":18474,"##羿":18475,"##翁":18476,"##翅":18477,"##翊":18478,"##翌":18479,"##翎":18480,"##習":18481,"##翔":18482,"##翘":18483,"##翟":18484,"##翠":18485,"##翡":18486,"##翦":18487,"##翩":18488,"##翰":18489,"##翱":18490,"##翳":18491,"##翹":18492,"##翻":18493,"##翼":18494,"##耀":18495,"##老":18496,"##考":18497,"##耄":18498,"##者":18499,"##耆":18500,"##耋":18501,"##而":18502,"##耍":18503,"##耐":18504,"##耒":18505,"##耕":18506,"##耗":18507,"##耘":18508,"##耙":18509,"##耦":18510,"##耨":18511,"##耳":18512,"##耶":18513,"##耷":18514,"##耸":18515,"##耻":18516,"##耽":18517,"##耿":18518,"##聂":18519,"##聆":18520,"##聊":18521,"##聋":18522,"##职":18523,"##聒":18524,"##联":18525,"##聖":18526,"##聘":18527,"##聚":18528,"##聞":18529,"##聪":18530,"##聯":18531,"##聰":18532,"##聲":18533,"##聳":18534,"##聴":18535,"##聶":18536,"##職":18537,"##聽":18538,"##聾":18539,"##聿":18540,"##肃":18541,"##肄":18542,"##肅":18543,"##肆":18544,"##肇":18545,"##肉":18546,"##肋":18547,"##肌":18548,"##肏":18549,"##肓":18550,"##肖":18551,"##肘":18552,"##肚":18553,"##肛":18554,"##肝":18555,"##肠":18556,"##股":18557,"##肢":18558,"##肤":18559,"##肥":18560,"##肩":18561,"##肪":18562,"##肮":18563,"##肯":18564,"##肱":18565,"##育":18566,"##肴":18567,"##肺":18568,"##肽":18569,"##肾":18570,"##肿":18571,"##胀":18572,"##胁":18573,"##胃":18574,"##胄":18575,"##胆":18576,"##背":18577,"##胍":18578,"##胎":18579,"##胖":18580,"##胚":18581,"##胛":18582,"##胜":18583,"##胝":18584,"##胞":18585,"##胡":18586,"##胤":18587,"##胥":18588,"##胧":18589,"##胫":18590,"##胭":18591,"##胯":18592,"##胰":18593,"##胱":18594,"##胳":18595,"##胴":18596,"##胶":18597,"##胸":18598,"##胺":18599,"##能":18600,"##脂":18601,"##脅":18602,"##脆":18603,"##脇":18604,"##脈":18605,"##脉":18606,"##脊":18607,"##脍":18608,"##脏":18609,"##脐":18610,"##脑":18611,"##脓":18612,"##脖":18613,"##脘":18614,"##脚":18615,"##脛":18616,"##脣":18617,"##脩":18618,"##脫":18619,"##脯":18620,"##脱":18621,"##脲":18622,"##脳":18623,"##脸":18624,"##脹":18625,"##脾":18626,"##腆":18627,"##腈":18628,"##腊":18629,"##腋":18630,"##腌":18631,"##腎":18632,"##腐":18633,"##腑":18634,"##腓":18635,"##腔":18636,"##腕":18637,"##腥":18638,"##腦":18639,"##腩":18640,"##腫":18641,"##腭":18642,"##腮":18643,"##腰":18644,"##腱":18645,"##腳":18646,"##腴":18647,"##腸":18648,"##腹":18649,"##腺":18650,"##腻":18651,"##腼":18652,"##腾":18653,"##腿":18654,"##膀":18655,"##膈":18656,"##膊":18657,"##膏":18658,"##膑":18659,"##膘":18660,"##膚":18661,"##膛":18662,"##膜":18663,"##膝":18664,"##膠":18665,"##膦":18666,"##膨":18667,"##膩":18668,"##膳":18669,"##膺":18670,"##膻":18671,"##膽":18672,"##膾":18673,"##膿":18674,"##臀":18675,"##臂":18676,"##臃":18677,"##臆":18678,"##臉":18679,"##臊":18680,"##臍":18681,"##臓":18682,"##臘":18683,"##臟":18684,"##臣":18685,"##臥":18686,"##臧":18687,"##臨":18688,"##自":18689,"##臬":18690,"##臭":18691,"##至":18692,"##致":18693,"##臺":18694,"##臻":18695,"##臼":18696,"##臾":18697,"##舀":18698,"##舂":18699,"##舅":18700,"##舆":18701,"##與":18702,"##興":18703,"##舉":18704,"##舊":18705,"##舌":18706,"##舍":18707,"##舎":18708,"##舐":18709,"##舒":18710,"##舔":18711,"##舖":18712,"##舗":18713,"##舛":18714,"##舜":18715,"##舞":18716,"##舟":18717,"##航":18718,"##舫":18719,"##般":18720,"##舰":18721,"##舱":18722,"##舵":18723,"##舶":18724,"##舷":18725,"##舸":18726,"##船":18727,"##舺":18728,"##舾":18729,"##艇":18730,"##艋":18731,"##艘":18732,"##艙":18733,"##艦":18734,"##艮":18735,"##良":18736,"##艰":18737,"##艱":18738,"##色":18739,"##艳":18740,"##艷":18741,"##艹":18742,"##艺":18743,"##艾":18744,"##节":18745,"##芃":18746,"##芈":18747,"##芊":18748,"##芋":18749,"##芍":18750,"##芎":18751,"##芒":18752,"##芙":18753,"##芜":18754,"##芝":18755,"##芡":18756,"##芥":18757,"##芦":18758,"##芩":18759,"##芪":18760,"##芫":18761,"##芬":18762,"##芭":18763,"##芮":18764,"##芯":18765,"##花":18766,"##芳":18767,"##芷":18768,"##芸":18769,"##芹":18770,"##芻":18771,"##芽":18772,"##芾":18773,"##苁":18774,"##苄":18775,"##苇":18776,"##苋":18777,"##苍":18778,"##苏":18779,"##苑":18780,"##苒":18781,"##苓":18782,"##苔":18783,"##苕":18784,"##苗":18785,"##苛":18786,"##苜":18787,"##苞":18788,"##苟":18789,"##苡":18790,"##苣":18791,"##若":18792,"##苦":18793,"##苫":18794,"##苯":18795,"##英":18796,"##苷":18797,"##苹":18798,"##苻":18799,"##茁":18800,"##茂":18801,"##范":18802,"##茄":18803,"##茅":18804,"##茉":18805,"##茎":18806,"##茏":18807,"##茗":18808,"##茜":18809,"##茧":18810,"##茨":18811,"##茫":18812,"##茬":18813,"##茭":18814,"##茯":18815,"##茱":18816,"##茲":18817,"##茴":18818,"##茵":18819,"##茶":18820,"##茸":18821,"##茹":18822,"##茼":18823,"##荀":18824,"##荃":18825,"##荆":18826,"##草":18827,"##荊":18828,"##荏":18829,"##荐":18830,"##荒":18831,"##荔":18832,"##荖":18833,"##荘":18834,"##荚":18835,"##荞":18836,"##荟":18837,"##荠":18838,"##荡":18839,"##荣":18840,"##荤":18841,"##荥":18842,"##荧":18843,"##荨":18844,"##荪":18845,"##荫":18846,"##药":18847,"##荳":18848,"##荷":18849,"##荸":18850,"##荻":18851,"##荼":18852,"##荽":18853,"##莅":18854,"##莆":18855,"##莉":18856,"##莊":18857,"##莎":18858,"##莒":18859,"##莓":18860,"##莖":18861,"##莘":18862,"##莞":18863,"##莠":18864,"##莢":18865,"##莧":18866,"##莪":18867,"##莫":18868,"##莱":18869,"##莲":18870,"##莴":18871,"##获":18872,"##莹":18873,"##莺":18874,"##莽":18875,"##莿":18876,"##菀":18877,"##菁":18878,"##菅":18879,"##菇":18880,"##菈":18881,"##菊":18882,"##菌":18883,"##菏":18884,"##菓":18885,"##菖":18886,"##菘":18887,"##菜":18888,"##菟":18889,"##菠":18890,"##菡":18891,"##菩":18892,"##華":18893,"##菱":18894,"##菲":18895,"##菸":18896,"##菽":18897,"##萁":18898,"##萃":18899,"##萄":18900,"##萊":18901,"##萋":18902,"##萌":18903,"##萍":18904,"##萎":18905,"##萘":18906,"##萝":18907,"##萤":18908,"##营":18909,"##萦":18910,"##萧":18911,"##萨":18912,"##萩":18913,"##萬":18914,"##萱":18915,"##萵":18916,"##萸":18917,"##萼":18918,"##落":18919,"##葆":18920,"##葉":18921,"##著":18922,"##葚":18923,"##葛":18924,"##葡":18925,"##董":18926,"##葦":18927,"##葩":18928,"##葫":18929,"##葬":18930,"##葭":18931,"##葯":18932,"##葱":18933,"##葳":18934,"##葵":18935,"##葷":18936,"##葺":18937,"##蒂":18938,"##蒋":18939,"##蒐":18940,"##蒔":18941,"##蒙":18942,"##蒜":18943,"##蒞":18944,"##蒟":18945,"##蒡":18946,"##蒨":18947,"##蒲":18948,"##蒸":18949,"##蒹":18950,"##蒻":18951,"##蒼":18952,"##蒿":18953,"##蓁":18954,"##蓄":18955,"##蓆":18956,"##蓉":18957,"##蓋":18958,"##蓑":18959,"##蓓":18960,"##蓖":18961,"##蓝":18962,"##蓟":18963,"##蓦":18964,"##蓬":18965,"##蓮":18966,"##蓼":18967,"##蓿":18968,"##蔑":18969,"##蔓":18970,"##蔔":18971,"##蔗":18972,"##蔘":18973,"##蔚":18974,"##蔡":18975,"##蔣":18976,"##蔥":18977,"##蔫":18978,"##蔬":18979,"##蔭":18980,"##蔵":18981,"##蔷":18982,"##蔺":18983,"##蔻":18984,"##蔼":18985,"##蔽":18986,"##蕁":18987,"##蕃":18988,"##蕈":18989,"##蕉":18990,"##蕊":18991,"##蕎":18992,"##蕙":18993,"##蕤":18994,"##蕨":18995,"##蕩":18996,"##蕪":18997,"##蕭":18998,"##蕲":18999,"##蕴":19000,"##蕻":19001,"##蕾":19002,"##薄":19003,"##薅":19004,"##薇":19005,"##薈":19006,"##薊":19007,"##薏":19008,"##薑":19009,"##薔":19010,"##薙":19011,"##薛":19012,"##薦":19013,"##薨":19014,"##薩":19015,"##薪":19016,"##薬":19017,"##薯":19018,"##薰":19019,"##薹":19020,"##藉":19021,"##藍":19022,"##藏":19023,"##藐":19024,"##藓":19025,"##藕":19026,"##藜":19027,"##藝":19028,"##藤":19029,"##藥":19030,"##藩":19031,"##藹":19032,"##藻":19033,"##藿":19034,"##蘆":19035,"##蘇":19036,"##蘊":19037,"##蘋":19038,"##蘑":19039,"##蘚":19040,"##蘭":19041,"##蘸":19042,"##蘼":19043,"##蘿":19044,"##虎":19045,"##虏":19046,"##虐":19047,"##虑":19048,"##虔":19049,"##處":19050,"##虚":19051,"##虛":19052,"##虜":19053,"##虞":19054,"##號":19055,"##虢":19056,"##虧":19057,"##虫":19058,"##虬":19059,"##虱":19060,"##虹":19061,"##虻":19062,"##虽":19063,"##虾":19064,"##蚀":19065,"##蚁":19066,"##蚂":19067,"##蚊":19068,"##蚌":19069,"##蚓":19070,"##蚕":19071,"##蚜":19072,"##蚝":19073,"##蚣":19074,"##蚤":19075,"##蚩":19076,"##蚪":19077,"##蚯":19078,"##蚱":19079,"##蚵":19080,"##蛀":19081,"##蛆":19082,"##蛇":19083,"##蛊":19084,"##蛋":19085,"##蛎":19086,"##蛐":19087,"##蛔":19088,"##蛙":19089,"##蛛":19090,"##蛟":19091,"##蛤":19092,"##蛭":19093,"##蛮":19094,"##蛰":19095,"##蛳":19096,"##蛹":19097,"##蛻":19098,"##蛾":19099,"##蜀":19100,"##蜂":19101,"##蜃":19102,"##蜆":19103,"##蜇":19104,"##蜈":19105,"##蜊":19106,"##蜍":19107,"##蜒":19108,"##蜓":19109,"##蜕":19110,"##蜗":19111,"##蜘":19112,"##蜚":19113,"##蜜":19114,"##蜡":19115,"##蜢":19116,"##蜥":19117,"##蜱":19118,"##蜴":19119,"##蜷":19120,"##蜻":19121,"##蜿":19122,"##蝇":19123,"##蝈":19124,"##蝉":19125,"##蝌":19126,"##蝎":19127,"##蝕":19128,"##蝗":19129,"##蝙":19130,"##蝟":19131,"##蝠":19132,"##蝦":19133,"##蝨":19134,"##蝴":19135,"##蝶":19136,"##蝸":19137,"##蝼":19138,"##螂":19139,"##螃":19140,"##融":19141,"##螞":19142,"##螢":19143,"##螨":19144,"##螯":19145,"##螳":19146,"##螺":19147,"##蟀":19148,"##蟄":19149,"##蟆":19150,"##蟋":19151,"##蟎":19152,"##蟑":19153,"##蟒":19154,"##蟠":19155,"##蟬":19156,"##蟲":19157,"##蟹":19158,"##蟻":19159,"##蟾":19160,"##蠅":19161,"##蠍":19162,"##蠔":19163,"##蠕":19164,"##蠛":19165,"##蠟":19166,"##蠡":19167,"##蠢":19168,"##蠣":19169,"##蠱":19170,"##蠶":19171,"##蠹":19172,"##蠻":19173,"##血":19174,"##衄":19175,"##衅":19176,"##衆":19177,"##行":19178,"##衍":19179,"##術":19180,"##衔":19181,"##街":19182,"##衙":19183,"##衛":19184,"##衝":19185,"##衞":19186,"##衡":19187,"##衢":19188,"##衣":19189,"##补":19190,"##表":19191,"##衩":19192,"##衫":19193,"##衬":19194,"##衮":19195,"##衰":19196,"##衲":19197,"##衷":19198,"##衹":19199,"##衾":19200,"##衿":19201,"##袁":19202,"##袂":19203,"##袄":19204,"##袅":19205,"##袈":19206,"##袋":19207,"##袍":19208,"##袒":19209,"##袖":19210,"##袜":19211,"##袞":19212,"##袤":19213,"##袪":19214,"##被":19215,"##袭":19216,"##袱":19217,"##裁":19218,"##裂":19219,"##装":19220,"##裆":19221,"##裊":19222,"##裏":19223,"##裔":19224,"##裕":19225,"##裘":19226,"##裙":19227,"##補":19228,"##裝":19229,"##裟":19230,"##裡":19231,"##裤":19232,"##裨":19233,"##裱":19234,"##裳":19235,"##裴":19236,"##裸":19237,"##裹":19238,"##製":19239,"##裾":19240,"##褂":19241,"##複":19242,"##褐":19243,"##褒":19244,"##褓":19245,"##褔":19246,"##褚":19247,"##褥":19248,"##褪":19249,"##褫":19250,"##褲":19251,"##褶":19252,"##褻":19253,"##襁":19254,"##襄":19255,"##襟":19256,"##襠":19257,"##襪":19258,"##襬":19259,"##襯":19260,"##襲":19261,"##西":19262,"##要":19263,"##覃":19264,"##覆":19265,"##覇":19266,"##見":19267,"##規":19268,"##覓":19269,"##視":19270,"##覚":19271,"##覦":19272,"##覧":19273,"##親":19274,"##覬":19275,"##観":19276,"##覷":19277,"##覺":19278,"##覽":19279,"##觀":19280,"##见":19281,"##观":19282,"##规":19283,"##觅":19284,"##视":19285,"##览":19286,"##觉":19287,"##觊":19288,"##觎":19289,"##觐":19290,"##觑":19291,"##角":19292,"##觞":19293,"##解":19294,"##觥":19295,"##触":19296,"##觸":19297,"##言":19298,"##訂":19299,"##計":19300,"##訊":19301,"##討":19302,"##訓":19303,"##訕":19304,"##訖":19305,"##託":19306,"##記":19307,"##訛":19308,"##訝":19309,"##訟":19310,"##訣":19311,"##訥":19312,"##訪":19313,"##設":19314,"##許":19315,"##訳":19316,"##訴":19317,"##訶":19318,"##診":19319,"##註":19320,"##証":19321,"##詆":19322,"##詐":19323,"##詔":19324,"##評":19325,"##詛":19326,"##詞":19327,"##詠":19328,"##詡":19329,"##詢":19330,"##詣":19331,"##試":19332,"##詩":19333,"##詫":19334,"##詬":19335,"##詭":19336,"##詮":19337,"##詰":19338,"##話":19339,"##該":19340,"##詳":19341,"##詹":19342,"##詼":19343,"##誅":19344,"##誇":19345,"##誉":19346,"##誌":19347,"##認":19348,"##誓":19349,"##誕":19350,"##誘":19351,"##語":19352,"##誠":19353,"##誡":19354,"##誣":19355,"##誤":19356,"##誥":19357,"##誦":19358,"##誨":19359,"##說":19360,"##説":19361,"##読":19362,"##誰":19363,"##課":19364,"##誹":19365,"##誼":19366,"##調":19367,"##諄":19368,"##談":19369,"##請":19370,"##諏":19371,"##諒":19372,"##論":19373,"##諗":19374,"##諜":19375,"##諡":19376,"##諦":19377,"##諧":19378,"##諫":19379,"##諭":19380,"##諮":19381,"##諱":19382,"##諳":19383,"##諷":19384,"##諸":19385,"##諺":19386,"##諾":19387,"##謀":19388,"##謁":19389,"##謂":19390,"##謄":19391,"##謊":19392,"##謎":19393,"##謐":19394,"##謔":19395,"##謗":19396,"##謙":19397,"##講":19398,"##謝":19399,"##謠":19400,"##謨":19401,"##謬":19402,"##謹":19403,"##謾":19404,"##譁":19405,"##證":19406,"##譎":19407,"##譏":19408,"##識":19409,"##譙":19410,"##譚":19411,"##譜":19412,"##警":19413,"##譬":19414,"##譯":19415,"##議":19416,"##譲":19417,"##譴":19418,"##護":19419,"##譽":19420,"##讀":19421,"##變":19422,"##讓":19423,"##讚":19424,"##讞":19425,"##计":19426,"##订":19427,"##认":19428,"##讥":19429,"##讧":19430,"##讨":19431,"##让":19432,"##讪":19433,"##讫":19434,"##训":19435,"##议":19436,"##讯":19437,"##记":19438,"##讲":19439,"##讳":19440,"##讴":19441,"##讶":19442,"##讷":19443,"##许":19444,"##讹":19445,"##论":19446,"##讼":19447,"##讽":19448,"##设":19449,"##访":19450,"##诀":19451,"##证":19452,"##诃":19453,"##评":19454,"##诅":19455,"##识":19456,"##诈":19457,"##诉":19458,"##诊":19459,"##诋":19460,"##词":19461,"##诏":19462,"##译":19463,"##试":19464,"##诗":19465,"##诘":19466,"##诙":19467,"##诚":19468,"##诛":19469,"##话":19470,"##诞":19471,"##诟":19472,"##诠":19473,"##诡":19474,"##询":19475,"##诣":19476,"##诤":19477,"##该":19478,"##详":19479,"##诧":19480,"##诩":19481,"##诫":19482,"##诬":19483,"##语":19484,"##误":19485,"##诰":19486,"##诱":19487,"##诲":19488,"##说":19489,"##诵":19490,"##诶":19491,"##请":19492,"##诸":19493,"##诺":19494,"##读":19495,"##诽":19496,"##课":19497,"##诿":19498,"##谀":19499,"##谁":19500,"##调":19501,"##谄":19502,"##谅":19503,"##谆":19504,"##谈":19505,"##谊":19506,"##谋":19507,"##谌":19508,"##谍":19509,"##谎":19510,"##谏":19511,"##谐":19512,"##谑":19513,"##谒":19514,"##谓":19515,"##谔":19516,"##谕":19517,"##谗":19518,"##谘":19519,"##谙":19520,"##谚":19521,"##谛":19522,"##谜":19523,"##谟":19524,"##谢":19525,"##谣":19526,"##谤":19527,"##谥":19528,"##谦":19529,"##谧":19530,"##谨":19531,"##谩":19532,"##谪":19533,"##谬":19534,"##谭":19535,"##谯":19536,"##谱":19537,"##谲":19538,"##谴":19539,"##谶":19540,"##谷":19541,"##豁":19542,"##豆":19543,"##豇":19544,"##豈":19545,"##豉":19546,"##豊":19547,"##豌":19548,"##豎":19549,"##豐":19550,"##豔":19551,"##豚":19552,"##象":19553,"##豢":19554,"##豪":19555,"##豫":19556,"##豬":19557,"##豹":19558,"##豺":19559,"##貂":19560,"##貅":19561,"##貌":19562,"##貓":19563,"##貔":19564,"##貘":19565,"##貝":19566,"##貞":19567,"##負":19568,"##財":19569,"##貢":19570,"##貧":19571,"##貨":19572,"##販":19573,"##貪":19574,"##貫":19575,"##責":19576,"##貯":19577,"##貰":19578,"##貳":19579,"##貴":19580,"##貶":19581,"##買":19582,"##貸":19583,"##費":19584,"##貼":19585,"##貽":19586,"##貿":19587,"##賀":19588,"##賁":19589,"##賂":19590,"##賃":19591,"##賄":19592,"##資":19593,"##賈":19594,"##賊":19595,"##賑":19596,"##賓":19597,"##賜":19598,"##賞":19599,"##賠":19600,"##賡":19601,"##賢":19602,"##賣":19603,"##賤":19604,"##賦":19605,"##質":19606,"##賬":19607,"##賭":19608,"##賴":19609,"##賺":19610,"##購":19611,"##賽":19612,"##贅":19613,"##贈":19614,"##贊":19615,"##贍":19616,"##贏":19617,"##贓":19618,"##贖":19619,"##贛":19620,"##贝":19621,"##贞":19622,"##负":19623,"##贡":19624,"##财":19625,"##责":19626,"##贤":19627,"##败":19628,"##账":19629,"##货":19630,"##质":19631,"##贩":19632,"##贪":19633,"##贫":19634,"##贬":19635,"##购":19636,"##贮":19637,"##贯":19638,"##贰":19639,"##贱":19640,"##贲":19641,"##贴":19642,"##贵":19643,"##贷":19644,"##贸":19645,"##费":19646,"##贺":19647,"##贻":19648,"##贼":19649,"##贾":19650,"##贿":19651,"##赁":19652,"##赂":19653,"##赃":19654,"##资":19655,"##赅":19656,"##赈":19657,"##赊":19658,"##赋":19659,"##赌":19660,"##赎":19661,"##赏":19662,"##赐":19663,"##赓":19664,"##赔":19665,"##赖":19666,"##赘":19667,"##赚":19668,"##赛":19669,"##赝":19670,"##赞":19671,"##赠":19672,"##赡":19673,"##赢":19674,"##赣":19675,"##赤":19676,"##赦":19677,"##赧":19678,"##赫":19679,"##赭":19680,"##走":19681,"##赳":19682,"##赴":19683,"##赵":19684,"##赶":19685,"##起":19686,"##趁":19687,"##超":19688,"##越":19689,"##趋":19690,"##趕":19691,"##趙":19692,"##趟":19693,"##趣":19694,"##趨":19695,"##足":19696,"##趴":19697,"##趵":19698,"##趸":19699,"##趺":19700,"##趾":19701,"##跃":19702,"##跄":19703,"##跆":19704,"##跋":19705,"##跌":19706,"##跎":19707,"##跑":19708,"##跖":19709,"##跚":19710,"##跛":19711,"##距":19712,"##跟":19713,"##跡":19714,"##跤":19715,"##跨":19716,"##跩":19717,"##跪":19718,"##路":19719,"##跳":19720,"##践":19721,"##跷":19722,"##跹":19723,"##跺":19724,"##跻":19725,"##踉":19726,"##踊":19727,"##踌":19728,"##踏":19729,"##踐":19730,"##踝":19731,"##踞":19732,"##踟":19733,"##踢":19734,"##踩":19735,"##踪":19736,"##踮":19737,"##踱":19738,"##踴":19739,"##踵":19740,"##踹":19741,"##蹂":19742,"##蹄":19743,"##蹇":19744,"##蹈":19745,"##蹉":19746,"##蹊":19747,"##蹋":19748,"##蹑":19749,"##蹒":19750,"##蹙":19751,"##蹟":19752,"##蹣":19753,"##蹤":19754,"##蹦":19755,"##蹩":19756,"##蹬":19757,"##蹭":19758,"##蹲":19759,"##蹴":19760,"##蹶":19761,"##蹺":19762,"##蹼":19763,"##蹿":19764,"##躁":19765,"##躇":19766,"##躉":19767,"##躊":19768,"##躋":19769,"##躍":19770,"##躏":19771,"##躪":19772,"##身":19773,"##躬":19774,"##躯":19775,"##躲":19776,"##躺":19777,"##軀":19778,"##車":19779,"##軋":19780,"##軌":19781,"##軍":19782,"##軒":19783,"##軟":19784,"##転":19785,"##軸":19786,"##軼":19787,"##軽":19788,"##軾":19789,"##較":19790,"##載":19791,"##輒":19792,"##輓":19793,"##輔":19794,"##輕":19795,"##輛":19796,"##輝":19797,"##輟":19798,"##輩":19799,"##輪":19800,"##輯":19801,"##輸":19802,"##輻":19803,"##輾":19804,"##輿":19805,"##轄":19806,"##轅":19807,"##轆":19808,"##轉":19809,"##轍":19810,"##轎":19811,"##轟":19812,"##车":19813,"##轧":19814,"##轨":19815,"##轩":19816,"##转":19817,"##轭":19818,"##轮":19819,"##软":19820,"##轰":19821,"##轲":19822,"##轴":19823,"##轶":19824,"##轻":19825,"##轼":19826,"##载":19827,"##轿":19828,"##较":19829,"##辄":19830,"##辅":19831,"##辆":19832,"##辇":19833,"##辈":19834,"##辉":19835,"##辊":19836,"##辍":19837,"##辐":19838,"##辑":19839,"##输":19840,"##辕":19841,"##辖":19842,"##辗":19843,"##辘":19844,"##辙":19845,"##辛":19846,"##辜":19847,"##辞":19848,"##辟":19849,"##辣":19850,"##辦":19851,"##辨":19852,"##辩":19853,"##辫":19854,"##辭":19855,"##辮":19856,"##辯":19857,"##辰":19858,"##辱":19859,"##農":19860,"##边":19861,"##辺":19862,"##辻":19863,"##込":19864,"##辽":19865,"##达":19866,"##迁":19867,"##迂":19868,"##迄":19869,"##迅":19870,"##过":19871,"##迈":19872,"##迎":19873,"##运":19874,"##近":19875,"##返":19876,"##还":19877,"##这":19878,"##进":19879,"##远":19880,"##违":19881,"##连":19882,"##迟":19883,"##迢":19884,"##迤":19885,"##迥":19886,"##迦":19887,"##迩":19888,"##迪":19889,"##迫":19890,"##迭":19891,"##述":19892,"##迴":19893,"##迷":19894,"##迸":19895,"##迹":19896,"##迺":19897,"##追":19898,"##退":19899,"##送":19900,"##适":19901,"##逃":19902,"##逅":19903,"##逆":19904,"##选":19905,"##逊":19906,"##逍":19907,"##透":19908,"##逐":19909,"##递":19910,"##途":19911,"##逕":19912,"##逗":19913,"##這":19914,"##通":19915,"##逛":19916,"##逝":19917,"##逞":19918,"##速":19919,"##造":19920,"##逢":19921,"##連":19922,"##逮":19923,"##週":19924,"##進":19925,"##逵":19926,"##逶":19927,"##逸":19928,"##逻":19929,"##逼":19930,"##逾":19931,"##遁":19932,"##遂":19933,"##遅":19934,"##遇":19935,"##遊":19936,"##運":19937,"##遍":19938,"##過":19939,"##遏":19940,"##遐":19941,"##遑":19942,"##遒":19943,"##道":19944,"##達":19945,"##違":19946,"##遗":19947,"##遙":19948,"##遛":19949,"##遜":19950,"##遞":19951,"##遠":19952,"##遢":19953,"##遣":19954,"##遥":19955,"##遨":19956,"##適":19957,"##遭":19958,"##遮":19959,"##遲":19960,"##遴":19961,"##遵":19962,"##遶":19963,"##遷":19964,"##選":19965,"##遺":19966,"##遼":19967,"##遽":19968,"##避":19969,"##邀":19970,"##邁":19971,"##邂":19972,"##邃":19973,"##還":19974,"##邇":19975,"##邈":19976,"##邊":19977,"##邋":19978,"##邏":19979,"##邑":19980,"##邓":19981,"##邕":19982,"##邛":19983,"##邝":19984,"##邢":19985,"##那":19986,"##邦":19987,"##邨":19988,"##邪":19989,"##邬":19990,"##邮":19991,"##邯":19992,"##邰":19993,"##邱":19994,"##邳":19995,"##邵":19996,"##邸":19997,"##邹":19998,"##邺":19999,"##邻":20000,"##郁":20001,"##郅":20002,"##郊":20003,"##郎":20004,"##郑":20005,"##郜":20006,"##郝":20007,"##郡":20008,"##郢":20009,"##郤":20010,"##郦":20011,"##郧":20012,"##部":20013,"##郫":20014,"##郭":20015,"##郴":20016,"##郵":20017,"##郷":20018,"##郸":20019,"##都":20020,"##鄂":20021,"##鄉":20022,"##鄒":20023,"##鄔":20024,"##鄙":20025,"##鄞":20026,"##鄢":20027,"##鄧":20028,"##鄭":20029,"##鄰":20030,"##鄱":20031,"##鄲":20032,"##鄺":20033,"##酉":20034,"##酊":20035,"##酋":20036,"##酌":20037,"##配":20038,"##酐":20039,"##酒":20040,"##酗":20041,"##酚":20042,"##酝":20043,"##酢":20044,"##酣":20045,"##酥":20046,"##酩":20047,"##酪":20048,"##酬":20049,"##酮":20050,"##酯":20051,"##酰":20052,"##酱":20053,"##酵":20054,"##酶":20055,"##酷":20056,"##酸":20057,"##酿":20058,"##醃":20059,"##醇":20060,"##醉":20061,"##醋":20062,"##醍":20063,"##醐":20064,"##醒":20065,"##醚":20066,"##醛":20067,"##醜":20068,"##醞":20069,"##醣":20070,"##醪":20071,"##醫":20072,"##醬":20073,"##醮":20074,"##醯":20075,"##醴":20076,"##醺":20077,"##釀":20078,"##釁":20079,"##采":20080,"##釉":20081,"##释":20082,"##釋":20083,"##里":20084,"##重":20085,"##野":20086,"##量":20087,"##釐":20088,"##金":20089,"##釗":20090,"##釘":20091,"##釜":20092,"##針":20093,"##釣":20094,"##釦":20095,"##釧":20096,"##釵":20097,"##鈀":20098,"##鈉":20099,"##鈍":20100,"##鈎":20101,"##鈔":20102,"##鈕":20103,"##鈞":20104,"##鈣":20105,"##鈦":20106,"##鈪":20107,"##鈴":20108,"##鈺":20109,"##鈾":20110,"##鉀":20111,"##鉄":20112,"##鉅":20113,"##鉉":20114,"##鉑":20115,"##鉗":20116,"##鉚":20117,"##鉛":20118,"##鉤":20119,"##鉴":20120,"##鉻":20121,"##銀":20122,"##銃":20123,"##銅":20124,"##銑":20125,"##銓":20126,"##銖":20127,"##銘":20128,"##銜":20129,"##銬":20130,"##銭":20131,"##銮":20132,"##銳":20133,"##銷":20134,"##銹":20135,"##鋁":20136,"##鋅":20137,"##鋒":20138,"##鋤":20139,"##鋪":20140,"##鋰":20141,"##鋸":20142,"##鋼":20143,"##錄":20144,"##錐":20145,"##錘":20146,"##錚":20147,"##錠":20148,"##錢":20149,"##錦":20150,"##錨":20151,"##錫":20152,"##錮":20153,"##錯":20154,"##録":20155,"##錳":20156,"##錶":20157,"##鍊":20158,"##鍋":20159,"##鍍":20160,"##鍛":20161,"##鍥":20162,"##鍰":20163,"##鍵":20164,"##鍺":20165,"##鍾":20166,"##鎂":20167,"##鎊":20168,"##鎌":20169,"##鎏":20170,"##鎔":20171,"##鎖":20172,"##鎗":20173,"##鎚":20174,"##鎧":20175,"##鎬":20176,"##鎮":20177,"##鎳":20178,"##鏈":20179,"##鏖":20180,"##鏗":20181,"##鏘":20182,"##鏞":20183,"##鏟":20184,"##鏡":20185,"##鏢":20186,"##鏤":20187,"##鏽":20188,"##鐘":20189,"##鐮":20190,"##鐲":20191,"##鐳":20192,"##鐵":20193,"##鐸":20194,"##鐺":20195,"##鑄":20196,"##鑊":20197,"##鑑":20198,"##鑒":20199,"##鑣":20200,"##鑫":20201,"##鑰":20202,"##鑲":20203,"##鑼":20204,"##鑽":20205,"##鑾":20206,"##鑿":20207,"##针":20208,"##钉":20209,"##钊":20210,"##钎":20211,"##钏":20212,"##钒":20213,"##钓":20214,"##钗":20215,"##钙":20216,"##钛":20217,"##钜":20218,"##钝":20219,"##钞":20220,"##钟":20221,"##钠":20222,"##钡":20223,"##钢":20224,"##钣":20225,"##钤":20226,"##钥":20227,"##钦":20228,"##钧":20229,"##钨":20230,"##钩":20231,"##钮":20232,"##钯":20233,"##钰":20234,"##钱":20235,"##钳":20236,"##钴":20237,"##钵":20238,"##钺":20239,"##钻":20240,"##钼":20241,"##钾":20242,"##钿":20243,"##铀":20244,"##铁":20245,"##铂":20246,"##铃":20247,"##铄":20248,"##铅":20249,"##铆":20250,"##铉":20251,"##铎":20252,"##铐":20253,"##铛":20254,"##铜":20255,"##铝":20256,"##铠":20257,"##铡":20258,"##铢":20259,"##铣":20260,"##铤":20261,"##铨":20262,"##铩":20263,"##铬":20264,"##铭":20265,"##铮":20266,"##铰":20267,"##铲":20268,"##铵":20269,"##银":20270,"##铸":20271,"##铺":20272,"##链":20273,"##铿":20274,"##销":20275,"##锁":20276,"##锂":20277,"##锄":20278,"##锅":20279,"##锆":20280,"##锈":20281,"##锉":20282,"##锋":20283,"##锌":20284,"##锏":20285,"##锐":20286,"##锑":20287,"##错":20288,"##锚":20289,"##锟":20290,"##锡":20291,"##锢":20292,"##锣":20293,"##锤":20294,"##锥":20295,"##锦":20296,"##锭":20297,"##键":20298,"##锯":20299,"##锰":20300,"##锲":20301,"##锵":20302,"##锹":20303,"##锺":20304,"##锻":20305,"##镀":20306,"##镁":20307,"##镂":20308,"##镇":20309,"##镉":20310,"##镌":20311,"##镍":20312,"##镐":20313,"##镑":20314,"##镕":20315,"##镖":20316,"##镗":20317,"##镛":20318,"##镜":20319,"##镣":20320,"##镭":20321,"##镯":20322,"##镰":20323,"##镳":20324,"##镶":20325,"##長":20326,"##长":20327,"##門":20328,"##閃":20329,"##閉":20330,"##開":20331,"##閎":20332,"##閏":20333,"##閑":20334,"##閒":20335,"##間":20336,"##閔":20337,"##閘":20338,"##閡":20339,"##関":20340,"##閣":20341,"##閥":20342,"##閨":20343,"##閩":20344,"##閱":20345,"##閲":20346,"##閹":20347,"##閻":20348,"##閾":20349,"##闆":20350,"##闇":20351,"##闊":20352,"##闌":20353,"##闍":20354,"##闔":20355,"##闕":20356,"##闖":20357,"##闘":20358,"##關":20359,"##闡":20360,"##闢":20361,"##门":20362,"##闪":20363,"##闫":20364,"##闭":20365,"##问":20366,"##闯":20367,"##闰":20368,"##闲":20369,"##间":20370,"##闵":20371,"##闷":20372,"##闸":20373,"##闹":20374,"##闺":20375,"##闻":20376,"##闽":20377,"##闾":20378,"##阀":20379,"##阁":20380,"##阂":20381,"##阅":20382,"##阆":20383,"##阇":20384,"##阈":20385,"##阉":20386,"##阎":20387,"##阐":20388,"##阑":20389,"##阔":20390,"##阕":20391,"##阖":20392,"##阙":20393,"##阚":20394,"##阜":20395,"##队":20396,"##阡":20397,"##阪":20398,"##阮":20399,"##阱":20400,"##防":20401,"##阳":20402,"##阴":20403,"##阵":20404,"##阶":20405,"##阻":20406,"##阿":20407,"##陀":20408,"##陂":20409,"##附":20410,"##际":20411,"##陆":20412,"##陇":20413,"##陈":20414,"##陋":20415,"##陌":20416,"##降":20417,"##限":20418,"##陕":20419,"##陛":20420,"##陝":20421,"##陞":20422,"##陟":20423,"##陡":20424,"##院":20425,"##陣":20426,"##除":20427,"##陨":20428,"##险":20429,"##陪":20430,"##陰":20431,"##陲":20432,"##陳":20433,"##陵":20434,"##陶":20435,"##陷":20436,"##陸":20437,"##険":20438,"##陽":20439,"##隅":20440,"##隆":20441,"##隈":20442,"##隊":20443,"##隋":20444,"##隍":20445,"##階":20446,"##随":20447,"##隐":20448,"##隔":20449,"##隕":20450,"##隘":20451,"##隙":20452,"##際":20453,"##障":20454,"##隠":20455,"##隣":20456,"##隧":20457,"##隨":20458,"##險":20459,"##隱":20460,"##隴":20461,"##隶":20462,"##隸":20463,"##隻":20464,"##隼":20465,"##隽":20466,"##难":20467,"##雀":20468,"##雁":20469,"##雄":20470,"##雅":20471,"##集":20472,"##雇":20473,"##雉":20474,"##雋":20475,"##雌":20476,"##雍":20477,"##雎":20478,"##雏":20479,"##雑":20480,"##雒":20481,"##雕":20482,"##雖":20483,"##雙":20484,"##雛":20485,"##雜":20486,"##雞":20487,"##離":20488,"##難":20489,"##雨":20490,"##雪":20491,"##雯":20492,"##雰":20493,"##雲":20494,"##雳":20495,"##零":20496,"##雷":20497,"##雹":20498,"##電":20499,"##雾":20500,"##需":20501,"##霁":20502,"##霄":20503,"##霆":20504,"##震":20505,"##霈":20506,"##霉":20507,"##霊":20508,"##霍":20509,"##霎":20510,"##霏":20511,"##霑":20512,"##霓":20513,"##霖":20514,"##霜":20515,"##霞":20516,"##霧":20517,"##霭":20518,"##霰":20519,"##露":20520,"##霸":20521,"##霹":20522,"##霽":20523,"##霾":20524,"##靂":20525,"##靄":20526,"##靈":20527,"##青":20528,"##靓":20529,"##靖":20530,"##静":20531,"##靚":20532,"##靛":20533,"##靜":20534,"##非":20535,"##靠":20536,"##靡":20537,"##面":20538,"##靥":20539,"##靦":20540,"##革":20541,"##靳":20542,"##靴":20543,"##靶":20544,"##靼":20545,"##鞅":20546,"##鞋":20547,"##鞍":20548,"##鞏":20549,"##鞑":20550,"##鞘":20551,"##鞠":20552,"##鞣":20553,"##鞦":20554,"##鞭":20555,"##韆":20556,"##韋":20557,"##韌":20558,"##韓":20559,"##韜":20560,"##韦":20561,"##韧":20562,"##韩":20563,"##韬":20564,"##韭":20565,"##音":20566,"##韵":20567,"##韶":20568,"##韻":20569,"##響":20570,"##頁":20571,"##頂":20572,"##頃":20573,"##項":20574,"##順":20575,"##須":20576,"##頌":20577,"##預":20578,"##頑":20579,"##頒":20580,"##頓":20581,"##頗":20582,"##領":20583,"##頜":20584,"##頡":20585,"##頤":20586,"##頫":20587,"##頭":20588,"##頰":20589,"##頷":20590,"##頸":20591,"##頹":20592,"##頻":20593,"##頼":20594,"##顆":20595,"##題":20596,"##額":20597,"##顎":20598,"##顏":20599,"##顔":20600,"##願":20601,"##顛":20602,"##類":20603,"##顧":20604,"##顫":20605,"##顯":20606,"##顱":20607,"##顴":20608,"##页":20609,"##顶":20610,"##顷":20611,"##项":20612,"##顺":20613,"##须":20614,"##顼":20615,"##顽":20616,"##顾":20617,"##顿":20618,"##颁":20619,"##颂":20620,"##预":20621,"##颅":20622,"##领":20623,"##颇":20624,"##颈":20625,"##颉":20626,"##颊":20627,"##颌":20628,"##颍":20629,"##颐":20630,"##频":20631,"##颓":20632,"##颔":20633,"##颖":20634,"##颗":20635,"##题":20636,"##颚":20637,"##颛":20638,"##颜":20639,"##额":20640,"##颞":20641,"##颠":20642,"##颡":20643,"##颢":20644,"##颤":20645,"##颦":20646,"##颧":20647,"##風":20648,"##颯":20649,"##颱":20650,"##颳":20651,"##颶":20652,"##颼":20653,"##飄":20654,"##飆":20655,"##风":20656,"##飒":20657,"##飓":20658,"##飕":20659,"##飘":20660,"##飙":20661,"##飚":20662,"##飛":20663,"##飞":20664,"##食":20665,"##飢":20666,"##飨":20667,"##飩":20668,"##飪":20669,"##飯":20670,"##飲":20671,"##飼":20672,"##飽":20673,"##飾":20674,"##餃":20675,"##餅":20676,"##餉":20677,"##養":20678,"##餌":20679,"##餐":20680,"##餒":20681,"##餓":20682,"##餘":20683,"##餚":20684,"##餛":20685,"##餞":20686,"##餡":20687,"##館":20688,"##餮":20689,"##餵":20690,"##餾":20691,"##饅":20692,"##饈":20693,"##饋":20694,"##饌":20695,"##饍":20696,"##饑":20697,"##饒":20698,"##饕":20699,"##饗":20700,"##饞":20701,"##饥":20702,"##饨":20703,"##饪":20704,"##饬":20705,"##饭":20706,"##饮":20707,"##饯":20708,"##饰":20709,"##饱":20710,"##饲":20711,"##饴":20712,"##饵":20713,"##饶":20714,"##饷":20715,"##饺":20716,"##饼":20717,"##饽":20718,"##饿":20719,"##馀":20720,"##馁":20721,"##馄":20722,"##馅":20723,"##馆":20724,"##馈":20725,"##馋":20726,"##馍":20727,"##馏":20728,"##馒":20729,"##馔":20730,"##首":20731,"##馗":20732,"##香":20733,"##馥":20734,"##馨":20735,"##馬":20736,"##馭":20737,"##馮":20738,"##馳":20739,"##馴":20740,"##駁":20741,"##駄":20742,"##駅":20743,"##駆":20744,"##駐":20745,"##駒":20746,"##駕":20747,"##駛":20748,"##駝":20749,"##駭":20750,"##駱":20751,"##駿":20752,"##騁":20753,"##騎":20754,"##騏":20755,"##験":20756,"##騙":20757,"##騨":20758,"##騰":20759,"##騷":20760,"##驀":20761,"##驅":20762,"##驊":20763,"##驍":20764,"##驒":20765,"##驕":20766,"##驗":20767,"##驚":20768,"##驛":20769,"##驟":20770,"##驢":20771,"##驥":20772,"##马":20773,"##驭":20774,"##驮":20775,"##驯":20776,"##驰":20777,"##驱":20778,"##驳":20779,"##驴":20780,"##驶":20781,"##驷":20782,"##驸":20783,"##驹":20784,"##驻":20785,"##驼":20786,"##驾":20787,"##驿":20788,"##骁":20789,"##骂":20790,"##骄":20791,"##骅":20792,"##骆":20793,"##骇":20794,"##骈":20795,"##骊":20796,"##骋":20797,"##验":20798,"##骏":20799,"##骐":20800,"##骑":20801,"##骗":20802,"##骚":20803,"##骛":20804,"##骜":20805,"##骞":20806,"##骠":20807,"##骡":20808,"##骤":20809,"##骥":20810,"##骧":20811,"##骨":20812,"##骯":20813,"##骰":20814,"##骶":20815,"##骷":20816,"##骸":20817,"##骼":20818,"##髂":20819,"##髅":20820,"##髋":20821,"##髏":20822,"##髒":20823,"##髓":20824,"##體":20825,"##髖":20826,"##高":20827,"##髦":20828,"##髪":20829,"##髮":20830,"##髯":20831,"##髻":20832,"##鬃":20833,"##鬆":20834,"##鬍":20835,"##鬓":20836,"##鬚":20837,"##鬟":20838,"##鬢":20839,"##鬣":20840,"##鬥":20841,"##鬧":20842,"##鬱":20843,"##鬼":20844,"##魁":20845,"##魂":20846,"##魄":20847,"##魅":20848,"##魇":20849,"##魍":20850,"##魏":20851,"##魔":20852,"##魘":20853,"##魚":20854,"##魯":20855,"##魷":20856,"##鮑":20857,"##鮨":20858,"##鮪":20859,"##鮭":20860,"##鮮":20861,"##鯉":20862,"##鯊":20863,"##鯖":20864,"##鯛":20865,"##鯨":20866,"##鯰":20867,"##鯽":20868,"##鰍":20869,"##鰓":20870,"##鰭":20871,"##鰲":20872,"##鰻":20873,"##鰾":20874,"##鱈":20875,"##鱉":20876,"##鱔":20877,"##鱗":20878,"##鱷":20879,"##鱸":20880,"##鱼":20881,"##鱿":20882,"##鲁":20883,"##鲈":20884,"##鲍":20885,"##鲑":20886,"##鲛":20887,"##鲜":20888,"##鲟":20889,"##鲢":20890,"##鲤":20891,"##鲨":20892,"##鲫":20893,"##鲱":20894,"##鲲":20895,"##鲶":20896,"##鲷":20897,"##鲸":20898,"##鳃":20899,"##鳄":20900,"##鳅":20901,"##鳌":20902,"##鳍":20903,"##鳕":20904,"##鳖":20905,"##鳗":20906,"##鳝":20907,"##鳞":20908,"##鳥":20909,"##鳩":20910,"##鳳":20911,"##鳴":20912,"##鳶":20913,"##鴉":20914,"##鴕":20915,"##鴛":20916,"##鴦":20917,"##鴨":20918,"##鴻":20919,"##鴿":20920,"##鵑":20921,"##鵜":20922,"##鵝":20923,"##鵡":20924,"##鵬":20925,"##鵰":20926,"##鵲":20927,"##鶘":20928,"##鶩":20929,"##鶯":20930,"##鶴":20931,"##鷗":20932,"##鷲":20933,"##鷹":20934,"##鷺":20935,"##鸚":20936,"##鸞":20937,"##鸟":20938,"##鸠":20939,"##鸡":20940,"##鸢":20941,"##鸣":20942,"##鸥":20943,"##鸦":20944,"##鸨":20945,"##鸪":20946,"##鸭":20947,"##鸯":20948,"##鸳":20949,"##鸵":20950,"##鸽":20951,"##鸾":20952,"##鸿":20953,"##鹂":20954,"##鹃":20955,"##鹄":20956,"##鹅":20957,"##鹈":20958,"##鹉":20959,"##鹊":20960,"##鹌":20961,"##鹏":20962,"##鹑":20963,"##鹕":20964,"##鹘":20965,"##鹜":20966,"##鹞":20967,"##鹤":20968,"##鹦":20969,"##鹧":20970,"##鹫":20971,"##鹭":20972,"##鹰":20973,"##鹳":20974,"##鹵":20975,"##鹹":20976,"##鹼":20977,"##鹽":20978,"##鹿":20979,"##麂":20980,"##麋":20981,"##麒":20982,"##麓":20983,"##麗":20984,"##麝":20985,"##麟":20986,"##麥":20987,"##麦":20988,"##麩":20989,"##麴":20990,"##麵":20991,"##麸":20992,"##麺":20993,"##麻":20994,"##麼":20995,"##麽":20996,"##麾":20997,"##黃":20998,"##黄":20999,"##黍":21000,"##黎":21001,"##黏":21002,"##黑":21003,"##黒":21004,"##黔":21005,"##默":21006,"##黛":21007,"##黜":21008,"##黝":21009,"##點":21010,"##黠":21011,"##黨":21012,"##黯":21013,"##黴":21014,"##鼋":21015,"##鼎":21016,"##鼐":21017,"##鼓":21018,"##鼠":21019,"##鼬":21020,"##鼹":21021,"##鼻":21022,"##鼾":21023,"##齁":21024,"##齊":21025,"##齋":21026,"##齐":21027,"##齒":21028,"##齡":21029,"##齢":21030,"##齣":21031,"##齦":21032,"##齿":21033,"##龄":21034,"##龅":21035,"##龈":21036,"##龊":21037,"##龋":21038,"##龌":21039,"##龍":21040,"##龐":21041,"##龔":21042,"##龕":21043,"##龙":21044,"##龚":21045,"##龛":21046,"##龜":21047,"##龟":21048,"##︰":21049,"##︱":21050,"##︶":21051,"##︿":21052,"##﹁":21053,"##﹂":21054,"##﹍":21055,"##﹏":21056,"##﹐":21057,"##﹑":21058,"##﹒":21059,"##﹔":21060,"##﹕":21061,"##﹖":21062,"##﹗":21063,"##﹙":21064,"##﹚":21065,"##﹝":21066,"##﹞":21067,"##﹡":21068,"##﹣":21069,"##!":21070,"##"":21071,"###":21072,"##$":21073,"##%":21074,"##&":21075,"##'":21076,"##(":21077,"##)":21078,"##*":21079,"##,":21080,"##-":21081,"##.":21082,"##/":21083,"##:":21084,"##;":21085,"##<":21086,"##?":21087,"##@":21088,"##[":21089,"##\":21090,"##]":21091,"##^":21092,"##_":21093,"##`":21094,"##f":21095,"##h":21096,"##j":21097,"##u":21098,"##w":21099,"##z":21100,"##{":21101,"##}":21102,"##。":21103,"##「":21104,"##」":21105,"##、":21106,"##・":21107,"##ッ":21108,"##ー":21109,"##イ":21110,"##ク":21111,"##シ":21112,"##ス":21113,"##ト":21114,"##ノ":21115,"##フ":21116,"##ラ":21117,"##ル":21118,"##ン":21119,"##゙":21120,"##゚":21121,"## ̄":21122,"##¥":21123,"##👍":21124,"##🔥":21125,"##😂":21126,"##😎":21127}}}
\ No newline at end of file
diff --git a/bert/chinese-roberta-wwm-ext-large/tokenizer_config.json b/bert/chinese-roberta-wwm-ext-large/tokenizer_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..66051e65c65b3ec5e0b437496d1e545c5d8934b4
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/tokenizer_config.json
@@ -0,0 +1 @@
+{"init_inputs": []}
\ No newline at end of file
diff --git a/bert/chinese-roberta-wwm-ext-large/vocab.txt b/bert/chinese-roberta-wwm-ext-large/vocab.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ca4f9781030019ab9b253c6dcb8c7878b6dc87a5
--- /dev/null
+++ b/bert/chinese-roberta-wwm-ext-large/vocab.txt
@@ -0,0 +1,21128 @@
+[PAD]
+[unused1]
+[unused2]
+[unused3]
+[unused4]
+[unused5]
+[unused6]
+[unused7]
+[unused8]
+[unused9]
+[unused10]
+[unused11]
+[unused12]
+[unused13]
+[unused14]
+[unused15]
+[unused16]
+[unused17]
+[unused18]
+[unused19]
+[unused20]
+[unused21]
+[unused22]
+[unused23]
+[unused24]
+[unused25]
+[unused26]
+[unused27]
+[unused28]
+[unused29]
+[unused30]
+[unused31]
+[unused32]
+[unused33]
+[unused34]
+[unused35]
+[unused36]
+[unused37]
+[unused38]
+[unused39]
+[unused40]
+[unused41]
+[unused42]
+[unused43]
+[unused44]
+[unused45]
+[unused46]
+[unused47]
+[unused48]
+[unused49]
+[unused50]
+[unused51]
+[unused52]
+[unused53]
+[unused54]
+[unused55]
+[unused56]
+[unused57]
+[unused58]
+[unused59]
+[unused60]
+[unused61]
+[unused62]
+[unused63]
+[unused64]
+[unused65]
+[unused66]
+[unused67]
+[unused68]
+[unused69]
+[unused70]
+[unused71]
+[unused72]
+[unused73]
+[unused74]
+[unused75]
+[unused76]
+[unused77]
+[unused78]
+[unused79]
+[unused80]
+[unused81]
+[unused82]
+[unused83]
+[unused84]
+[unused85]
+[unused86]
+[unused87]
+[unused88]
+[unused89]
+[unused90]
+[unused91]
+[unused92]
+[unused93]
+[unused94]
+[unused95]
+[unused96]
+[unused97]
+[unused98]
+[unused99]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+
+
+!
+"
+#
+$
+%
+&
+'
+(
+)
+*
++
+,
+-
+.
+/
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+:
+;
+<
+=
+>
+?
+@
+[
+\
+]
+^
+_
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
+{
+|
+}
+~
+£
+¤
+¥
+§
+©
+«
+®
+°
+±
+²
+³
+µ
+·
+¹
+º
+»
+¼
+×
+ß
+æ
+÷
+ø
+đ
+ŋ
+ɔ
+ə
+ɡ
+ʰ
+ˇ
+ˈ
+ˊ
+ˋ
+ˍ
+ː
+˙
+˚
+ˢ
+α
+β
+γ
+δ
+ε
+η
+θ
+ι
+κ
+λ
+μ
+ν
+ο
+π
+ρ
+ς
+σ
+τ
+υ
+φ
+χ
+ψ
+ω
+а
+б
+в
+г
+д
+е
+ж
+з
+и
+к
+л
+м
+н
+о
+п
+р
+с
+т
+у
+ф
+х
+ц
+ч
+ш
+ы
+ь
+я
+і
+ا
+ب
+ة
+ت
+د
+ر
+س
+ع
+ل
+م
+ن
+ه
+و
+ي
+۩
+ก
+ง
+น
+ม
+ย
+ร
+อ
+า
+เ
+๑
+་
+ღ
+ᄀ
+ᄁ
+ᄂ
+ᄃ
+ᄅ
+ᄆ
+ᄇ
+ᄈ
+ᄉ
+ᄋ
+ᄌ
+ᄎ
+ᄏ
+ᄐ
+ᄑ
+ᄒ
+ᅡ
+ᅢ
+ᅣ
+ᅥ
+ᅦ
+ᅧ
+ᅨ
+ᅩ
+ᅪ
+ᅬ
+ᅭ
+ᅮ
+ᅯ
+ᅲ
+ᅳ
+ᅴ
+ᅵ
+ᆨ
+ᆫ
+ᆯ
+ᆷ
+ᆸ
+ᆺ
+ᆻ
+ᆼ
+ᗜ
+ᵃ
+ᵉ
+ᵍ
+ᵏ
+ᵐ
+ᵒ
+ᵘ
+‖
+„
+†
+•
+‥
+‧
+
+‰
+′
+″
+‹
+›
+※
+‿
+⁄
+ⁱ
+⁺
+ⁿ
+₁
+₂
+₃
+₄
+€
+℃
+№
+™
+ⅰ
+ⅱ
+ⅲ
+ⅳ
+ⅴ
+←
+↑
+→
+↓
+↔
+↗
+↘
+⇒
+∀
+−
+∕
+∙
+√
+∞
+∟
+∠
+∣
+∥
+∩
+∮
+∶
+∼
+∽
+≈
+≒
+≡
+≤
+≥
+≦
+≧
+≪
+≫
+⊙
+⋅
+⋈
+⋯
+⌒
+①
+②
+③
+④
+⑤
+⑥
+⑦
+⑧
+⑨
+⑩
+⑴
+⑵
+⑶
+⑷
+⑸
+⒈
+⒉
+⒊
+⒋
+ⓒ
+ⓔ
+ⓘ
+─
+━
+│
+┃
+┅
+┆
+┊
+┌
+└
+├
+┣
+═
+║
+╚
+╞
+╠
+╭
+╮
+╯
+╰
+╱
+╳
+▂
+▃
+▅
+▇
+█
+▉
+▋
+▌
+▍
+▎
+■
+□
+▪
+▫
+▬
+▲
+△
+▶
+►
+▼
+▽
+◆
+◇
+○
+◎
+●
+◕
+◠
+◢
+◤
+☀
+★
+☆
+☕
+☞
+☺
+☼
+♀
+♂
+♠
+♡
+♣
+♥
+♦
+♪
+♫
+♬
+✈
+✔
+✕
+✖
+✦
+✨
+✪
+✰
+✿
+❀
+❤
+➜
+➤
+⦿
+、
+。
+〃
+々
+〇
+〈
+〉
+《
+》
+「
+」
+『
+』
+【
+】
+〓
+〔
+〕
+〖
+〗
+〜
+〝
+〞
+ぁ
+あ
+ぃ
+い
+う
+ぇ
+え
+お
+か
+き
+く
+け
+こ
+さ
+し
+す
+せ
+そ
+た
+ち
+っ
+つ
+て
+と
+な
+に
+ぬ
+ね
+の
+は
+ひ
+ふ
+へ
+ほ
+ま
+み
+む
+め
+も
+ゃ
+や
+ゅ
+ゆ
+ょ
+よ
+ら
+り
+る
+れ
+ろ
+わ
+を
+ん
+゜
+ゝ
+ァ
+ア
+ィ
+イ
+ゥ
+ウ
+ェ
+エ
+ォ
+オ
+カ
+キ
+ク
+ケ
+コ
+サ
+シ
+ス
+セ
+ソ
+タ
+チ
+ッ
+ツ
+テ
+ト
+ナ
+ニ
+ヌ
+ネ
+ノ
+ハ
+ヒ
+フ
+ヘ
+ホ
+マ
+ミ
+ム
+メ
+モ
+ャ
+ヤ
+ュ
+ユ
+ョ
+ヨ
+ラ
+リ
+ル
+レ
+ロ
+ワ
+ヲ
+ン
+ヶ
+・
+ー
+ヽ
+ㄅ
+ㄆ
+ㄇ
+ㄉ
+ㄋ
+ㄌ
+ㄍ
+ㄎ
+ㄏ
+ㄒ
+ㄚ
+ㄛ
+ㄞ
+ㄟ
+ㄢ
+ㄤ
+ㄥ
+ㄧ
+ㄨ
+ㆍ
+㈦
+㊣
+㎡
+㗎
+一
+丁
+七
+万
+丈
+三
+上
+下
+不
+与
+丐
+丑
+专
+且
+丕
+世
+丘
+丙
+业
+丛
+东
+丝
+丞
+丟
+両
+丢
+两
+严
+並
+丧
+丨
+个
+丫
+中
+丰
+串
+临
+丶
+丸
+丹
+为
+主
+丼
+丽
+举
+丿
+乂
+乃
+久
+么
+义
+之
+乌
+乍
+乎
+乏
+乐
+乒
+乓
+乔
+乖
+乗
+乘
+乙
+乜
+九
+乞
+也
+习
+乡
+书
+乩
+买
+乱
+乳
+乾
+亀
+亂
+了
+予
+争
+事
+二
+于
+亏
+云
+互
+五
+井
+亘
+亙
+亚
+些
+亜
+亞
+亟
+亡
+亢
+交
+亥
+亦
+产
+亨
+亩
+享
+京
+亭
+亮
+亲
+亳
+亵
+人
+亿
+什
+仁
+仃
+仄
+仅
+仆
+仇
+今
+介
+仍
+从
+仏
+仑
+仓
+仔
+仕
+他
+仗
+付
+仙
+仝
+仞
+仟
+代
+令
+以
+仨
+仪
+们
+仮
+仰
+仲
+件
+价
+任
+份
+仿
+企
+伉
+伊
+伍
+伎
+伏
+伐
+休
+伕
+众
+优
+伙
+会
+伝
+伞
+伟
+传
+伢
+伤
+伦
+伪
+伫
+伯
+估
+伴
+伶
+伸
+伺
+似
+伽
+佃
+但
+佇
+佈
+位
+低
+住
+佐
+佑
+体
+佔
+何
+佗
+佘
+余
+佚
+佛
+作
+佝
+佞
+佟
+你
+佢
+佣
+佤
+佥
+佩
+佬
+佯
+佰
+佳
+併
+佶
+佻
+佼
+使
+侃
+侄
+來
+侈
+例
+侍
+侏
+侑
+侖
+侗
+供
+依
+侠
+価
+侣
+侥
+侦
+侧
+侨
+侬
+侮
+侯
+侵
+侶
+侷
+便
+係
+促
+俄
+俊
+俎
+俏
+俐
+俑
+俗
+俘
+俚
+保
+俞
+俟
+俠
+信
+俨
+俩
+俪
+俬
+俭
+修
+俯
+俱
+俳
+俸
+俺
+俾
+倆
+倉
+個
+倌
+倍
+倏
+們
+倒
+倔
+倖
+倘
+候
+倚
+倜
+借
+倡
+値
+倦
+倩
+倪
+倫
+倬
+倭
+倶
+债
+值
+倾
+偃
+假
+偈
+偉
+偌
+偎
+偏
+偕
+做
+停
+健
+側
+偵
+偶
+偷
+偻
+偽
+偿
+傀
+傅
+傍
+傑
+傘
+備
+傚
+傢
+傣
+傥
+储
+傩
+催
+傭
+傲
+傳
+債
+傷
+傻
+傾
+僅
+働
+像
+僑
+僕
+僖
+僚
+僥
+僧
+僭
+僮
+僱
+僵
+價
+僻
+儀
+儂
+億
+儆
+儉
+儋
+儒
+儕
+儘
+償
+儡
+優
+儲
+儷
+儼
+儿
+兀
+允
+元
+兄
+充
+兆
+兇
+先
+光
+克
+兌
+免
+児
+兑
+兒
+兔
+兖
+党
+兜
+兢
+入
+內
+全
+兩
+八
+公
+六
+兮
+兰
+共
+兲
+关
+兴
+兵
+其
+具
+典
+兹
+养
+兼
+兽
+冀
+内
+円
+冇
+冈
+冉
+冊
+册
+再
+冏
+冒
+冕
+冗
+写
+军
+农
+冠
+冢
+冤
+冥
+冨
+冪
+冬
+冯
+冰
+冲
+决
+况
+冶
+冷
+冻
+冼
+冽
+冾
+净
+凄
+准
+凇
+凈
+凉
+凋
+凌
+凍
+减
+凑
+凛
+凜
+凝
+几
+凡
+凤
+処
+凪
+凭
+凯
+凰
+凱
+凳
+凶
+凸
+凹
+出
+击
+函
+凿
+刀
+刁
+刃
+分
+切
+刈
+刊
+刍
+刎
+刑
+划
+列
+刘
+则
+刚
+创
+初
+删
+判
+別
+刨
+利
+刪
+别
+刮
+到
+制
+刷
+券
+刹
+刺
+刻
+刽
+剁
+剂
+剃
+則
+剉
+削
+剋
+剌
+前
+剎
+剐
+剑
+剔
+剖
+剛
+剜
+剝
+剣
+剤
+剥
+剧
+剩
+剪
+副
+割
+創
+剷
+剽
+剿
+劃
+劇
+劈
+劉
+劊
+劍
+劏
+劑
+力
+劝
+办
+功
+加
+务
+劣
+动
+助
+努
+劫
+劭
+励
+劲
+劳
+労
+劵
+効
+劾
+势
+勁
+勃
+勇
+勉
+勋
+勐
+勒
+動
+勖
+勘
+務
+勛
+勝
+勞
+募
+勢
+勤
+勧
+勳
+勵
+勸
+勺
+勻
+勾
+勿
+匀
+包
+匆
+匈
+匍
+匐
+匕
+化
+北
+匙
+匝
+匠
+匡
+匣
+匪
+匮
+匯
+匱
+匹
+区
+医
+匾
+匿
+區
+十
+千
+卅
+升
+午
+卉
+半
+卍
+华
+协
+卑
+卒
+卓
+協
+单
+卖
+南
+単
+博
+卜
+卞
+卟
+占
+卡
+卢
+卤
+卦
+卧
+卫
+卮
+卯
+印
+危
+即
+却
+卵
+卷
+卸
+卻
+卿
+厂
+厄
+厅
+历
+厉
+压
+厌
+厕
+厘
+厚
+厝
+原
+厢
+厥
+厦
+厨
+厩
+厭
+厮
+厲
+厳
+去
+县
+叁
+参
+參
+又
+叉
+及
+友
+双
+反
+収
+发
+叔
+取
+受
+变
+叙
+叛
+叟
+叠
+叡
+叢
+口
+古
+句
+另
+叨
+叩
+只
+叫
+召
+叭
+叮
+可
+台
+叱
+史
+右
+叵
+叶
+号
+司
+叹
+叻
+叼
+叽
+吁
+吃
+各
+吆
+合
+吉
+吊
+吋
+同
+名
+后
+吏
+吐
+向
+吒
+吓
+吕
+吖
+吗
+君
+吝
+吞
+吟
+吠
+吡
+否
+吧
+吨
+吩
+含
+听
+吭
+吮
+启
+吱
+吳
+吴
+吵
+吶
+吸
+吹
+吻
+吼
+吽
+吾
+呀
+呂
+呃
+呆
+呈
+告
+呋
+呎
+呐
+呓
+呕
+呗
+员
+呛
+呜
+呢
+呤
+呦
+周
+呱
+呲
+味
+呵
+呷
+呸
+呻
+呼
+命
+咀
+咁
+咂
+咄
+咆
+咋
+和
+咎
+咏
+咐
+咒
+咔
+咕
+咖
+咗
+咘
+咙
+咚
+咛
+咣
+咤
+咦
+咧
+咨
+咩
+咪
+咫
+咬
+咭
+咯
+咱
+咲
+咳
+咸
+咻
+咽
+咿
+哀
+品
+哂
+哄
+哆
+哇
+哈
+哉
+哋
+哌
+响
+哎
+哏
+哐
+哑
+哒
+哔
+哗
+哟
+員
+哥
+哦
+哧
+哨
+哩
+哪
+哭
+哮
+哲
+哺
+哼
+哽
+唁
+唄
+唆
+唇
+唉
+唏
+唐
+唑
+唔
+唠
+唤
+唧
+唬
+售
+唯
+唰
+唱
+唳
+唷
+唸
+唾
+啃
+啄
+商
+啉
+啊
+問
+啓
+啕
+啖
+啜
+啞
+啟
+啡
+啤
+啥
+啦
+啧
+啪
+啫
+啬
+啮
+啰
+啱
+啲
+啵
+啶
+啷
+啸
+啻
+啼
+啾
+喀
+喂
+喃
+善
+喆
+喇
+喉
+喊
+喋
+喎
+喏
+喔
+喘
+喙
+喚
+喜
+喝
+喟
+喧
+喪
+喫
+喬
+單
+喰
+喱
+喲
+喳
+喵
+営
+喷
+喹
+喺
+喻
+喽
+嗅
+嗆
+嗇
+嗎
+嗑
+嗒
+嗓
+嗔
+嗖
+嗚
+嗜
+嗝
+嗟
+嗡
+嗣
+嗤
+嗦
+嗨
+嗪
+嗬
+嗯
+嗰
+嗲
+嗳
+嗶
+嗷
+嗽
+嘀
+嘅
+嘆
+嘈
+嘉
+嘌
+嘍
+嘎
+嘔
+嘖
+嘗
+嘘
+嘚
+嘛
+嘜
+嘞
+嘟
+嘢
+嘣
+嘤
+嘧
+嘩
+嘭
+嘮
+嘯
+嘰
+嘱
+嘲
+嘴
+嘶
+嘸
+嘹
+嘻
+嘿
+噁
+噌
+噎
+噓
+噔
+噗
+噙
+噜
+噠
+噢
+噤
+器
+噩
+噪
+噬
+噱
+噴
+噶
+噸
+噹
+噻
+噼
+嚀
+嚇
+嚎
+嚏
+嚐
+嚓
+嚕
+嚟
+嚣
+嚥
+嚨
+嚮
+嚴
+嚷
+嚼
+囂
+囉
+囊
+囍
+囑
+囔
+囗
+囚
+四
+囝
+回
+囟
+因
+囡
+团
+団
+囤
+囧
+囪
+囫
+园
+困
+囱
+囲
+図
+围
+囹
+固
+国
+图
+囿
+圃
+圄
+圆
+圈
+國
+圍
+圏
+園
+圓
+圖
+團
+圜
+土
+圣
+圧
+在
+圩
+圭
+地
+圳
+场
+圻
+圾
+址
+坂
+均
+坊
+坍
+坎
+坏
+坐
+坑
+块
+坚
+坛
+坝
+坞
+坟
+坠
+坡
+坤
+坦
+坨
+坪
+坯
+坳
+坵
+坷
+垂
+垃
+垄
+型
+垒
+垚
+垛
+垠
+垢
+垣
+垦
+垩
+垫
+垭
+垮
+垵
+埂
+埃
+埋
+城
+埔
+埕
+埗
+域
+埠
+埤
+埵
+執
+埸
+培
+基
+埼
+堀
+堂
+堃
+堅
+堆
+堇
+堑
+堕
+堙
+堡
+堤
+堪
+堯
+堰
+報
+場
+堵
+堺
+堿
+塊
+塌
+塑
+塔
+塗
+塘
+塚
+塞
+塢
+塩
+填
+塬
+塭
+塵
+塾
+墀
+境
+墅
+墉
+墊
+墒
+墓
+増
+墘
+墙
+墜
+增
+墟
+墨
+墩
+墮
+墳
+墻
+墾
+壁
+壅
+壆
+壇
+壊
+壑
+壓
+壕
+壘
+壞
+壟
+壢
+壤
+壩
+士
+壬
+壮
+壯
+声
+売
+壳
+壶
+壹
+壺
+壽
+处
+备
+変
+复
+夏
+夔
+夕
+外
+夙
+多
+夜
+够
+夠
+夢
+夥
+大
+天
+太
+夫
+夭
+央
+夯
+失
+头
+夷
+夸
+夹
+夺
+夾
+奂
+奄
+奇
+奈
+奉
+奋
+奎
+奏
+奐
+契
+奔
+奕
+奖
+套
+奘
+奚
+奠
+奢
+奥
+奧
+奪
+奬
+奮
+女
+奴
+奶
+奸
+她
+好
+如
+妃
+妄
+妆
+妇
+妈
+妊
+妍
+妒
+妓
+妖
+妘
+妙
+妝
+妞
+妣
+妤
+妥
+妨
+妩
+妪
+妮
+妲
+妳
+妹
+妻
+妾
+姆
+姉
+姊
+始
+姍
+姐
+姑
+姒
+姓
+委
+姗
+姚
+姜
+姝
+姣
+姥
+姦
+姨
+姪
+姫
+姬
+姹
+姻
+姿
+威
+娃
+娄
+娅
+娆
+娇
+娉
+娑
+娓
+娘
+娛
+娜
+娟
+娠
+娣
+娥
+娩
+娱
+娲
+娴
+娶
+娼
+婀
+婁
+婆
+婉
+婊
+婕
+婚
+婢
+婦
+婧
+婪
+婭
+婴
+婵
+婶
+婷
+婺
+婿
+媒
+媚
+媛
+媞
+媧
+媲
+媳
+媽
+媾
+嫁
+嫂
+嫉
+嫌
+嫑
+嫔
+嫖
+嫘
+嫚
+嫡
+嫣
+嫦
+嫩
+嫲
+嫵
+嫻
+嬅
+嬉
+嬌
+嬗
+嬛
+嬢
+嬤
+嬪
+嬰
+嬴
+嬷
+嬸
+嬿
+孀
+孃
+子
+孑
+孔
+孕
+孖
+字
+存
+孙
+孚
+孛
+孜
+孝
+孟
+孢
+季
+孤
+学
+孩
+孪
+孫
+孬
+孰
+孱
+孳
+孵
+學
+孺
+孽
+孿
+宁
+它
+宅
+宇
+守
+安
+宋
+完
+宏
+宓
+宕
+宗
+官
+宙
+定
+宛
+宜
+宝
+实
+実
+宠
+审
+客
+宣
+室
+宥
+宦
+宪
+宫
+宮
+宰
+害
+宴
+宵
+家
+宸
+容
+宽
+宾
+宿
+寂
+寄
+寅
+密
+寇
+富
+寐
+寒
+寓
+寛
+寝
+寞
+察
+寡
+寢
+寥
+實
+寧
+寨
+審
+寫
+寬
+寮
+寰
+寵
+寶
+寸
+对
+寺
+寻
+导
+対
+寿
+封
+専
+射
+将
+將
+專
+尉
+尊
+尋
+對
+導
+小
+少
+尔
+尕
+尖
+尘
+尚
+尝
+尤
+尧
+尬
+就
+尴
+尷
+尸
+尹
+尺
+尻
+尼
+尽
+尾
+尿
+局
+屁
+层
+屄
+居
+屆
+屈
+屉
+届
+屋
+屌
+屍
+屎
+屏
+屐
+屑
+展
+屜
+属
+屠
+屡
+屢
+層
+履
+屬
+屯
+山
+屹
+屿
+岀
+岁
+岂
+岌
+岐
+岑
+岔
+岖
+岗
+岘
+岙
+岚
+岛
+岡
+岩
+岫
+岬
+岭
+岱
+岳
+岷
+岸
+峇
+峋
+峒
+峙
+峡
+峤
+峥
+峦
+峨
+峪
+峭
+峯
+峰
+峴
+島
+峻
+峽
+崁
+崂
+崆
+崇
+崎
+崑
+崔
+崖
+崗
+崙
+崛
+崧
+崩
+崭
+崴
+崽
+嵇
+嵊
+嵋
+嵌
+嵐
+嵘
+嵩
+嵬
+嵯
+嶂
+嶄
+嶇
+嶋
+嶙
+嶺
+嶼
+嶽
+巅
+巍
+巒
+巔
+巖
+川
+州
+巡
+巢
+工
+左
+巧
+巨
+巩
+巫
+差
+己
+已
+巳
+巴
+巷
+巻
+巽
+巾
+巿
+币
+市
+布
+帅
+帆
+师
+希
+帐
+帑
+帕
+帖
+帘
+帚
+帛
+帜
+帝
+帥
+带
+帧
+師
+席
+帮
+帯
+帰
+帳
+帶
+帷
+常
+帼
+帽
+幀
+幂
+幄
+幅
+幌
+幔
+幕
+幟
+幡
+幢
+幣
+幫
+干
+平
+年
+并
+幸
+幹
+幺
+幻
+幼
+幽
+幾
+广
+庁
+広
+庄
+庆
+庇
+床
+序
+庐
+库
+应
+底
+庖
+店
+庙
+庚
+府
+庞
+废
+庠
+度
+座
+庫
+庭
+庵
+庶
+康
+庸
+庹
+庾
+廁
+廂
+廃
+廈
+廉
+廊
+廓
+廖
+廚
+廝
+廟
+廠
+廢
+廣
+廬
+廳
+延
+廷
+建
+廿
+开
+弁
+异
+弃
+弄
+弈
+弊
+弋
+式
+弑
+弒
+弓
+弔
+引
+弗
+弘
+弛
+弟
+张
+弥
+弦
+弧
+弩
+弭
+弯
+弱
+張
+強
+弹
+强
+弼
+弾
+彅
+彆
+彈
+彌
+彎
+归
+当
+录
+彗
+彙
+彝
+形
+彤
+彥
+彦
+彧
+彩
+彪
+彫
+彬
+彭
+彰
+影
+彷
+役
+彻
+彼
+彿
+往
+征
+径
+待
+徇
+很
+徉
+徊
+律
+後
+徐
+徑
+徒
+従
+徕
+得
+徘
+徙
+徜
+從
+徠
+御
+徨
+復
+循
+徬
+微
+徳
+徴
+徵
+德
+徹
+徼
+徽
+心
+必
+忆
+忌
+忍
+忏
+忐
+忑
+忒
+忖
+志
+忘
+忙
+応
+忠
+忡
+忤
+忧
+忪
+快
+忱
+念
+忻
+忽
+忿
+怀
+态
+怂
+怅
+怆
+怎
+怏
+怒
+怔
+怕
+怖
+怙
+怜
+思
+怠
+怡
+急
+怦
+性
+怨
+怪
+怯
+怵
+总
+怼
+恁
+恃
+恆
+恋
+恍
+恐
+恒
+恕
+恙
+恚
+恢
+恣
+恤
+恥
+恨
+恩
+恪
+恫
+恬
+恭
+息
+恰
+恳
+恵
+恶
+恸
+恺
+恻
+恼
+恿
+悄
+悅
+悉
+悌
+悍
+悔
+悖
+悚
+悟
+悠
+患
+悦
+您
+悩
+悪
+悬
+悯
+悱
+悲
+悴
+悵
+悶
+悸
+悻
+悼
+悽
+情
+惆
+惇
+惊
+惋
+惑
+惕
+惘
+惚
+惜
+惟
+惠
+惡
+惦
+惧
+惨
+惩
+惫
+惬
+惭
+惮
+惯
+惰
+惱
+想
+惴
+惶
+惹
+惺
+愁
+愆
+愈
+愉
+愍
+意
+愕
+愚
+愛
+愜
+感
+愣
+愤
+愧
+愫
+愷
+愿
+慄
+慈
+態
+慌
+慎
+慑
+慕
+慘
+慚
+慟
+慢
+慣
+慧
+慨
+慫
+慮
+慰
+慳
+慵
+慶
+慷
+慾
+憂
+憊
+憋
+憎
+憐
+憑
+憔
+憚
+憤
+憧
+憨
+憩
+憫
+憬
+憲
+憶
+憾
+懂
+懇
+懈
+應
+懊
+懋
+懑
+懒
+懦
+懲
+懵
+懶
+懷
+懸
+懺
+懼
+懾
+懿
+戀
+戈
+戊
+戌
+戍
+戎
+戏
+成
+我
+戒
+戕
+或
+战
+戚
+戛
+戟
+戡
+戦
+截
+戬
+戮
+戰
+戲
+戳
+戴
+戶
+户
+戸
+戻
+戾
+房
+所
+扁
+扇
+扈
+扉
+手
+才
+扎
+扑
+扒
+打
+扔
+払
+托
+扛
+扣
+扦
+执
+扩
+扪
+扫
+扬
+扭
+扮
+扯
+扰
+扱
+扳
+扶
+批
+扼
+找
+承
+技
+抄
+抉
+把
+抑
+抒
+抓
+投
+抖
+抗
+折
+抚
+抛
+抜
+択
+抟
+抠
+抡
+抢
+护
+报
+抨
+披
+抬
+抱
+抵
+抹
+押
+抽
+抿
+拂
+拄
+担
+拆
+拇
+拈
+拉
+拋
+拌
+拍
+拎
+拐
+拒
+拓
+拔
+拖
+拗
+拘
+拙
+拚
+招
+拜
+拟
+拡
+拢
+拣
+拥
+拦
+拧
+拨
+择
+括
+拭
+拮
+拯
+拱
+拳
+拴
+拷
+拼
+拽
+拾
+拿
+持
+挂
+指
+挈
+按
+挎
+挑
+挖
+挙
+挚
+挛
+挝
+挞
+挟
+挠
+挡
+挣
+挤
+挥
+挨
+挪
+挫
+振
+挲
+挹
+挺
+挽
+挾
+捂
+捅
+捆
+捉
+捋
+捌
+捍
+捎
+捏
+捐
+捕
+捞
+损
+捡
+换
+捣
+捧
+捨
+捩
+据
+捱
+捲
+捶
+捷
+捺
+捻
+掀
+掂
+掃
+掇
+授
+掉
+掌
+掏
+掐
+排
+掖
+掘
+掙
+掛
+掠
+採
+探
+掣
+接
+控
+推
+掩
+措
+掬
+掰
+掲
+掳
+掴
+掷
+掸
+掺
+揀
+揃
+揄
+揆
+揉
+揍
+描
+提
+插
+揖
+揚
+換
+握
+揣
+揩
+揪
+揭
+揮
+援
+揶
+揸
+揹
+揽
+搀
+搁
+搂
+搅
+損
+搏
+搐
+搓
+搔
+搖
+搗
+搜
+搞
+搡
+搪
+搬
+搭
+搵
+搶
+携
+搽
+摀
+摁
+摄
+摆
+摇
+摈
+摊
+摒
+摔
+摘
+摞
+摟
+摧
+摩
+摯
+摳
+摸
+摹
+摺
+摻
+撂
+撃
+撅
+撇
+撈
+撐
+撑
+撒
+撓
+撕
+撚
+撞
+撤
+撥
+撩
+撫
+撬
+播
+撮
+撰
+撲
+撵
+撷
+撸
+撻
+撼
+撿
+擀
+擁
+擂
+擄
+擅
+擇
+擊
+擋
+操
+擎
+擒
+擔
+擘
+據
+擞
+擠
+擡
+擢
+擦
+擬
+擰
+擱
+擲
+擴
+擷
+擺
+擼
+擾
+攀
+攏
+攒
+攔
+攘
+攙
+攜
+攝
+攞
+攢
+攣
+攤
+攥
+攪
+攫
+攬
+支
+收
+攸
+改
+攻
+放
+政
+故
+效
+敌
+敍
+敎
+敏
+救
+敕
+敖
+敗
+敘
+教
+敛
+敝
+敞
+敢
+散
+敦
+敬
+数
+敲
+整
+敵
+敷
+數
+斂
+斃
+文
+斋
+斌
+斎
+斐
+斑
+斓
+斗
+料
+斛
+斜
+斟
+斡
+斤
+斥
+斧
+斩
+斫
+斬
+断
+斯
+新
+斷
+方
+於
+施
+旁
+旃
+旅
+旋
+旌
+旎
+族
+旖
+旗
+无
+既
+日
+旦
+旧
+旨
+早
+旬
+旭
+旮
+旱
+时
+旷
+旺
+旻
+昀
+昂
+昆
+昇
+昉
+昊
+昌
+明
+昏
+易
+昔
+昕
+昙
+星
+映
+春
+昧
+昨
+昭
+是
+昱
+昴
+昵
+昶
+昼
+显
+晁
+時
+晃
+晉
+晋
+晌
+晏
+晒
+晓
+晔
+晕
+晖
+晗
+晚
+晝
+晞
+晟
+晤
+晦
+晨
+晩
+普
+景
+晰
+晴
+晶
+晷
+智
+晾
+暂
+暄
+暇
+暈
+暉
+暌
+暐
+暑
+暖
+暗
+暝
+暢
+暧
+暨
+暫
+暮
+暱
+暴
+暸
+暹
+曄
+曆
+曇
+曉
+曖
+曙
+曜
+曝
+曠
+曦
+曬
+曰
+曲
+曳
+更
+書
+曹
+曼
+曾
+替
+最
+會
+月
+有
+朋
+服
+朐
+朔
+朕
+朗
+望
+朝
+期
+朦
+朧
+木
+未
+末
+本
+札
+朮
+术
+朱
+朴
+朵
+机
+朽
+杀
+杂
+权
+杆
+杈
+杉
+李
+杏
+材
+村
+杓
+杖
+杜
+杞
+束
+杠
+条
+来
+杨
+杭
+杯
+杰
+東
+杳
+杵
+杷
+杼
+松
+板
+极
+构
+枇
+枉
+枋
+析
+枕
+林
+枚
+果
+枝
+枢
+枣
+枪
+枫
+枭
+枯
+枰
+枱
+枳
+架
+枷
+枸
+柄
+柏
+某
+柑
+柒
+染
+柔
+柘
+柚
+柜
+柞
+柠
+柢
+查
+柩
+柬
+柯
+柱
+柳
+柴
+柵
+査
+柿
+栀
+栃
+栄
+栅
+标
+栈
+栉
+栋
+栎
+栏
+树
+栓
+栖
+栗
+校
+栩
+株
+样
+核
+根
+格
+栽
+栾
+桀
+桁
+桂
+桃
+桅
+框
+案
+桉
+桌
+桎
+桐
+桑
+桓
+桔
+桜
+桠
+桡
+桢
+档
+桥
+桦
+桧
+桨
+桩
+桶
+桿
+梁
+梅
+梆
+梏
+梓
+梗
+條
+梟
+梢
+梦
+梧
+梨
+梭
+梯
+械
+梳
+梵
+梶
+检
+棂
+棄
+棉
+棋
+棍
+棒
+棕
+棗
+棘
+棚
+棟
+棠
+棣
+棧
+森
+棱
+棲
+棵
+棹
+棺
+椁
+椅
+椋
+植
+椎
+椒
+検
+椪
+椭
+椰
+椹
+椽
+椿
+楂
+楊
+楓
+楔
+楚
+楝
+楞
+楠
+楣
+楨
+楫
+業
+楮
+極
+楷
+楸
+楹
+楼
+楽
+概
+榄
+榆
+榈
+榉
+榔
+榕
+榖
+榛
+榜
+榨
+榫
+榭
+榮
+榱
+榴
+榷
+榻
+槁
+槃
+構
+槌
+槍
+槎
+槐
+槓
+様
+槛
+槟
+槤
+槭
+槲
+槳
+槻
+槽
+槿
+樁
+樂
+樊
+樑
+樓
+標
+樞
+樟
+模
+樣
+権
+横
+樫
+樯
+樱
+樵
+樸
+樹
+樺
+樽
+樾
+橄
+橇
+橋
+橐
+橘
+橙
+機
+橡
+橢
+橫
+橱
+橹
+橼
+檀
+檄
+檎
+檐
+檔
+檗
+檜
+檢
+檬
+檯
+檳
+檸
+檻
+櫃
+櫚
+櫛
+櫥
+櫸
+櫻
+欄
+權
+欒
+欖
+欠
+次
+欢
+欣
+欧
+欲
+欸
+欺
+欽
+款
+歆
+歇
+歉
+歌
+歎
+歐
+歓
+歙
+歛
+歡
+止
+正
+此
+步
+武
+歧
+歩
+歪
+歯
+歲
+歳
+歴
+歷
+歸
+歹
+死
+歼
+殁
+殃
+殆
+殇
+殉
+殊
+残
+殒
+殓
+殖
+殘
+殞
+殡
+殤
+殭
+殯
+殲
+殴
+段
+殷
+殺
+殼
+殿
+毀
+毁
+毂
+毅
+毆
+毋
+母
+毎
+每
+毒
+毓
+比
+毕
+毗
+毘
+毙
+毛
+毡
+毫
+毯
+毽
+氈
+氏
+氐
+民
+氓
+气
+氖
+気
+氙
+氛
+氟
+氡
+氢
+氣
+氤
+氦
+氧
+氨
+氪
+氫
+氮
+氯
+氰
+氲
+水
+氷
+永
+氹
+氾
+汀
+汁
+求
+汆
+汇
+汉
+汎
+汐
+汕
+汗
+汙
+汛
+汝
+汞
+江
+池
+污
+汤
+汨
+汩
+汪
+汰
+汲
+汴
+汶
+汹
+決
+汽
+汾
+沁
+沂
+沃
+沅
+沈
+沉
+沌
+沏
+沐
+沒
+沓
+沖
+沙
+沛
+沟
+没
+沢
+沣
+沥
+沦
+沧
+沪
+沫
+沭
+沮
+沱
+河
+沸
+油
+治
+沼
+沽
+沾
+沿
+況
+泄
+泉
+泊
+泌
+泓
+法
+泗
+泛
+泞
+泠
+泡
+波
+泣
+泥
+注
+泪
+泫
+泮
+泯
+泰
+泱
+泳
+泵
+泷
+泸
+泻
+泼
+泽
+泾
+洁
+洄
+洋
+洒
+洗
+洙
+洛
+洞
+津
+洩
+洪
+洮
+洱
+洲
+洵
+洶
+洸
+洹
+活
+洼
+洽
+派
+流
+浃
+浄
+浅
+浆
+浇
+浊
+测
+济
+浏
+浑
+浒
+浓
+浔
+浙
+浚
+浜
+浣
+浦
+浩
+浪
+浬
+浮
+浯
+浴
+海
+浸
+涂
+涅
+涇
+消
+涉
+涌
+涎
+涓
+涔
+涕
+涙
+涛
+涝
+涞
+涟
+涠
+涡
+涣
+涤
+润
+涧
+涨
+涩
+涪
+涮
+涯
+液
+涵
+涸
+涼
+涿
+淀
+淄
+淅
+淆
+淇
+淋
+淌
+淑
+淒
+淖
+淘
+淙
+淚
+淞
+淡
+淤
+淦
+淨
+淩
+淪
+淫
+淬
+淮
+深
+淳
+淵
+混
+淹
+淺
+添
+淼
+清
+済
+渉
+渊
+渋
+渍
+渎
+渐
+渔
+渗
+渙
+渚
+減
+渝
+渠
+渡
+渣
+渤
+渥
+渦
+温
+測
+渭
+港
+渲
+渴
+游
+渺
+渾
+湃
+湄
+湊
+湍
+湖
+湘
+湛
+湟
+湧
+湫
+湮
+湯
+湳
+湾
+湿
+満
+溃
+溅
+溉
+溏
+源
+準
+溜
+溝
+溟
+溢
+溥
+溧
+溪
+溫
+溯
+溱
+溴
+溶
+溺
+溼
+滁
+滂
+滄
+滅
+滇
+滋
+滌
+滑
+滓
+滔
+滕
+滙
+滚
+滝
+滞
+滟
+满
+滢
+滤
+滥
+滦
+滨
+滩
+滬
+滯
+滲
+滴
+滷
+滸
+滾
+滿
+漁
+漂
+漆
+漉
+漏
+漓
+演
+漕
+漠
+漢
+漣
+漩
+漪
+漫
+漬
+漯
+漱
+漲
+漳
+漸
+漾
+漿
+潆
+潇
+潋
+潍
+潑
+潔
+潘
+潛
+潜
+潞
+潟
+潢
+潤
+潦
+潧
+潭
+潮
+潰
+潴
+潸
+潺
+潼
+澀
+澄
+澆
+澈
+澍
+澎
+澗
+澜
+澡
+澤
+澧
+澱
+澳
+澹
+激
+濁
+濂
+濃
+濑
+濒
+濕
+濘
+濛
+濟
+濠
+濡
+濤
+濫
+濬
+濮
+濯
+濱
+濺
+濾
+瀅
+瀆
+瀉
+瀋
+瀏
+瀑
+瀕
+瀘
+瀚
+瀛
+瀝
+瀞
+瀟
+瀧
+瀨
+瀬
+瀰
+瀾
+灌
+灏
+灑
+灘
+灝
+灞
+灣
+火
+灬
+灭
+灯
+灰
+灵
+灶
+灸
+灼
+災
+灾
+灿
+炀
+炁
+炅
+炉
+炊
+炎
+炒
+炔
+炕
+炖
+炙
+炜
+炫
+炬
+炭
+炮
+炯
+炳
+炷
+炸
+点
+為
+炼
+炽
+烁
+烂
+烃
+烈
+烊
+烏
+烘
+烙
+烛
+烟
+烤
+烦
+烧
+烨
+烩
+烫
+烬
+热
+烯
+烷
+烹
+烽
+焉
+焊
+焕
+焖
+焗
+焘
+焙
+焚
+焜
+無
+焦
+焯
+焰
+焱
+然
+焼
+煅
+煉
+煊
+煌
+煎
+煒
+煖
+煙
+煜
+煞
+煤
+煥
+煦
+照
+煨
+煩
+煮
+煲
+煸
+煽
+熄
+熊
+熏
+熒
+熔
+熙
+熟
+熠
+熨
+熬
+熱
+熵
+熹
+熾
+燁
+燃
+燄
+燈
+燉
+燊
+燎
+燒
+燔
+燕
+燙
+燜
+營
+燥
+燦
+燧
+燭
+燮
+燴
+燻
+燼
+燿
+爆
+爍
+爐
+爛
+爪
+爬
+爭
+爰
+爱
+爲
+爵
+父
+爷
+爸
+爹
+爺
+爻
+爽
+爾
+牆
+片
+版
+牌
+牍
+牒
+牙
+牛
+牝
+牟
+牠
+牡
+牢
+牦
+牧
+物
+牯
+牲
+牴
+牵
+特
+牺
+牽
+犀
+犁
+犄
+犊
+犍
+犒
+犢
+犧
+犬
+犯
+状
+犷
+犸
+犹
+狀
+狂
+狄
+狈
+狎
+狐
+狒
+狗
+狙
+狞
+狠
+狡
+狩
+独
+狭
+狮
+狰
+狱
+狸
+狹
+狼
+狽
+猎
+猕
+猖
+猗
+猙
+猛
+猜
+猝
+猥
+猩
+猪
+猫
+猬
+献
+猴
+猶
+猷
+猾
+猿
+獄
+獅
+獎
+獐
+獒
+獗
+獠
+獣
+獨
+獭
+獰
+獲
+獵
+獷
+獸
+獺
+獻
+獼
+獾
+玄
+率
+玉
+王
+玑
+玖
+玛
+玟
+玠
+玥
+玩
+玫
+玮
+环
+现
+玲
+玳
+玷
+玺
+玻
+珀
+珂
+珅
+珈
+珉
+珊
+珍
+珏
+珐
+珑
+珙
+珞
+珠
+珣
+珥
+珩
+珪
+班
+珮
+珲
+珺
+現
+球
+琅
+理
+琇
+琉
+琊
+琍
+琏
+琐
+琛
+琢
+琥
+琦
+琨
+琪
+琬
+琮
+琰
+琲
+琳
+琴
+琵
+琶
+琺
+琼
+瑀
+瑁
+瑄
+瑋
+瑕
+瑗
+瑙
+瑚
+瑛
+瑜
+瑞
+瑟
+瑠
+瑣
+瑤
+瑩
+瑪
+瑯
+瑰
+瑶
+瑾
+璀
+璁
+璃
+璇
+璉
+璋
+璎
+璐
+璜
+璞
+璟
+璧
+璨
+環
+璽
+璿
+瓊
+瓏
+瓒
+瓜
+瓢
+瓣
+瓤
+瓦
+瓮
+瓯
+瓴
+瓶
+瓷
+甄
+甌
+甕
+甘
+甙
+甚
+甜
+生
+產
+産
+甥
+甦
+用
+甩
+甫
+甬
+甭
+甯
+田
+由
+甲
+申
+电
+男
+甸
+町
+画
+甾
+畀
+畅
+界
+畏
+畑
+畔
+留
+畜
+畝
+畢
+略
+畦
+番
+畫
+異
+畲
+畳
+畴
+當
+畸
+畹
+畿
+疆
+疇
+疊
+疏
+疑
+疔
+疖
+疗
+疙
+疚
+疝
+疟
+疡
+疣
+疤
+疥
+疫
+疮
+疯
+疱
+疲
+疳
+疵
+疸
+疹
+疼
+疽
+疾
+痂
+病
+症
+痈
+痉
+痊
+痍
+痒
+痔
+痕
+痘
+痙
+痛
+痞
+痠
+痢
+痣
+痤
+痧
+痨
+痪
+痫
+痰
+痱
+痴
+痹
+痺
+痼
+痿
+瘀
+瘁
+瘋
+瘍
+瘓
+瘘
+瘙
+瘟
+瘠
+瘡
+瘢
+瘤
+瘦
+瘧
+瘩
+瘪
+瘫
+瘴
+瘸
+瘾
+療
+癇
+癌
+癒
+癖
+癜
+癞
+癡
+癢
+癣
+癥
+癫
+癬
+癮
+癱
+癲
+癸
+発
+登
+發
+白
+百
+皂
+的
+皆
+皇
+皈
+皋
+皎
+皑
+皓
+皖
+皙
+皚
+皮
+皰
+皱
+皴
+皺
+皿
+盂
+盃
+盅
+盆
+盈
+益
+盎
+盏
+盐
+监
+盒
+盔
+盖
+盗
+盘
+盛
+盜
+盞
+盟
+盡
+監
+盤
+盥
+盧
+盪
+目
+盯
+盱
+盲
+直
+相
+盹
+盼
+盾
+省
+眈
+眉
+看
+県
+眙
+眞
+真
+眠
+眦
+眨
+眩
+眯
+眶
+眷
+眸
+眺
+眼
+眾
+着
+睁
+睇
+睏
+睐
+睑
+睛
+睜
+睞
+睡
+睢
+督
+睥
+睦
+睨
+睪
+睫
+睬
+睹
+睽
+睾
+睿
+瞄
+瞅
+瞇
+瞋
+瞌
+瞎
+瞑
+瞒
+瞓
+瞞
+瞟
+瞠
+瞥
+瞧
+瞩
+瞪
+瞬
+瞭
+瞰
+瞳
+瞻
+瞼
+瞿
+矇
+矍
+矗
+矚
+矛
+矜
+矢
+矣
+知
+矩
+矫
+短
+矮
+矯
+石
+矶
+矽
+矾
+矿
+码
+砂
+砌
+砍
+砒
+研
+砖
+砗
+砚
+砝
+砣
+砥
+砧
+砭
+砰
+砲
+破
+砷
+砸
+砺
+砼
+砾
+础
+硅
+硐
+硒
+硕
+硝
+硫
+硬
+确
+硯
+硼
+碁
+碇
+碉
+碌
+碍
+碎
+碑
+碓
+碗
+碘
+碚
+碛
+碟
+碣
+碧
+碩
+碰
+碱
+碳
+碴
+確
+碼
+碾
+磁
+磅
+磊
+磋
+磐
+磕
+磚
+磡
+磨
+磬
+磯
+磲
+磷
+磺
+礁
+礎
+礙
+礡
+礦
+礪
+礫
+礴
+示
+礼
+社
+祀
+祁
+祂
+祇
+祈
+祉
+祎
+祐
+祕
+祖
+祗
+祚
+祛
+祜
+祝
+神
+祟
+祠
+祢
+祥
+票
+祭
+祯
+祷
+祸
+祺
+祿
+禀
+禁
+禄
+禅
+禍
+禎
+福
+禛
+禦
+禧
+禪
+禮
+禱
+禹
+禺
+离
+禽
+禾
+禿
+秀
+私
+秃
+秆
+秉
+秋
+种
+科
+秒
+秘
+租
+秣
+秤
+秦
+秧
+秩
+秭
+积
+称
+秸
+移
+秽
+稀
+稅
+程
+稍
+税
+稔
+稗
+稚
+稜
+稞
+稟
+稠
+稣
+種
+稱
+稲
+稳
+稷
+稹
+稻
+稼
+稽
+稿
+穀
+穂
+穆
+穌
+積
+穎
+穗
+穢
+穩
+穫
+穴
+究
+穷
+穹
+空
+穿
+突
+窃
+窄
+窈
+窍
+窑
+窒
+窓
+窕
+窖
+窗
+窘
+窜
+窝
+窟
+窠
+窥
+窦
+窨
+窩
+窪
+窮
+窯
+窺
+窿
+竄
+竅
+竇
+竊
+立
+竖
+站
+竜
+竞
+竟
+章
+竣
+童
+竭
+端
+競
+竹
+竺
+竽
+竿
+笃
+笆
+笈
+笋
+笏
+笑
+笔
+笙
+笛
+笞
+笠
+符
+笨
+第
+笹
+笺
+笼
+筆
+等
+筊
+筋
+筍
+筏
+筐
+筑
+筒
+答
+策
+筛
+筝
+筠
+筱
+筲
+筵
+筷
+筹
+签
+简
+箇
+箋
+箍
+箏
+箐
+箔
+箕
+算
+箝
+管
+箩
+箫
+箭
+箱
+箴
+箸
+節
+篁
+範
+篆
+篇
+築
+篑
+篓
+篙
+篝
+篠
+篡
+篤
+篩
+篪
+篮
+篱
+篷
+簇
+簌
+簍
+簡
+簦
+簧
+簪
+簫
+簷
+簸
+簽
+簾
+簿
+籁
+籃
+籌
+籍
+籐
+籟
+籠
+籤
+籬
+籮
+籲
+米
+类
+籼
+籽
+粄
+粉
+粑
+粒
+粕
+粗
+粘
+粟
+粤
+粥
+粧
+粪
+粮
+粱
+粲
+粳
+粵
+粹
+粼
+粽
+精
+粿
+糅
+糊
+糍
+糕
+糖
+糗
+糙
+糜
+糞
+糟
+糠
+糧
+糬
+糯
+糰
+糸
+系
+糾
+紀
+紂
+約
+紅
+紉
+紊
+紋
+納
+紐
+紓
+純
+紗
+紘
+紙
+級
+紛
+紜
+素
+紡
+索
+紧
+紫
+紮
+累
+細
+紳
+紹
+紺
+終
+絃
+組
+絆
+経
+結
+絕
+絞
+絡
+絢
+給
+絨
+絮
+統
+絲
+絳
+絵
+絶
+絹
+綁
+綏
+綑
+經
+継
+続
+綜
+綠
+綢
+綦
+綫
+綬
+維
+綱
+網
+綴
+綵
+綸
+綺
+綻
+綽
+綾
+綿
+緊
+緋
+総
+緑
+緒
+緘
+線
+緝
+緞
+締
+緣
+編
+緩
+緬
+緯
+練
+緹
+緻
+縁
+縄
+縈
+縛
+縝
+縣
+縫
+縮
+縱
+縴
+縷
+總
+績
+繁
+繃
+繆
+繇
+繋
+織
+繕
+繚
+繞
+繡
+繩
+繪
+繫
+繭
+繳
+繹
+繼
+繽
+纂
+續
+纍
+纏
+纓
+纔
+纖
+纜
+纠
+红
+纣
+纤
+约
+级
+纨
+纪
+纫
+纬
+纭
+纯
+纰
+纱
+纲
+纳
+纵
+纶
+纷
+纸
+纹
+纺
+纽
+纾
+线
+绀
+练
+组
+绅
+细
+织
+终
+绊
+绍
+绎
+经
+绑
+绒
+结
+绔
+绕
+绘
+给
+绚
+绛
+络
+绝
+绞
+统
+绡
+绢
+绣
+绥
+绦
+继
+绩
+绪
+绫
+续
+绮
+绯
+绰
+绳
+维
+绵
+绶
+绷
+绸
+绻
+综
+绽
+绾
+绿
+缀
+缄
+缅
+缆
+缇
+缈
+缉
+缎
+缓
+缔
+缕
+编
+缘
+缙
+缚
+缜
+缝
+缠
+缢
+缤
+缥
+缨
+缩
+缪
+缭
+缮
+缰
+缱
+缴
+缸
+缺
+缽
+罂
+罄
+罌
+罐
+网
+罔
+罕
+罗
+罚
+罡
+罢
+罩
+罪
+置
+罰
+署
+罵
+罷
+罹
+羁
+羅
+羈
+羊
+羌
+美
+羔
+羚
+羞
+羟
+羡
+羣
+群
+羥
+羧
+羨
+義
+羯
+羲
+羸
+羹
+羽
+羿
+翁
+翅
+翊
+翌
+翎
+習
+翔
+翘
+翟
+翠
+翡
+翦
+翩
+翰
+翱
+翳
+翹
+翻
+翼
+耀
+老
+考
+耄
+者
+耆
+耋
+而
+耍
+耐
+耒
+耕
+耗
+耘
+耙
+耦
+耨
+耳
+耶
+耷
+耸
+耻
+耽
+耿
+聂
+聆
+聊
+聋
+职
+聒
+联
+聖
+聘
+聚
+聞
+聪
+聯
+聰
+聲
+聳
+聴
+聶
+職
+聽
+聾
+聿
+肃
+肄
+肅
+肆
+肇
+肉
+肋
+肌
+肏
+肓
+肖
+肘
+肚
+肛
+肝
+肠
+股
+肢
+肤
+肥
+肩
+肪
+肮
+肯
+肱
+育
+肴
+肺
+肽
+肾
+肿
+胀
+胁
+胃
+胄
+胆
+背
+胍
+胎
+胖
+胚
+胛
+胜
+胝
+胞
+胡
+胤
+胥
+胧
+胫
+胭
+胯
+胰
+胱
+胳
+胴
+胶
+胸
+胺
+能
+脂
+脅
+脆
+脇
+脈
+脉
+脊
+脍
+脏
+脐
+脑
+脓
+脖
+脘
+脚
+脛
+脣
+脩
+脫
+脯
+脱
+脲
+脳
+脸
+脹
+脾
+腆
+腈
+腊
+腋
+腌
+腎
+腐
+腑
+腓
+腔
+腕
+腥
+腦
+腩
+腫
+腭
+腮
+腰
+腱
+腳
+腴
+腸
+腹
+腺
+腻
+腼
+腾
+腿
+膀
+膈
+膊
+膏
+膑
+膘
+膚
+膛
+膜
+膝
+膠
+膦
+膨
+膩
+膳
+膺
+膻
+膽
+膾
+膿
+臀
+臂
+臃
+臆
+臉
+臊
+臍
+臓
+臘
+臟
+臣
+臥
+臧
+臨
+自
+臬
+臭
+至
+致
+臺
+臻
+臼
+臾
+舀
+舂
+舅
+舆
+與
+興
+舉
+舊
+舌
+舍
+舎
+舐
+舒
+舔
+舖
+舗
+舛
+舜
+舞
+舟
+航
+舫
+般
+舰
+舱
+舵
+舶
+舷
+舸
+船
+舺
+舾
+艇
+艋
+艘
+艙
+艦
+艮
+良
+艰
+艱
+色
+艳
+艷
+艹
+艺
+艾
+节
+芃
+芈
+芊
+芋
+芍
+芎
+芒
+芙
+芜
+芝
+芡
+芥
+芦
+芩
+芪
+芫
+芬
+芭
+芮
+芯
+花
+芳
+芷
+芸
+芹
+芻
+芽
+芾
+苁
+苄
+苇
+苋
+苍
+苏
+苑
+苒
+苓
+苔
+苕
+苗
+苛
+苜
+苞
+苟
+苡
+苣
+若
+苦
+苫
+苯
+英
+苷
+苹
+苻
+茁
+茂
+范
+茄
+茅
+茉
+茎
+茏
+茗
+茜
+茧
+茨
+茫
+茬
+茭
+茯
+茱
+茲
+茴
+茵
+茶
+茸
+茹
+茼
+荀
+荃
+荆
+草
+荊
+荏
+荐
+荒
+荔
+荖
+荘
+荚
+荞
+荟
+荠
+荡
+荣
+荤
+荥
+荧
+荨
+荪
+荫
+药
+荳
+荷
+荸
+荻
+荼
+荽
+莅
+莆
+莉
+莊
+莎
+莒
+莓
+莖
+莘
+莞
+莠
+莢
+莧
+莪
+莫
+莱
+莲
+莴
+获
+莹
+莺
+莽
+莿
+菀
+菁
+菅
+菇
+菈
+菊
+菌
+菏
+菓
+菖
+菘
+菜
+菟
+菠
+菡
+菩
+華
+菱
+菲
+菸
+菽
+萁
+萃
+萄
+萊
+萋
+萌
+萍
+萎
+萘
+萝
+萤
+营
+萦
+萧
+萨
+萩
+萬
+萱
+萵
+萸
+萼
+落
+葆
+葉
+著
+葚
+葛
+葡
+董
+葦
+葩
+葫
+葬
+葭
+葯
+葱
+葳
+葵
+葷
+葺
+蒂
+蒋
+蒐
+蒔
+蒙
+蒜
+蒞
+蒟
+蒡
+蒨
+蒲
+蒸
+蒹
+蒻
+蒼
+蒿
+蓁
+蓄
+蓆
+蓉
+蓋
+蓑
+蓓
+蓖
+蓝
+蓟
+蓦
+蓬
+蓮
+蓼
+蓿
+蔑
+蔓
+蔔
+蔗
+蔘
+蔚
+蔡
+蔣
+蔥
+蔫
+蔬
+蔭
+蔵
+蔷
+蔺
+蔻
+蔼
+蔽
+蕁
+蕃
+蕈
+蕉
+蕊
+蕎
+蕙
+蕤
+蕨
+蕩
+蕪
+蕭
+蕲
+蕴
+蕻
+蕾
+薄
+薅
+薇
+薈
+薊
+薏
+薑
+薔
+薙
+薛
+薦
+薨
+薩
+薪
+薬
+薯
+薰
+薹
+藉
+藍
+藏
+藐
+藓
+藕
+藜
+藝
+藤
+藥
+藩
+藹
+藻
+藿
+蘆
+蘇
+蘊
+蘋
+蘑
+蘚
+蘭
+蘸
+蘼
+蘿
+虎
+虏
+虐
+虑
+虔
+處
+虚
+虛
+虜
+虞
+號
+虢
+虧
+虫
+虬
+虱
+虹
+虻
+虽
+虾
+蚀
+蚁
+蚂
+蚊
+蚌
+蚓
+蚕
+蚜
+蚝
+蚣
+蚤
+蚩
+蚪
+蚯
+蚱
+蚵
+蛀
+蛆
+蛇
+蛊
+蛋
+蛎
+蛐
+蛔
+蛙
+蛛
+蛟
+蛤
+蛭
+蛮
+蛰
+蛳
+蛹
+蛻
+蛾
+蜀
+蜂
+蜃
+蜆
+蜇
+蜈
+蜊
+蜍
+蜒
+蜓
+蜕
+蜗
+蜘
+蜚
+蜜
+蜡
+蜢
+蜥
+蜱
+蜴
+蜷
+蜻
+蜿
+蝇
+蝈
+蝉
+蝌
+蝎
+蝕
+蝗
+蝙
+蝟
+蝠
+蝦
+蝨
+蝴
+蝶
+蝸
+蝼
+螂
+螃
+融
+螞
+螢
+螨
+螯
+螳
+螺
+蟀
+蟄
+蟆
+蟋
+蟎
+蟑
+蟒
+蟠
+蟬
+蟲
+蟹
+蟻
+蟾
+蠅
+蠍
+蠔
+蠕
+蠛
+蠟
+蠡
+蠢
+蠣
+蠱
+蠶
+蠹
+蠻
+血
+衄
+衅
+衆
+行
+衍
+術
+衔
+街
+衙
+衛
+衝
+衞
+衡
+衢
+衣
+补
+表
+衩
+衫
+衬
+衮
+衰
+衲
+衷
+衹
+衾
+衿
+袁
+袂
+袄
+袅
+袈
+袋
+袍
+袒
+袖
+袜
+袞
+袤
+袪
+被
+袭
+袱
+裁
+裂
+装
+裆
+裊
+裏
+裔
+裕
+裘
+裙
+補
+裝
+裟
+裡
+裤
+裨
+裱
+裳
+裴
+裸
+裹
+製
+裾
+褂
+複
+褐
+褒
+褓
+褔
+褚
+褥
+褪
+褫
+褲
+褶
+褻
+襁
+襄
+襟
+襠
+襪
+襬
+襯
+襲
+西
+要
+覃
+覆
+覇
+見
+規
+覓
+視
+覚
+覦
+覧
+親
+覬
+観
+覷
+覺
+覽
+觀
+见
+观
+规
+觅
+视
+览
+觉
+觊
+觎
+觐
+觑
+角
+觞
+解
+觥
+触
+觸
+言
+訂
+計
+訊
+討
+訓
+訕
+訖
+託
+記
+訛
+訝
+訟
+訣
+訥
+訪
+設
+許
+訳
+訴
+訶
+診
+註
+証
+詆
+詐
+詔
+評
+詛
+詞
+詠
+詡
+詢
+詣
+試
+詩
+詫
+詬
+詭
+詮
+詰
+話
+該
+詳
+詹
+詼
+誅
+誇
+誉
+誌
+認
+誓
+誕
+誘
+語
+誠
+誡
+誣
+誤
+誥
+誦
+誨
+說
+説
+読
+誰
+課
+誹
+誼
+調
+諄
+談
+請
+諏
+諒
+論
+諗
+諜
+諡
+諦
+諧
+諫
+諭
+諮
+諱
+諳
+諷
+諸
+諺
+諾
+謀
+謁
+謂
+謄
+謊
+謎
+謐
+謔
+謗
+謙
+講
+謝
+謠
+謨
+謬
+謹
+謾
+譁
+證
+譎
+譏
+識
+譙
+譚
+譜
+警
+譬
+譯
+議
+譲
+譴
+護
+譽
+讀
+變
+讓
+讚
+讞
+计
+订
+认
+讥
+讧
+讨
+让
+讪
+讫
+训
+议
+讯
+记
+讲
+讳
+讴
+讶
+讷
+许
+讹
+论
+讼
+讽
+设
+访
+诀
+证
+诃
+评
+诅
+识
+诈
+诉
+诊
+诋
+词
+诏
+译
+试
+诗
+诘
+诙
+诚
+诛
+话
+诞
+诟
+诠
+诡
+询
+诣
+诤
+该
+详
+诧
+诩
+诫
+诬
+语
+误
+诰
+诱
+诲
+说
+诵
+诶
+请
+诸
+诺
+读
+诽
+课
+诿
+谀
+谁
+调
+谄
+谅
+谆
+谈
+谊
+谋
+谌
+谍
+谎
+谏
+谐
+谑
+谒
+谓
+谔
+谕
+谗
+谘
+谙
+谚
+谛
+谜
+谟
+谢
+谣
+谤
+谥
+谦
+谧
+谨
+谩
+谪
+谬
+谭
+谯
+谱
+谲
+谴
+谶
+谷
+豁
+豆
+豇
+豈
+豉
+豊
+豌
+豎
+豐
+豔
+豚
+象
+豢
+豪
+豫
+豬
+豹
+豺
+貂
+貅
+貌
+貓
+貔
+貘
+貝
+貞
+負
+財
+貢
+貧
+貨
+販
+貪
+貫
+責
+貯
+貰
+貳
+貴
+貶
+買
+貸
+費
+貼
+貽
+貿
+賀
+賁
+賂
+賃
+賄
+資
+賈
+賊
+賑
+賓
+賜
+賞
+賠
+賡
+賢
+賣
+賤
+賦
+質
+賬
+賭
+賴
+賺
+購
+賽
+贅
+贈
+贊
+贍
+贏
+贓
+贖
+贛
+贝
+贞
+负
+贡
+财
+责
+贤
+败
+账
+货
+质
+贩
+贪
+贫
+贬
+购
+贮
+贯
+贰
+贱
+贲
+贴
+贵
+贷
+贸
+费
+贺
+贻
+贼
+贾
+贿
+赁
+赂
+赃
+资
+赅
+赈
+赊
+赋
+赌
+赎
+赏
+赐
+赓
+赔
+赖
+赘
+赚
+赛
+赝
+赞
+赠
+赡
+赢
+赣
+赤
+赦
+赧
+赫
+赭
+走
+赳
+赴
+赵
+赶
+起
+趁
+超
+越
+趋
+趕
+趙
+趟
+趣
+趨
+足
+趴
+趵
+趸
+趺
+趾
+跃
+跄
+跆
+跋
+跌
+跎
+跑
+跖
+跚
+跛
+距
+跟
+跡
+跤
+跨
+跩
+跪
+路
+跳
+践
+跷
+跹
+跺
+跻
+踉
+踊
+踌
+踏
+踐
+踝
+踞
+踟
+踢
+踩
+踪
+踮
+踱
+踴
+踵
+踹
+蹂
+蹄
+蹇
+蹈
+蹉
+蹊
+蹋
+蹑
+蹒
+蹙
+蹟
+蹣
+蹤
+蹦
+蹩
+蹬
+蹭
+蹲
+蹴
+蹶
+蹺
+蹼
+蹿
+躁
+躇
+躉
+躊
+躋
+躍
+躏
+躪
+身
+躬
+躯
+躲
+躺
+軀
+車
+軋
+軌
+軍
+軒
+軟
+転
+軸
+軼
+軽
+軾
+較
+載
+輒
+輓
+輔
+輕
+輛
+輝
+輟
+輩
+輪
+輯
+輸
+輻
+輾
+輿
+轄
+轅
+轆
+轉
+轍
+轎
+轟
+车
+轧
+轨
+轩
+转
+轭
+轮
+软
+轰
+轲
+轴
+轶
+轻
+轼
+载
+轿
+较
+辄
+辅
+辆
+辇
+辈
+辉
+辊
+辍
+辐
+辑
+输
+辕
+辖
+辗
+辘
+辙
+辛
+辜
+辞
+辟
+辣
+辦
+辨
+辩
+辫
+辭
+辮
+辯
+辰
+辱
+農
+边
+辺
+辻
+込
+辽
+达
+迁
+迂
+迄
+迅
+过
+迈
+迎
+运
+近
+返
+还
+这
+进
+远
+违
+连
+迟
+迢
+迤
+迥
+迦
+迩
+迪
+迫
+迭
+述
+迴
+迷
+迸
+迹
+迺
+追
+退
+送
+适
+逃
+逅
+逆
+选
+逊
+逍
+透
+逐
+递
+途
+逕
+逗
+這
+通
+逛
+逝
+逞
+速
+造
+逢
+連
+逮
+週
+進
+逵
+逶
+逸
+逻
+逼
+逾
+遁
+遂
+遅
+遇
+遊
+運
+遍
+過
+遏
+遐
+遑
+遒
+道
+達
+違
+遗
+遙
+遛
+遜
+遞
+遠
+遢
+遣
+遥
+遨
+適
+遭
+遮
+遲
+遴
+遵
+遶
+遷
+選
+遺
+遼
+遽
+避
+邀
+邁
+邂
+邃
+還
+邇
+邈
+邊
+邋
+邏
+邑
+邓
+邕
+邛
+邝
+邢
+那
+邦
+邨
+邪
+邬
+邮
+邯
+邰
+邱
+邳
+邵
+邸
+邹
+邺
+邻
+郁
+郅
+郊
+郎
+郑
+郜
+郝
+郡
+郢
+郤
+郦
+郧
+部
+郫
+郭
+郴
+郵
+郷
+郸
+都
+鄂
+鄉
+鄒
+鄔
+鄙
+鄞
+鄢
+鄧
+鄭
+鄰
+鄱
+鄲
+鄺
+酉
+酊
+酋
+酌
+配
+酐
+酒
+酗
+酚
+酝
+酢
+酣
+酥
+酩
+酪
+酬
+酮
+酯
+酰
+酱
+酵
+酶
+酷
+酸
+酿
+醃
+醇
+醉
+醋
+醍
+醐
+醒
+醚
+醛
+醜
+醞
+醣
+醪
+醫
+醬
+醮
+醯
+醴
+醺
+釀
+釁
+采
+釉
+释
+釋
+里
+重
+野
+量
+釐
+金
+釗
+釘
+釜
+針
+釣
+釦
+釧
+釵
+鈀
+鈉
+鈍
+鈎
+鈔
+鈕
+鈞
+鈣
+鈦
+鈪
+鈴
+鈺
+鈾
+鉀
+鉄
+鉅
+鉉
+鉑
+鉗
+鉚
+鉛
+鉤
+鉴
+鉻
+銀
+銃
+銅
+銑
+銓
+銖
+銘
+銜
+銬
+銭
+銮
+銳
+銷
+銹
+鋁
+鋅
+鋒
+鋤
+鋪
+鋰
+鋸
+鋼
+錄
+錐
+錘
+錚
+錠
+錢
+錦
+錨
+錫
+錮
+錯
+録
+錳
+錶
+鍊
+鍋
+鍍
+鍛
+鍥
+鍰
+鍵
+鍺
+鍾
+鎂
+鎊
+鎌
+鎏
+鎔
+鎖
+鎗
+鎚
+鎧
+鎬
+鎮
+鎳
+鏈
+鏖
+鏗
+鏘
+鏞
+鏟
+鏡
+鏢
+鏤
+鏽
+鐘
+鐮
+鐲
+鐳
+鐵
+鐸
+鐺
+鑄
+鑊
+鑑
+鑒
+鑣
+鑫
+鑰
+鑲
+鑼
+鑽
+鑾
+鑿
+针
+钉
+钊
+钎
+钏
+钒
+钓
+钗
+钙
+钛
+钜
+钝
+钞
+钟
+钠
+钡
+钢
+钣
+钤
+钥
+钦
+钧
+钨
+钩
+钮
+钯
+钰
+钱
+钳
+钴
+钵
+钺
+钻
+钼
+钾
+钿
+铀
+铁
+铂
+铃
+铄
+铅
+铆
+铉
+铎
+铐
+铛
+铜
+铝
+铠
+铡
+铢
+铣
+铤
+铨
+铩
+铬
+铭
+铮
+铰
+铲
+铵
+银
+铸
+铺
+链
+铿
+销
+锁
+锂
+锄
+锅
+锆
+锈
+锉
+锋
+锌
+锏
+锐
+锑
+错
+锚
+锟
+锡
+锢
+锣
+锤
+锥
+锦
+锭
+键
+锯
+锰
+锲
+锵
+锹
+锺
+锻
+镀
+镁
+镂
+镇
+镉
+镌
+镍
+镐
+镑
+镕
+镖
+镗
+镛
+镜
+镣
+镭
+镯
+镰
+镳
+镶
+長
+长
+門
+閃
+閉
+開
+閎
+閏
+閑
+閒
+間
+閔
+閘
+閡
+関
+閣
+閥
+閨
+閩
+閱
+閲
+閹
+閻
+閾
+闆
+闇
+闊
+闌
+闍
+闔
+闕
+闖
+闘
+關
+闡
+闢
+门
+闪
+闫
+闭
+问
+闯
+闰
+闲
+间
+闵
+闷
+闸
+闹
+闺
+闻
+闽
+闾
+阀
+阁
+阂
+阅
+阆
+阇
+阈
+阉
+阎
+阐
+阑
+阔
+阕
+阖
+阙
+阚
+阜
+队
+阡
+阪
+阮
+阱
+防
+阳
+阴
+阵
+阶
+阻
+阿
+陀
+陂
+附
+际
+陆
+陇
+陈
+陋
+陌
+降
+限
+陕
+陛
+陝
+陞
+陟
+陡
+院
+陣
+除
+陨
+险
+陪
+陰
+陲
+陳
+陵
+陶
+陷
+陸
+険
+陽
+隅
+隆
+隈
+隊
+隋
+隍
+階
+随
+隐
+隔
+隕
+隘
+隙
+際
+障
+隠
+隣
+隧
+隨
+險
+隱
+隴
+隶
+隸
+隻
+隼
+隽
+难
+雀
+雁
+雄
+雅
+集
+雇
+雉
+雋
+雌
+雍
+雎
+雏
+雑
+雒
+雕
+雖
+雙
+雛
+雜
+雞
+離
+難
+雨
+雪
+雯
+雰
+雲
+雳
+零
+雷
+雹
+電
+雾
+需
+霁
+霄
+霆
+震
+霈
+霉
+霊
+霍
+霎
+霏
+霑
+霓
+霖
+霜
+霞
+霧
+霭
+霰
+露
+霸
+霹
+霽
+霾
+靂
+靄
+靈
+青
+靓
+靖
+静
+靚
+靛
+靜
+非
+靠
+靡
+面
+靥
+靦
+革
+靳
+靴
+靶
+靼
+鞅
+鞋
+鞍
+鞏
+鞑
+鞘
+鞠
+鞣
+鞦
+鞭
+韆
+韋
+韌
+韓
+韜
+韦
+韧
+韩
+韬
+韭
+音
+韵
+韶
+韻
+響
+頁
+頂
+頃
+項
+順
+須
+頌
+預
+頑
+頒
+頓
+頗
+領
+頜
+頡
+頤
+頫
+頭
+頰
+頷
+頸
+頹
+頻
+頼
+顆
+題
+額
+顎
+顏
+顔
+願
+顛
+類
+顧
+顫
+顯
+顱
+顴
+页
+顶
+顷
+项
+顺
+须
+顼
+顽
+顾
+顿
+颁
+颂
+预
+颅
+领
+颇
+颈
+颉
+颊
+颌
+颍
+颐
+频
+颓
+颔
+颖
+颗
+题
+颚
+颛
+颜
+额
+颞
+颠
+颡
+颢
+颤
+颦
+颧
+風
+颯
+颱
+颳
+颶
+颼
+飄
+飆
+风
+飒
+飓
+飕
+飘
+飙
+飚
+飛
+飞
+食
+飢
+飨
+飩
+飪
+飯
+飲
+飼
+飽
+飾
+餃
+餅
+餉
+養
+餌
+餐
+餒
+餓
+餘
+餚
+餛
+餞
+餡
+館
+餮
+餵
+餾
+饅
+饈
+饋
+饌
+饍
+饑
+饒
+饕
+饗
+饞
+饥
+饨
+饪
+饬
+饭
+饮
+饯
+饰
+饱
+饲
+饴
+饵
+饶
+饷
+饺
+饼
+饽
+饿
+馀
+馁
+馄
+馅
+馆
+馈
+馋
+馍
+馏
+馒
+馔
+首
+馗
+香
+馥
+馨
+馬
+馭
+馮
+馳
+馴
+駁
+駄
+駅
+駆
+駐
+駒
+駕
+駛
+駝
+駭
+駱
+駿
+騁
+騎
+騏
+験
+騙
+騨
+騰
+騷
+驀
+驅
+驊
+驍
+驒
+驕
+驗
+驚
+驛
+驟
+驢
+驥
+马
+驭
+驮
+驯
+驰
+驱
+驳
+驴
+驶
+驷
+驸
+驹
+驻
+驼
+驾
+驿
+骁
+骂
+骄
+骅
+骆
+骇
+骈
+骊
+骋
+验
+骏
+骐
+骑
+骗
+骚
+骛
+骜
+骞
+骠
+骡
+骤
+骥
+骧
+骨
+骯
+骰
+骶
+骷
+骸
+骼
+髂
+髅
+髋
+髏
+髒
+髓
+體
+髖
+高
+髦
+髪
+髮
+髯
+髻
+鬃
+鬆
+鬍
+鬓
+鬚
+鬟
+鬢
+鬣
+鬥
+鬧
+鬱
+鬼
+魁
+魂
+魄
+魅
+魇
+魍
+魏
+魔
+魘
+魚
+魯
+魷
+鮑
+鮨
+鮪
+鮭
+鮮
+鯉
+鯊
+鯖
+鯛
+鯨
+鯰
+鯽
+鰍
+鰓
+鰭
+鰲
+鰻
+鰾
+鱈
+鱉
+鱔
+鱗
+鱷
+鱸
+鱼
+鱿
+鲁
+鲈
+鲍
+鲑
+鲛
+鲜
+鲟
+鲢
+鲤
+鲨
+鲫
+鲱
+鲲
+鲶
+鲷
+鲸
+鳃
+鳄
+鳅
+鳌
+鳍
+鳕
+鳖
+鳗
+鳝
+鳞
+鳥
+鳩
+鳳
+鳴
+鳶
+鴉
+鴕
+鴛
+鴦
+鴨
+鴻
+鴿
+鵑
+鵜
+鵝
+鵡
+鵬
+鵰
+鵲
+鶘
+鶩
+鶯
+鶴
+鷗
+鷲
+鷹
+鷺
+鸚
+鸞
+鸟
+鸠
+鸡
+鸢
+鸣
+鸥
+鸦
+鸨
+鸪
+鸭
+鸯
+鸳
+鸵
+鸽
+鸾
+鸿
+鹂
+鹃
+鹄
+鹅
+鹈
+鹉
+鹊
+鹌
+鹏
+鹑
+鹕
+鹘
+鹜
+鹞
+鹤
+鹦
+鹧
+鹫
+鹭
+鹰
+鹳
+鹵
+鹹
+鹼
+鹽
+鹿
+麂
+麋
+麒
+麓
+麗
+麝
+麟
+麥
+麦
+麩
+麴
+麵
+麸
+麺
+麻
+麼
+麽
+麾
+黃
+黄
+黍
+黎
+黏
+黑
+黒
+黔
+默
+黛
+黜
+黝
+點
+黠
+黨
+黯
+黴
+鼋
+鼎
+鼐
+鼓
+鼠
+鼬
+鼹
+鼻
+鼾
+齁
+齊
+齋
+齐
+齒
+齡
+齢
+齣
+齦
+齿
+龄
+龅
+龈
+龊
+龋
+龌
+龍
+龐
+龔
+龕
+龙
+龚
+龛
+龜
+龟
+︰
+︱
+︶
+︿
+﹁
+﹂
+﹍
+﹏
+﹐
+﹑
+﹒
+﹔
+﹕
+﹖
+﹗
+﹙
+﹚
+﹝
+﹞
+﹡
+﹣
+!
+"
+#
+$
+%
+&
+'
+(
+)
+*
++
+,
+-
+.
+/
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+:
+;
+<
+=
+>
+?
+@
+[
+\
+]
+^
+_
+`
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
+{
+|
+}
+~
+。
+「
+」
+、
+・
+ッ
+ー
+イ
+ク
+シ
+ス
+ト
+ノ
+フ
+ラ
+ル
+ン
+゙
+゚
+ ̄
+¥
+👍
+🔥
+😂
+😎
+...
+yam
+10
+2017
+12
+11
+2016
+20
+30
+15
+06
+lofter
+##s
+2015
+by
+16
+14
+18
+13
+24
+17
+2014
+21
+##0
+22
+19
+25
+23
+com
+100
+00
+05
+2013
+##a
+03
+09
+08
+28
+##2
+50
+01
+04
+##1
+27
+02
+2012
+##3
+26
+##e
+07
+##8
+##5
+##6
+##4
+##9
+##7
+29
+2011
+40
+##t
+2010
+##o
+##d
+##i
+2009
+##n
+app
+www
+the
+##m
+31
+##c
+##l
+##y
+##r
+##g
+2008
+60
+http
+200
+qq
+##p
+80
+##f
+google
+pixnet
+90
+cookies
+tripadvisor
+500
+##er
+##k
+35
+##h
+facebook
+2007
+2000
+70
+##b
+of
+##x
+##u
+45
+300
+iphone
+32
+1000
+2006
+48
+ip
+36
+in
+38
+3d
+##w
+##ing
+55
+ctrip
+##on
+##v
+33
+##の
+to
+34
+400
+id
+2005
+it
+37
+windows
+llc
+top
+99
+42
+39
+000
+led
+at
+##an
+41
+51
+52
+46
+49
+43
+53
+44
+##z
+android
+58
+and
+59
+2004
+56
+vr
+##か
+5000
+2003
+47
+blogthis
+twitter
+54
+##le
+150
+ok
+2018
+57
+75
+cn
+no
+ios
+##in
+##mm
+##00
+800
+on
+te
+3000
+65
+2001
+360
+95
+ig
+lv
+120
+##ng
+##を
+##us
+##に
+pc
+てす
+──
+600
+##te
+85
+2002
+88
+##ed
+html
+ncc
+wifi
+email
+64
+blog
+is
+##10
+##て
+mail
+online
+##al
+dvd
+##ic
+studio
+##は
+##℃
+##ia
+##と
+line
+vip
+72
+##q
+98
+##ce
+##en
+for
+##is
+##ra
+##es
+##j
+usb
+net
+cp
+1999
+asia
+4g
+##cm
+diy
+new
+3c
+##お
+ta
+66
+language
+vs
+apple
+tw
+86
+web
+##ne
+ipad
+62
+you
+##re
+101
+68
+##tion
+ps
+de
+bt
+pony
+atm
+##2017
+1998
+67
+##ch
+ceo
+##or
+go
+##na
+av
+pro
+cafe
+96
+pinterest
+97
+63
+pixstyleme3c
+##ta
+more
+said
+##2016
+1997
+mp3
+700
+##ll
+nba
+jun
+##20
+92
+tv
+1995
+pm
+61
+76
+nbsp
+250
+##ie
+linux
+##ma
+cd
+110
+hd
+##17
+78
+##ion
+77
+6000
+am
+##th
+##st
+94
+##se
+##et
+69
+180
+gdp
+my
+105
+81
+abc
+89
+flash
+79
+one
+93
+1990
+1996
+##ck
+gps
+##も
+##ly
+web885
+106
+2020
+91
+##ge
+4000
+1500
+xd
+boss
+isbn
+1994
+org
+##ry
+me
+love
+##11
+0fork
+73
+##12
+3g
+##ter
+##ar
+71
+82
+##la
+hotel
+130
+1970
+pk
+83
+87
+140
+ie
+##os
+##30
+##el
+74
+##50
+seo
+cpu
+##ml
+p2p
+84
+may
+##る
+sun
+tue
+internet
+cc
+posted
+youtube
+##at
+##ン
+##man
+ii
+##ル
+##15
+abs
+nt
+pdf
+yahoo
+ago
+1980
+##it
+news
+mac
+104
+##てす
+##me
+##り
+java
+1992
+spa
+##de
+##nt
+hk
+all
+plus
+la
+1993
+##mb
+##16
+##ve
+west
+##da
+160
+air
+##い
+##ps
+から
+##to
+1989
+logo
+htc
+php
+https
+fi
+momo
+##son
+sat
+##ke
+##80
+ebd
+suv
+wi
+day
+apk
+##88
+##um
+mv
+galaxy
+wiki
+or
+brake
+##ス
+1200
+する
+this
+1991
+mon
+##こ
+❤2017
+po
+##ない
+javascript
+life
+home
+june
+##ss
+system
+900
+##ー
+##0
+pp
+1988
+world
+fb
+4k
+br
+##as
+ic
+ai
+leonardo
+safari
+##60
+live
+free
+xx
+wed
+win7
+kiehl
+##co
+lg
+o2o
+##go
+us
+235
+1949
+mm
+しい
+vfm
+kanye
+##90
+##2015
+##id
+jr
+##ey
+123
+rss
+##sa
+##ro
+##am
+##no
+thu
+fri
+350
+##sh
+##ki
+103
+comments
+name
+##のて
+##pe
+##ine
+max
+1987
+8000
+uber
+##mi
+##ton
+wordpress
+office
+1986
+1985
+##ment
+107
+bd
+win10
+##ld
+##li
+gmail
+bb
+dior
+##rs
+##ri
+##rd
+##ます
+up
+cad
+##®
+dr
+して
+read
+##21
+をお
+##io
+##99
+url
+1984
+pvc
+paypal
+show
+policy
+##40
+##ty
+##18
+with
+##★
+##01
+txt
+102
+##ba
+dna
+from
+post
+mini
+ar
+taiwan
+john
+##ga
+privacy
+agoda
+##13
+##ny
+word
+##24
+##22
+##by
+##ur
+##hz
+1982
+##ang
+265
+cookie
+netscape
+108
+##ka
+##~
+##ad
+house
+share
+note
+ibm
+code
+hello
+nike
+sim
+survey
+##016
+1979
+1950
+wikia
+##32
+##017
+5g
+cbc
+##tor
+##kg
+1983
+##rt
+##14
+campaign
+store
+2500
+os
+##ct
+##ts
+##°
+170
+api
+##ns
+365
+excel
+##な
+##ao
+##ら
+##し
+~~
+##nd
+university
+163
+には
+518
+##70
+##ya
+##il
+##25
+pierre
+ipo
+0020
+897
+##23
+hotels
+##ian
+のお
+125
+years
+6606
+##ers
+##26
+high
+##day
+time
+##ay
+bug
+##line
+##く
+##す
+##be
+xp
+talk2yam
+yamservice
+10000
+coco
+##dy
+sony
+##ies
+1978
+microsoft
+david
+people
+##ha
+1960
+instagram
+intel
+その
+##ot
+iso
+1981
+##va
+115
+##mo
+##land
+xxx
+man
+co
+ltxsw
+##ation
+baby
+220
+##pa
+##ol
+1945
+7000
+tag
+450
+##ue
+msn
+##31
+oppo
+##ト
+##ca
+control
+##om
+st
+chrome
+##ure
+##ん
+be
+##き
+lol
+##19
+した
+##bo
+240
+lady
+##100
+##way
+##から
+4600
+##ko
+##do
+##un
+4s
+corporation
+168
+##ni
+herme
+##28
+cp
+978
+##up
+##06
+ui
+##ds
+ppt
+admin
+three
+します
+bbc
+re
+128
+##48
+ca
+##015
+##35
+hp
+##ee
+tpp
+##た
+##ive
+××
+root
+##cc
+##ました
+##ble
+##ity
+adobe
+park
+114
+et
+oled
+city
+##ex
+##ler
+##ap
+china
+##book
+20000
+view
+##ice
+global
+##km
+your
+hong
+##mg
+out
+##ms
+ng
+ebay
+##29
+menu
+ubuntu
+##cy
+rom
+##view
+open
+ktv
+do
+server
+##lo
+if
+english
+##ね
+##5
+##oo
+1600
+##02
+step1
+kong
+club
+135
+july
+inc
+1976
+mr
+hi
+##net
+touch
+##ls
+##ii
+michael
+lcd
+##05
+##33
+phone
+james
+step2
+1300
+ios9
+##box
+dc
+##2
+##ley
+samsung
+111
+280
+pokemon
+css
+##ent
+##les
+いいえ
+##1
+s8
+atom
+play
+bmw
+##said
+sa
+etf
+ctrl
+♥yoyo♥
+##55
+2025
+##2014
+##66
+adidas
+amazon
+1958
+##ber
+##ner
+visa
+##77
+##der
+1800
+connectivity
+##hi
+firefox
+109
+118
+hr
+so
+style
+mark
+pop
+ol
+skip
+1975
+as
+##27
+##ir
+##61
+190
+mba
+##う
+##ai
+le
+##ver
+1900
+cafe2017
+lte
+super
+113
+129
+##ron
+amd
+like
+##☆
+are
+##ster
+we
+##sk
+paul
+data
+international
+##ft
+longchamp
+ssd
+good
+##ート
+##ti
+reply
+##my
+↓↓↓
+apr
+star
+##ker
+source
+136
+js
+112
+get
+force
+photo
+##one
+126
+##2013
+##ow
+link
+bbs
+1972
+goods
+##lin
+python
+119
+##ip
+game
+##ics
+##ません
+blue
+##●
+520
+##45
+page
+itunes
+##03
+1955
+260
+1968
+gt
+gif
+618
+##ff
+##47
+group
+くたさい
+about
+bar
+ganji
+##nce
+music
+lee
+not
+1977
+1971
+1973
+##per
+an
+faq
+comment
+##って
+days
+##ock
+116
+##bs
+1974
+1969
+v1
+player
+1956
+xbox
+sql
+fm
+f1
+139
+##ah
+210
+##lv
+##mp
+##000
+melody
+1957
+##3
+550
+17life
+199
+1966
+xml
+market
+##au
+##71
+999
+##04
+what
+gl
+##95
+##age
+tips
+##68
+book
+##ting
+mysql
+can
+1959
+230
+##ung
+wonderland
+watch
+10℃
+##ction
+9000
+mar
+mobile
+1946
+1962
+article
+##db
+part
+▲top
+party
+って
+1967
+1964
+1948
+##07
+##ore
+##op
+この
+dj
+##78
+##38
+010
+main
+225
+1965
+##ong
+art
+320
+ad
+134
+020
+##73
+117
+pm2
+japan
+228
+##08
+ts
+1963
+##ica
+der
+sm
+##36
+2019
+##wa
+ct
+##7
+##や
+##64
+1937
+homemesh
+search
+##85
+##れは
+##tv
+##di
+macbook
+##9
+##くたさい
+service
+##♥
+type
+った
+750
+##ier
+##si
+##75
+##います
+##ok
+best
+##ット
+goris
+lock
+##った
+cf
+3m
+big
+##ut
+ftp
+carol
+##vi
+10
+1961
+happy
+sd
+##ac
+122
+anti
+pe
+cnn
+iii
+1920
+138
+##ラ
+1940
+esp
+jan
+tags
+##98
+##51
+august
+vol
+##86
+154
+##™
+##fs
+##れ
+##sion
+design
+ac
+##ム
+press
+jordan
+ppp
+that
+key
+check
+##6
+##tt
+##㎡
+1080p
+##lt
+power
+##42
+1952
+##bc
+vivi
+##ック
+he
+133
+121
+jpg
+##rry
+201
+175
+3500
+1947
+nb
+##ted
+##rn
+しています
+1954
+usd
+##t00
+master
+##ンク
+001
+model
+##58
+al
+##09
+1953
+##34
+ram
+goo
+ても
+##ui
+127
+1930
+red
+##ary
+rpg
+item
+##pm
+##41
+270
+##za
+project
+##2012
+hot
+td
+blogabstract
+##ger
+##62
+650
+##44
+gr2
+##します
+##m
+black
+electronic
+nfc
+year
+asus
+また
+html5
+cindy
+##hd
+m3
+132
+esc
+##od
+booking
+##53
+fed
+tvb
+##81
+##ina
+mit
+165
+##いる
+chan
+192
+distribution
+next
+になる
+peter
+bios
+steam
+cm
+1941
+にも
+pk10
+##ix
+##65
+##91
+dec
+nasa
+##ana
+icecat
+00z
+b1
+will
+##46
+li
+se
+##ji
+##み
+##ard
+oct
+##ain
+jp
+##ze
+##bi
+cio
+##56
+smart
+h5
+##39
+##port
+curve
+vpn
+##nm
+##dia
+utc
+##あり
+12345678910
+##52
+rmvb
+chanel
+a4
+miss
+##and
+##im
+media
+who
+##63
+she
+girl
+5s
+124
+vera
+##して
+class
+vivo
+king
+##フ
+##ei
+national
+ab
+1951
+5cm
+888
+145
+ipod
+ap
+1100
+5mm
+211
+ms
+2756
+##69
+mp4
+msci
+##po
+##89
+131
+mg
+index
+380
+##bit
+##out
+##zz
+##97
+##67
+158
+apec
+##8
+photoshop
+opec
+¥799
+ては
+##96
+##tes
+##ast
+2g
+○○
+##ール
+¥2899
+##ling
+##よ
+##ory
+1938
+##ical
+kitty
+content
+##43
+step3
+##cn
+win8
+155
+vc
+1400
+iphone7
+robert
+##した
+tcl
+137
+beauty
+##87
+en
+dollars
+##ys
+##oc
+step
+pay
+yy
+a1
+##2011
+##lly
+##ks
+##♪
+1939
+188
+download
+1944
+sep
+exe
+ph
+います
+school
+gb
+center
+pr
+street
+##board
+uv
+##37
+##lan
+winrar
+##que
+##ua
+##com
+1942
+1936
+480
+gpu
+##4
+ettoday
+fu
+tom
+##54
+##ren
+##via
+149
+##72
+b2b
+144
+##79
+##tch
+rose
+arm
+mb
+##49
+##ial
+##nn
+nvidia
+step4
+mvp
+00㎡
+york
+156
+##イ
+how
+cpi
+591
+2765
+gov
+kg
+joe
+##xx
+mandy
+pa
+##ser
+copyright
+fashion
+1935
+don
+##け
+ecu
+##ist
+##art
+erp
+wap
+have
+##lm
+talk
+##ek
+##ning
+##if
+ch
+##ite
+video
+1943
+cs
+san
+iot
+look
+##84
+##2010
+##ku
+october
+##ux
+trump
+##hs
+##ide
+box
+141
+first
+##ins
+april
+##ight
+##83
+185
+angel
+protected
+aa
+151
+162
+x1
+m2
+##fe
+##×
+##ho
+size
+143
+min
+ofo
+fun
+gomaji
+ex
+hdmi
+food
+dns
+march
+chris
+kevin
+##のか
+##lla
+##pp
+##ec
+ag
+ems
+6s
+720p
+##rm
+##ham
+off
+##92
+asp
+team
+fandom
+ed
+299
+▌♥
+##ell
+info
+されています
+##82
+sina
+4066
+161
+##able
+##ctor
+330
+399
+315
+dll
+rights
+ltd
+idc
+jul
+3kg
+1927
+142
+ma
+surface
+##76
+##ク
+~~~
+304
+mall
+eps
+146
+green
+##59
+map
+space
+donald
+v2
+sodu
+##light
+1931
+148
+1700
+まて
+310
+reserved
+htm
+##han
+##57
+2d
+178
+mod
+##ise
+##tions
+152
+ti
+##shi
+doc
+1933
+icp
+055
+wang
+##ram
+shopping
+aug
+##pi
+##well
+now
+wam
+b2
+からお
+##hu
+236
+1928
+##gb
+266
+f2
+##93
+153
+mix
+##ef
+##uan
+bwl
+##plus
+##res
+core
+##ess
+tea
+5℃
+hktvmall
+nhk
+##ate
+list
+##ese
+301
+feb
+4m
+inn
+ての
+nov
+159
+12345
+daniel
+##ci
+pass
+##bet
+##nk
+coffee
+202
+ssl
+airbnb
+##ute
+fbi
+woshipm
+skype
+ea
+cg
+sp
+##fc
+##www
+yes
+edge
+alt
+007
+##94
+fpga
+##ght
+##gs
+iso9001
+さい
+##ile
+##wood
+##uo
+image
+lin
+icon
+american
+##em
+1932
+set
+says
+##king
+##tive
+blogger
+##74
+なと
+256
+147
+##ox
+##zy
+##red
+##ium
+##lf
+nokia
+claire
+##リ
+##ding
+november
+lohas
+##500
+##tic
+##マ
+##cs
+##ある
+##che
+##ire
+##gy
+##ult
+db
+january
+win
+##カ
+166
+road
+ptt
+##ま
+##つ
+198
+##fa
+##mer
+anna
+pchome
+はい
+udn
+ef
+420
+##time
+##tte
+2030
+##ア
+g20
+white
+かかります
+1929
+308
+garden
+eleven
+di
+##おります
+chen
+309b
+777
+172
+young
+cosplay
+ちてない
+4500
+bat
+##123
+##tra
+##ては
+kindle
+npc
+steve
+etc
+##ern
+##|
+call
+xperia
+ces
+travel
+sk
+s7
+##ous
+1934
+##int
+みいたたけます
+183
+edu
+file
+cho
+qr
+##car
+##our
+186
+##ant
+##d
+eric
+1914
+rends
+##jo
+##する
+mastercard
+##2000
+kb
+##min
+290
+##ino
+vista
+##ris
+##ud
+jack
+2400
+##set
+169
+pos
+1912
+##her
+##ou
+taipei
+しく
+205
+beta
+##ませんか
+232
+##fi
+express
+255
+body
+##ill
+aphojoy
+user
+december
+meiki
+##ick
+tweet
+richard
+##av
+##ᆫ
+iphone6
+##dd
+ちてすか
+views
+##mark
+321
+pd
+##00
+times
+##▲
+level
+##ash
+10g
+point
+5l
+##ome
+208
+koreanmall
+##ak
+george
+q2
+206
+wma
+tcp
+##200
+スタッフ
+full
+mlb
+##lle
+##watch
+tm
+run
+179
+911
+smith
+business
+##und
+1919
+color
+##tal
+222
+171
+##less
+moon
+4399
+##rl
+update
+pcb
+shop
+499
+157
+little
+なし
+end
+##mhz
+van
+dsp
+easy
+660
+##house
+##key
+history
+##o
+oh
+##001
+##hy
+##web
+oem
+let
+was
+##2009
+##gg
+review
+##wan
+182
+##°c
+203
+uc
+title
+##val
+united
+233
+2021
+##ons
+doi
+trivago
+overdope
+sbs
+##ance
+##ち
+grand
+special
+573032185
+imf
+216
+wx17house
+##so
+##ーム
+audi
+##he
+london
+william
+##rp
+##ake
+science
+beach
+cfa
+amp
+ps4
+880
+##800
+##link
+##hp
+crm
+ferragamo
+bell
+make
+##eng
+195
+under
+zh
+photos
+2300
+##style
+##ント
+via
+176
+da
+##gi
+company
+i7
+##ray
+thomas
+370
+ufo
+i5
+##max
+plc
+ben
+back
+research
+8g
+173
+mike
+##pc
+##ッフ
+september
+189
+##ace
+vps
+february
+167
+pantos
+wp
+lisa
+1921
+★★
+jquery
+night
+long
+offer
+##berg
+##news
+1911
+##いて
+ray
+fks
+wto
+せます
+over
+164
+340
+##all
+##rus
+1924
+##888
+##works
+blogtitle
+loftpermalink
+##→
+187
+martin
+test
+ling
+km
+##め
+15000
+fda
+v3
+##ja
+##ロ
+wedding
+かある
+outlet
+family
+##ea
+をこ
+##top
+story
+##ness
+salvatore
+##lu
+204
+swift
+215
+room
+している
+oracle
+##ul
+1925
+sam
+b2c
+week
+pi
+rock
+##のは
+##a
+##けと
+##ean
+##300
+##gle
+cctv
+after
+chinese
+##back
+powered
+x2
+##tan
+1918
+##nes
+##イン
+canon
+only
+181
+##zi
+##las
+say
+##oe
+184
+##sd
+221
+##bot
+##world
+##zo
+sky
+made
+top100
+just
+1926
+pmi
+802
+234
+gap
+##vr
+177
+les
+174
+▲topoct
+ball
+vogue
+vi
+ing
+ofweek
+cos
+##list
+##ort
+▲topmay
+##なら
+##lon
+として
+last
+##tc
+##of
+##bus
+##gen
+real
+eva
+##コ
+a3
+nas
+##lie
+##ria
+##coin
+##bt
+▲topapr
+his
+212
+cat
+nata
+vive
+health
+⋯⋯
+drive
+sir
+▲topmar
+du
+cup
+##カー
+##ook
+##よう
+##sy
+alex
+msg
+tour
+しました
+3ce
+##word
+193
+ebooks
+r8
+block
+318
+##より
+2200
+nice
+pvp
+207
+months
+1905
+rewards
+##ther
+1917
+0800
+##xi
+##チ
+##sc
+micro
+850
+gg
+blogfp
+op
+1922
+daily
+m1
+264
+true
+##bb
+ml
+##tar
+##のお
+##ky
+anthony
+196
+253
+##yo
+state
+218
+##ara
+##aa
+##rc
+##tz
+##ston
+より
+gear
+##eo
+##ade
+ge
+see
+1923
+##win
+##ura
+ss
+heart
+##den
+##ita
+down
+##sm
+el
+png
+2100
+610
+rakuten
+whatsapp
+bay
+dream
+add
+##use
+680
+311
+pad
+gucci
+mpv
+##ode
+##fo
+island
+▲topjun
+##▼
+223
+jason
+214
+chicago
+##❤
+しの
+##hone
+io
+##れる
+##ことか
+sogo
+be2
+##ology
+990
+cloud
+vcd
+##con
+2~3
+##ford
+##joy
+##kb
+##こさいます
+##rade
+but
+##ach
+docker
+##ful
+rfid
+ul
+##ase
+hit
+ford
+##star
+580
+##○
+11
+a2
+sdk
+reading
+edited
+##are
+cmos
+##mc
+238
+siri
+light
+##ella
+##ため
+bloomberg
+##read
+pizza
+##ison
+jimmy
+##vm
+college
+node
+journal
+ba
+18k
+##play
+245
+##cer
+20
+magic
+##yu
+191
+jump
+288
+tt
+##ings
+asr
+##lia
+3200
+step5
+network
+##cd
+mc
+いします
+1234
+pixstyleme
+273
+##600
+2800
+money
+★★★★★
+1280
+12
+430
+bl
+みの
+act
+##tus
+tokyo
+##rial
+##life
+emba
+##ae
+saas
+tcs
+##rk
+##wang
+summer
+##sp
+ko
+##ving
+390
+premium
+##その
+netflix
+##ヒ
+uk
+mt
+##lton
+right
+frank
+two
+209
+える
+##ple
+##cal
+021
+##んな
+##sen
+##ville
+hold
+nexus
+dd
+##ius
+てお
+##mah
+##なく
+tila
+zero
+820
+ce
+##tin
+resort
+##ws
+charles
+old
+p10
+5d
+report
+##360
+##ru
+##には
+bus
+vans
+lt
+##est
+pv
+##レ
+links
+rebecca
+##ツ
+##dm
+azure
+##365
+きな
+limited
+bit
+4gb
+##mon
+1910
+moto
+##eam
+213
+1913
+var
+eos
+なとの
+226
+blogspot
+された
+699
+e3
+dos
+dm
+fc
+##ments
+##ik
+##kw
+boy
+##bin
+##ata
+960
+er
+##せ
+219
+##vin
+##tu
+##ula
+194
+##∥
+station
+##ろ
+##ature
+835
+files
+zara
+hdr
+top10
+nature
+950
+magazine
+s6
+marriott
+##シ
+avira
+case
+##っと
+tab
+##ran
+tony
+##home
+oculus
+im
+##ral
+jean
+saint
+cry
+307
+rosie
+##force
+##ini
+ice
+##bert
+のある
+##nder
+##mber
+pet
+2600
+##◆
+plurk
+▲topdec
+##sis
+00kg
+▲topnov
+720
+##ence
+tim
+##ω
+##nc
+##ても
+##name
+log
+ips
+great
+ikea
+malaysia
+unix
+##イト
+3600
+##ncy
+##nie
+12000
+akb48
+##ye
+##oid
+404
+##chi
+##いた
+oa
+xuehai
+##1000
+##orm
+##rf
+275
+さん
+##ware
+##リー
+980
+ho
+##pro
+text
+##era
+560
+bob
+227
+##ub
+##2008
+8891
+scp
+avi
+##zen
+2022
+mi
+wu
+museum
+qvod
+apache
+lake
+jcb
+▲topaug
+★★★
+ni
+##hr
+hill
+302
+ne
+weibo
+490
+ruby
+##ーシ
+##ヶ
+##row
+4d
+▲topjul
+iv
+##ish
+github
+306
+mate
+312
+##スト
+##lot
+##ane
+andrew
+のハイト
+##tina
+t1
+rf
+ed2k
+##vel
+##900
+way
+final
+りの
+ns
+5a
+705
+197
+##メ
+sweet
+bytes
+##ene
+▲topjan
+231
+##cker
+##2007
+##px
+100g
+topapp
+229
+helpapp
+rs
+low
+14k
+g4g
+care
+630
+ldquo
+あり
+##fork
+leave
+rm
+edition
+##gan
+##zon
+##qq
+▲topsep
+##google
+##ism
+gold
+224
+explorer
+##zer
+toyota
+category
+select
+visual
+##labels
+restaurant
+##md
+posts
+s1
+##ico
+もっと
+angelababy
+123456
+217
+sports
+s3
+mbc
+1915
+してくたさい
+shell
+x86
+candy
+##new
+kbs
+face
+xl
+470
+##here
+4a
+swissinfo
+v8
+▲topfeb
+dram
+##ual
+##vice
+3a
+##wer
+sport
+q1
+ios10
+public
+int
+card
+##c
+ep
+au
+rt
+##れた
+1080
+bill
+##mll
+kim
+30
+460
+wan
+##uk
+##ミ
+x3
+298
+0t
+scott
+##ming
+239
+e5
+##3d
+h7n9
+worldcat
+brown
+##あります
+##vo
+##led
+##580
+##ax
+249
+410
+##ert
+paris
+##~6
+polo
+925
+##lr
+599
+##ナ
+capital
+##hing
+bank
+cv
+1g
+##chat
+##s
+##たい
+adc
+##ule
+2m
+##e
+digital
+hotmail
+268
+##pad
+870
+bbq
+quot
+##ring
+before
+wali
+##まて
+mcu
+2k
+2b
+という
+costco
+316
+north
+333
+switch
+##city
+##p
+philips
+##mann
+management
+panasonic
+##cl
+##vd
+##ping
+##rge
+alice
+##lk
+##ましょう
+css3
+##ney
+vision
+alpha
+##ular
+##400
+##tter
+lz
+にお
+##ありません
+mode
+gre
+1916
+pci
+##tm
+237
+1~2
+##yan
+##そ
+について
+##let
+##キ
+work
+war
+coach
+ah
+mary
+##ᅵ
+huang
+##pt
+a8
+pt
+follow
+##berry
+1895
+##ew
+a5
+ghost
+##ション
+##wn
+##og
+south
+##code
+girls
+##rid
+action
+villa
+git
+r11
+table
+games
+##cket
+error
+##anonymoussaid
+##ag
+here
+##ame
+##gc
+qa
+##■
+##lis
+gmp
+##gin
+vmalife
+##cher
+yu
+wedding
+##tis
+demo
+dragon
+530
+soho
+social
+bye
+##rant
+river
+orz
+acer
+325
+##↑
+##ース
+##ats
+261
+del
+##ven
+440
+ups
+##ように
+##ター
+305
+value
+macd
+yougou
+##dn
+661
+##ano
+ll
+##urt
+##rent
+continue
+script
+##wen
+##ect
+paper
+263
+319
+shift
+##chel
+##フト
+##cat
+258
+x5
+fox
+243
+##さん
+car
+aaa
+##blog
+loading
+##yn
+##tp
+kuso
+799
+si
+sns
+イカせるテンマ
+ヒンクテンマ3
+rmb
+vdc
+forest
+central
+prime
+help
+ultra
+##rmb
+##ような
+241
+square
+688
+##しい
+のないフロクに
+##field
+##reen
+##ors
+##ju
+c1
+start
+510
+##air
+##map
+cdn
+##wo
+cba
+stephen
+m8
+100km
+##get
+opera
+##base
+##ood
+vsa
+com™
+##aw
+##ail
+251
+なのて
+count
+t2
+##ᅡ
+##een
+2700
+hop
+##gp
+vsc
+tree
+##eg
+##ose
+816
+285
+##ories
+##shop
+alphago
+v4
+1909
+simon
+##ᆼ
+fluke62max
+zip
+スホンサー
+##sta
+louis
+cr
+bas
+##~10
+bc
+##yer
+hadoop
+##ube
+##wi
+1906
+0755
+hola
+##low
+place
+centre
+5v
+d3
+##fer
+252
+##750
+##media
+281
+540
+0l
+exchange
+262
+series
+##ハー
+##san
+eb
+##bank
+##k
+q3
+##nge
+##mail
+take
+##lp
+259
+1888
+client
+east
+cache
+event
+vincent
+##ールを
+きを
+##nse
+sui
+855
+adchoice
+##и
+##stry
+##なたの
+246
+##zone
+ga
+apps
+sea
+##ab
+248
+cisco
+##タ
+##rner
+kymco
+##care
+dha
+##pu
+##yi
+minkoff
+royal
+p1
+への
+annie
+269
+collection
+kpi
+playstation
+257
+になります
+866
+bh
+##bar
+queen
+505
+radio
+1904
+andy
+armani
+##xy
+manager
+iherb
+##ery
+##share
+spring
+raid
+johnson
+1908
+##ob
+volvo
+hall
+##ball
+v6
+our
+taylor
+##hk
+bi
+242
+##cp
+kate
+bo
+water
+technology
+##rie
+サイトは
+277
+##ona
+##sl
+hpv
+303
+gtx
+hip
+rdquo
+jayz
+stone
+##lex
+##rum
+namespace
+##やり
+620
+##ale
+##atic
+des
+##erson
+##ql
+##ves
+##type
+enter
+##この
+##てきます
+d2
+##168
+##mix
+##bian
+との
+a9
+jj
+ky
+##lc
+access
+movie
+##hc
+リストに
+tower
+##ration
+##mit
+ます
+##nch
+ua
+tel
+prefix
+##o2
+1907
+##point
+1901
+ott
+~10
+##http
+##ury
+baidu
+##ink
+member
+##logy
+bigbang
+nownews
+##js
+##shot
+##tb
+##こと
+247
+eba
+##tics
+##lus
+ける
+v5
+spark
+##ama
+there
+##ions
+god
+##lls
+##down
+hiv
+##ress
+burberry
+day2
+##kv
+◆◆
+jeff
+related
+film
+edit
+joseph
+283
+##ark
+cx
+32gb
+order
+g9
+30000
+##ans
+##tty
+s5
+##bee
+かあります
+thread
+xr
+buy
+sh
+005
+land
+spotify
+mx
+##ari
+276
+##verse
+×email
+sf
+why
+##ことて
+244
+7headlines
+nego
+sunny
+dom
+exo
+401
+666
+positioning
+fit
+rgb
+##tton
+278
+kiss
+alexa
+adam
+lp
+みリストを
+##g
+mp
+##ties
+##llow
+amy
+##du
+np
+002
+institute
+271
+##rth
+##lar
+2345
+590
+##des
+sidebar
+15
+imax
+site
+##cky
+##kit
+##ime
+##009
+season
+323
+##fun
+##ンター
+##ひ
+gogoro
+a7
+pu
+lily
+fire
+twd600
+##ッセーシを
+いて
+##vis
+30ml
+##cture
+##をお
+information
+##オ
+close
+friday
+##くれる
+yi
+nick
+てすか
+##tta
+##tel
+6500
+##lock
+cbd
+economy
+254
+かお
+267
+tinker
+double
+375
+8gb
+voice
+##app
+oops
+channel
+today
+985
+##right
+raw
+xyz
+##+
+jim
+edm
+##cent
+7500
+supreme
+814
+ds
+##its
+##asia
+dropbox
+##てすか
+##tti
+books
+272
+100ml
+##tle
+##ller
+##ken
+##more
+##boy
+sex
+309
+##dom
+t3
+##ider
+##なります
+##unch
+1903
+810
+feel
+5500
+##かった
+##put
+により
+s2
+mo
+##gh
+men
+ka
+amoled
+div
+##tr
+##n1
+port
+howard
+##tags
+ken
+dnf
+##nus
+adsense
+##а
+ide
+##へ
+buff
+thunder
+##town
+##ique
+has
+##body
+auto
+pin
+##erry
+tee
+てした
+295
+number
+##the
+##013
+object
+psp
+cool
+udnbkk
+16gb
+##mic
+miui
+##tro
+most
+r2
+##alk
+##nity
+1880
+±0
+##いました
+428
+s4
+law
+version
+##oa
+n1
+sgs
+docomo
+##tf
+##ack
+henry
+fc2
+##ded
+##sco
+##014
+##rite
+286
+0mm
+linkedin
+##ada
+##now
+wii
+##ndy
+ucbug
+##◎
+sputniknews
+legalminer
+##ika
+##xp
+2gb
+##bu
+q10
+oo
+b6
+come
+##rman
+cheese
+ming
+maker
+##gm
+nikon
+##fig
+ppi
+kelly
+##ります
+jchere
+てきます
+ted
+md
+003
+fgo
+tech
+##tto
+dan
+soc
+##gl
+##len
+hair
+earth
+640
+521
+img
+##pper
+##a1
+##てきる
+##ロク
+acca
+##ition
+##ference
+suite
+##ig
+outlook
+##mond
+##cation
+398
+##pr
+279
+101vip
+358
+##999
+282
+64gb
+3800
+345
+airport
+##over
+284
+##おり
+jones
+##ith
+lab
+##su
+##いるのて
+co2
+town
+piece
+##llo
+no1
+vmware
+24h
+##qi
+focus
+reader
+##admin
+##ora
+tb
+false
+##log
+1898
+know
+lan
+838
+##ces
+f4
+##ume
+motel
+stop
+##oper
+na
+flickr
+netcomponents
+##af
+##─
+pose
+williams
+local
+##ound
+##cg
+##site
+##iko
+いお
+274
+5m
+gsm
+con
+##ath
+1902
+friends
+##hip
+cell
+317
+##rey
+780
+cream
+##cks
+012
+##dp
+facebooktwitterpinterestgoogle
+sso
+324
+shtml
+song
+swiss
+##mw
+##キンク
+lumia
+xdd
+string
+tiffany
+522
+marc
+られた
+insee
+russell
+sc
+dell
+##ations
+ok
+camera
+289
+##vs
+##flow
+##late
+classic
+287
+##nter
+stay
+g1
+mtv
+512
+##ever
+##lab
+##nger
+qe
+sata
+ryan
+d1
+50ml
+cms
+##cing
+su
+292
+3300
+editor
+296
+##nap
+security
+sunday
+association
+##ens
+##700
+##bra
+acg
+##かり
+sofascore
+とは
+mkv
+##ign
+jonathan
+gary
+build
+labels
+##oto
+tesla
+moba
+qi
+gohappy
+general
+ajax
+1024
+##かる
+サイト
+society
+##test
+##urs
+wps
+fedora
+##ich
+mozilla
+328
+##480
+##dr
+usa
+urn
+##lina
+##r
+grace
+##die
+##try
+##ader
+1250
+##なり
+elle
+570
+##chen
+##ᆯ
+price
+##ten
+uhz
+##ough
+eq
+##hen
+states
+push
+session
+balance
+wow
+506
+##cus
+##py
+when
+##ward
+##ep
+34e
+wong
+library
+prada
+##サイト
+##cle
+running
+##ree
+313
+ck
+date
+q4
+##ctive
+##ool
+##>
+mk
+##ira
+##163
+388
+die
+secret
+rq
+dota
+buffet
+は1ヶ
+e6
+##ez
+pan
+368
+ha
+##card
+##cha
+2a
+##さ
+alan
+day3
+eye
+f3
+##end
+france
+keep
+adi
+rna
+tvbs
+##ala
+solo
+nova
+##え
+##tail
+##ょう
+support
+##ries
+##なる
+##ved
+base
+copy
+iis
+fps
+##ways
+hero
+hgih
+profile
+fish
+mu
+ssh
+entertainment
+chang
+##wd
+click
+cake
+##ond
+pre
+##tom
+kic
+pixel
+##ov
+##fl
+product
+6a
+##pd
+dear
+##gate
+es
+yumi
+audio
+##²
+##sky
+echo
+bin
+where
+##ture
+329
+##ape
+find
+sap
+isis
+##なと
+nand
+##101
+##load
+##ream
+band
+a6
+525
+never
+##post
+festival
+50cm
+##we
+555
+guide
+314
+zenfone
+##ike
+335
+gd
+forum
+jessica
+strong
+alexander
+##ould
+software
+allen
+##ious
+program
+360°
+else
+lohasthree
+##gar
+することかてきます
+please
+##れます
+rc
+##ggle
+##ric
+bim
+50000
+##own
+eclipse
+355
+brian
+3ds
+##side
+061
+361
+##other
+##ける
+##tech
+##ator
+485
+engine
+##ged
+##t
+plaza
+##fit
+cia
+ngo
+westbrook
+shi
+tbs
+50mm
+##みませんか
+sci
+291
+reuters
+##ily
+contextlink
+##hn
+af
+##cil
+bridge
+very
+##cel
+1890
+cambridge
+##ize
+15g
+##aid
+##data
+790
+frm
+##head
+award
+butler
+##sun
+meta
+##mar
+america
+ps3
+puma
+pmid
+##すか
+lc
+670
+kitchen
+##lic
+オーフン5
+きなしソフトサーヒス
+そして
+day1
+future
+★★★★
+##text
+##page
+##rris
+pm1
+##ket
+fans
+##っています
+1001
+christian
+bot
+kids
+trackback
+##hai
+c3
+display
+##hl
+n2
+1896
+idea
+さんも
+##sent
+airmail
+##ug
+##men
+pwm
+けます
+028
+##lution
+369
+852
+awards
+schemas
+354
+asics
+wikipedia
+font
+##tional
+##vy
+c2
+293
+##れている
+##dget
+##ein
+っている
+contact
+pepper
+スキル
+339
+##~5
+294
+##uel
+##ument
+730
+##hang
+みてす
+q5
+##sue
+rain
+##ndi
+wei
+swatch
+##cept
+わせ
+331
+popular
+##ste
+##tag
+p2
+501
+trc
+1899
+##west
+##live
+justin
+honda
+ping
+messenger
+##rap
+v9
+543
+##とは
+unity
+appqq
+はすへて
+025
+leo
+##tone
+##テ
+##ass
+uniqlo
+##010
+502
+her
+jane
+memory
+moneydj
+##tical
+human
+12306
+していると
+##m2
+coc
+miacare
+##mn
+tmt
+##core
+vim
+kk
+##may
+fan
+target
+use
+too
+338
+435
+2050
+867
+737
+fast
+##2c
+services
+##ope
+omega
+energy
+##わ
+pinkoi
+1a
+##なから
+##rain
+jackson
+##ement
+##シャンルの
+374
+366
+そんな
+p9
+rd
+##ᆨ
+1111
+##tier
+##vic
+zone
+##│
+385
+690
+dl
+isofix
+cpa
+m4
+322
+kimi
+めて
+davis
+##lay
+lulu
+##uck
+050
+weeks
+qs
+##hop
+920
+##n
+ae
+##ear
+~5
+eia
+405
+##fly
+korea
+jpeg
+boost
+##ship
+small
+##リア
+1860
+eur
+297
+425
+valley
+##iel
+simple
+##ude
+rn
+k2
+##ena
+されます
+non
+patrick
+しているから
+##ナー
+feed
+5757
+30g
+process
+well
+qqmei
+##thing
+they
+aws
+lu
+pink
+##ters
+##kin
+または
+board
+##vertisement
+wine
+##ien
+unicode
+##dge
+r1
+359
+##tant
+いを
+##twitter
+##3c
+cool1
+される
+##れて
+##l
+isp
+##012
+standard
+45㎡2
+402
+##150
+matt
+##fu
+326
+##iner
+googlemsn
+pixnetfacebookyahoo
+##ラン
+x7
+886
+##uce
+メーカー
+sao
+##ev
+##きました
+##file
+9678
+403
+xddd
+shirt
+6l
+##rio
+##hat
+3mm
+givenchy
+ya
+bang
+##lio
+monday
+crystal
+ロクイン
+##abc
+336
+head
+890
+ubuntuforumwikilinuxpastechat
+##vc
+##~20
+##rity
+cnc
+7866
+ipv6
+null
+1897
+##ost
+yang
+imsean
+tiger
+##fet
+##ンス
+352
+##=
+dji
+327
+ji
+maria
+##come
+##んて
+foundation
+3100
+##beth
+##なった
+1m
+601
+active
+##aft
+##don
+3p
+sr
+349
+emma
+##khz
+living
+415
+353
+1889
+341
+709
+457
+sas
+x6
+##face
+pptv
+x4
+##mate
+han
+sophie
+##jing
+337
+fifa
+##mand
+other
+sale
+inwedding
+##gn
+てきちゃいます
+##mmy
+##pmlast
+bad
+nana
+nbc
+してみてくたさいね
+なとはお
+##wu
+##かあります
+##あ
+note7
+single
+##340
+せからこ
+してくたさい♪この
+しにはとんとんワークケートを
+するとあなたにもっとマッチした
+ならワークケートへ
+もみつかっちゃうかも
+ワークケートの
+##bel
+window
+##dio
+##ht
+union
+age
+382
+14
+##ivity
+##y
+コメント
+domain
+neo
+##isa
+##lter
+5k
+f5
+steven
+##cts
+powerpoint
+tft
+self
+g2
+ft
+##テル
+zol
+##act
+mwc
+381
+343
+もう
+nbapop
+408
+てある
+eds
+ace
+##room
+previous
+author
+tomtom
+il
+##ets
+hu
+financial
+☆☆☆
+っています
+bp
+5t
+chi
+1gb
+##hg
+fairmont
+cross
+008
+gay
+h2
+function
+##けて
+356
+also
+1b
+625
+##ータ
+##raph
+1894
+3~5
+##ils
+i3
+334
+avenue
+##host
+による
+##bon
+##tsu
+message
+navigation
+50g
+fintech
+h6
+##ことを
+8cm
+##ject
+##vas
+##firm
+credit
+##wf
+xxxx
+form
+##nor
+##space
+huawei
+plan
+json
+sbl
+##dc
+machine
+921
+392
+wish
+##120
+##sol
+windows7
+edward
+##ために
+development
+washington
+##nsis
+lo
+818
+##sio
+##ym
+##bor
+planet
+##~8
+##wt
+ieee
+gpa
+##めて
+camp
+ann
+gm
+##tw
+##oka
+connect
+##rss
+##work
+##atus
+wall
+chicken
+soul
+2mm
+##times
+fa
+##ather
+##cord
+009
+##eep
+hitachi
+gui
+harry
+##pan
+e1
+disney
+##press
+##ーション
+wind
+386
+frigidaire
+##tl
+liu
+hsu
+332
+basic
+von
+ev
+いた
+てきる
+スホンサーサイト
+learning
+##ull
+expedia
+archives
+change
+##wei
+santa
+cut
+ins
+6gb
+turbo
+brand
+cf1
+508
+004
+return
+747
+##rip
+h1
+##nis
+##をこ
+128gb
+##にお
+3t
+application
+しており
+emc
+rx
+##oon
+384
+quick
+412
+15058
+wilson
+wing
+chapter
+##bug
+beyond
+##cms
+##dar
+##oh
+zoom
+e2
+trip
+sb
+##nba
+rcep
+342
+aspx
+ci
+080
+gc
+gnu
+める
+##count
+advanced
+dance
+dv
+##url
+##ging
+367
+8591
+am09
+shadow
+battle
+346
+##i
+##cia
+##という
+emily
+##のてす
+##tation
+host
+ff
+techorz
+sars
+##mini
+##mporary
+##ering
+nc
+4200
+798
+##next
+cma
+##mbps
+##gas
+##ift
+##dot
+##ィ
+455
+##~17
+amana
+##りの
+426
+##ros
+ir
+00㎡1
+##eet
+##ible
+##↓
+710
+ˋ▽ˊ
+##aka
+dcs
+iq
+##v
+l1
+##lor
+maggie
+##011
+##iu
+588
+##~1
+830
+##gt
+1tb
+articles
+create
+##burg
+##iki
+database
+fantasy
+##rex
+##cam
+dlc
+dean
+##you
+hard
+path
+gaming
+victoria
+maps
+cb
+##lee
+##itor
+overchicstoretvhome
+systems
+##xt
+416
+p3
+sarah
+760
+##nan
+407
+486
+x9
+install
+second
+626
+##ann
+##ph
+##rcle
+##nic
+860
+##nar
+ec
+##とう
+768
+metro
+chocolate
+##rian
+~4
+##table
+##しています
+skin
+##sn
+395
+mountain
+##0mm
+inparadise
+6m
+7x24
+ib
+4800
+##jia
+eeworld
+creative
+g5
+g3
+357
+parker
+ecfa
+village
+からの
+18000
+sylvia
+サーヒス
+hbl
+##ques
+##onsored
+##x2
+##きます
+##v4
+##tein
+ie6
+383
+##stack
+389
+ver
+##ads
+##baby
+sound
+bbe
+##110
+##lone
+##uid
+ads
+022
+gundam
+351
+thinkpad
+006
+scrum
+match
+##ave
+mems
+##470
+##oy
+##なりました
+##talk
+glass
+lamigo
+span
+##eme
+job
+##a5
+jay
+wade
+kde
+498
+##lace
+ocean
+tvg
+##covery
+##r3
+##ners
+##rea
+junior
+think
+##aine
+cover
+##ision
+##sia
+↓↓
+##bow
+msi
+413
+458
+406
+##love
+711
+801
+soft
+z2
+##pl
+456
+1840
+mobil
+mind
+##uy
+427
+nginx
+##oi
+めた
+##rr
+6221
+##mple
+##sson
+##ーシてす
+371
+##nts
+91tv
+comhd
+crv3000
+##uard
+1868
+397
+deep
+lost
+field
+gallery
+##bia
+rate
+spf
+redis
+traction
+930
+icloud
+011
+なら
+fe
+jose
+372
+##tory
+into
+sohu
+fx
+899
+379
+kicstart2
+##hia
+すく
+##~3
+##sit
+ra
+24
+##walk
+##xure
+500g
+##pact
+pacific
+xa
+natural
+carlo
+##250
+##walker
+1850
+##can
+cto
+gigi
+516
+##サー
+pen
+##hoo
+ob
+matlab
+##b
+##yy
+13913459
+##iti
+mango
+##bbs
+sense
+c5
+oxford
+##ニア
+walker
+jennifer
+##ola
+course
+##bre
+701
+##pus
+##rder
+lucky
+075
+##ぁ
+ivy
+なお
+##nia
+sotheby
+side
+##ugh
+joy
+##orage
+##ush
+##bat
+##dt
+364
+r9
+##2d
+##gio
+511
+country
+wear
+##lax
+##~7
+##moon
+393
+seven
+study
+411
+348
+lonzo
+8k
+##ェ
+evolution
+##イフ
+##kk
+gs
+kd
+##レス
+arduino
+344
+b12
+##lux
+arpg
+##rdon
+cook
+##x5
+dark
+five
+##als
+##ida
+とても
+sign
+362
+##ちの
+something
+20mm
+##nda
+387
+##posted
+fresh
+tf
+1870
+422
+cam
+##mine
+##skip
+##form
+##ssion
+education
+394
+##tee
+dyson
+stage
+##jie
+want
+##night
+epson
+pack
+あります
+##ppy
+テリヘル
+##█
+wd
+##eh
+##rence
+left
+##lvin
+golden
+mhz
+discovery
+##trix
+##n2
+loft
+##uch
+##dra
+##sse
+speed
+~1
+1mdb
+sorry
+welcome
+##urn
+wave
+gaga
+##lmer
+teddy
+##160
+トラックハック
+せよ
+611
+##f2016
+378
+rp
+##sha
+rar
+##あなたに
+##きた
+840
+holiday
+##ュー
+373
+074
+##vg
+##nos
+##rail
+gartner
+gi
+6p
+##dium
+kit
+488
+b3
+eco
+##ろう
+20g
+sean
+##stone
+autocad
+nu
+##np
+f16
+write
+029
+m5
+##ias
+images
+atp
+##dk
+fsm
+504
+1350
+ve
+52kb
+##xxx
+##のに
+##cake
+414
+unit
+lim
+ru
+1v
+##ification
+published
+angela
+16g
+analytics
+ak
+##q
+##nel
+gmt
+##icon
+again
+##₂
+##bby
+ios11
+445
+かこさいます
+waze
+いてす
+##ハ
+9985
+##ust
+##ティー
+framework
+##007
+iptv
+delete
+52sykb
+cl
+wwdc
+027
+30cm
+##fw
+##ての
+1389
+##xon
+brandt
+##ses
+##dragon
+tc
+vetements
+anne
+monte
+modern
+official
+##へて
+##ere
+##nne
+##oud
+もちろん
+50
+etnews
+##a2
+##graphy
+421
+863
+##ちゃん
+444
+##rtex
+##てお
+l2
+##gma
+mount
+ccd
+たと
+archive
+morning
+tan
+ddos
+e7
+##ホ
+day4
+##ウ
+gis
+453
+its
+495
+factory
+bruce
+pg
+##ito
+ってくたさい
+guest
+cdma
+##lling
+536
+n3
+しかし
+3~4
+mega
+eyes
+ro
+13
+women
+dac
+church
+##jun
+singapore
+##facebook
+6991
+starbucks
+##tos
+##stin
+##shine
+zen
+##mu
+tina
+20℃
+1893
+##たけて
+503
+465
+request
+##gence
+qt
+##っ
+1886
+347
+363
+q7
+##zzi
+diary
+##tore
+409
+##ead
+468
+cst
+##osa
+canada
+agent
+va
+##jiang
+##ちは
+##ーク
+##lam
+sg
+##nix
+##sday
+##よって
+g6
+##master
+bing
+##zl
+charlie
+16
+8mm
+nb40
+##ーン
+thai
+##ルフ
+ln284ct
+##itz
+##2f
+bonnie
+##food
+##lent
+originals
+##stro
+##lts
+418
+∟∣
+##bscribe
+children
+ntd
+yesstyle
+##かも
+hmv
+##tment
+d5
+2cm
+arts
+sms
+##pn
+##я
+##いい
+topios9
+539
+lifestyle
+virtual
+##ague
+xz
+##deo
+muji
+024
+unt
+##nnis
+##ᅩ
+faq1
+1884
+396
+##ette
+fly
+64㎡
+はしめまして
+441
+curry
+##pop
+のこ
+release
+##←
+##◆◆
+##cast
+073
+ありな
+500ml
+##ews
+5c
+##stle
+ios7
+##ima
+787
+dog
+lenovo
+##r4
+roger
+013
+cbs
+vornado
+100m
+417
+##desk
+##クok
+##ald
+1867
+9595
+2900
+##van
+oil
+##x
+some
+break
+common
+##jy
+##lines
+g7
+twice
+419
+ella
+nano
+belle
+にこ
+##mes
+##self
+##note
+jb
+##ことかてきます
+benz
+##との
+##ova
+451
+save
+##wing
+##ますのて
+kai
+りは
+##hua
+##rect
+rainer
+##unge
+448
+##0m
+adsl
+##かな
+guestname
+##uma
+##kins
+##zu
+tokichoi
+##price
+county
+##med
+##mus
+rmk
+391
+address
+vm
+えて
+openload
+##group
+##hin
+##iginal
+amg
+urban
+##oz
+jobs
+emi
+##public
+beautiful
+##sch
+album
+##dden
+##bell
+jerry
+works
+hostel
+miller
+##drive
+##rmin
+##10
+376
+boot
+828
+##370
+##fx
+##cm~
+1885
+##nome
+##ctionary
+##oman
+##lish
+##cr
+##hm
+433
+##how
+432
+francis
+xi
+c919
+b5
+evernote
+##uc
+vga
+##3000
+coupe
+##urg
+##cca
+##uality
+019
+6g
+れる
+multi
+##また
+##ett
+em
+hey
+##ani
+##tax
+##rma
+inside
+than
+740
+leonnhurt
+##jin
+ict
+れた
+bird
+notes
+200mm
+くの
+##dical
+##lli
+result
+442
+iu
+ee
+438
+smap
+gopro
+##last
+yin
+pure
+998
+32g
+けた
+5kg
+##dan
+##rame
+mama
+##oot
+bean
+marketing
+##hur
+2l
+bella
+sync
+xuite
+##ground
+515
+discuz
+##getrelax
+##ince
+##bay
+##5s
+cj
+##イス
+gmat
+apt
+##pass
+jing
+##rix
+c4
+rich
+##とても
+niusnews
+##ello
+bag
+770
+##eting
+##mobile
+18
+culture
+015
+##のてすか
+377
+1020
+area
+##ience
+616
+details
+gp
+universal
+silver
+dit
+はお
+private
+ddd
+u11
+kanshu
+##ified
+fung
+##nny
+dx
+##520
+tai
+475
+023
+##fr
+##lean
+3s
+##pin
+429
+##rin
+25000
+ly
+rick
+##bility
+usb3
+banner
+##baru
+##gion
+metal
+dt
+vdf
+1871
+karl
+qualcomm
+bear
+1010
+oldid
+ian
+jo
+##tors
+population
+##ernel
+1882
+mmorpg
+##mv
+##bike
+603
+##©
+ww
+friend
+##ager
+exhibition
+##del
+##pods
+fpx
+structure
+##free
+##tings
+kl
+##rley
+##copyright
+##mma
+california
+3400
+orange
+yoga
+4l
+canmake
+honey
+##anda
+##コメント
+595
+nikkie
+##ルハイト
+dhl
+publishing
+##mall
+##gnet
+20cm
+513
+##クセス
+##┅
+e88
+970
+##dog
+fishbase
+##!
+##"
+###
+##$
+##%
+##&
+##'
+##(
+##)
+##*
+##+
+##,
+##-
+##.
+##/
+##:
+##;
+##<
+##=
+##>
+##?
+##@
+##[
+##\
+##]
+##^
+##_
+##{
+##|
+##}
+##~
+##£
+##¤
+##¥
+##§
+##«
+##±
+##³
+##µ
+##·
+##¹
+##º
+##»
+##¼
+##ß
+##æ
+##÷
+##ø
+##đ
+##ŋ
+##ɔ
+##ə
+##ɡ
+##ʰ
+##ˇ
+##ˈ
+##ˊ
+##ˋ
+##ˍ
+##ː
+##˙
+##˚
+##ˢ
+##α
+##β
+##γ
+##δ
+##ε
+##η
+##θ
+##ι
+##κ
+##λ
+##μ
+##ν
+##ο
+##π
+##ρ
+##ς
+##σ
+##τ
+##υ
+##φ
+##χ
+##ψ
+##б
+##в
+##г
+##д
+##е
+##ж
+##з
+##к
+##л
+##м
+##н
+##о
+##п
+##р
+##с
+##т
+##у
+##ф
+##х
+##ц
+##ч
+##ш
+##ы
+##ь
+##і
+##ا
+##ب
+##ة
+##ت
+##د
+##ر
+##س
+##ع
+##ل
+##م
+##ن
+##ه
+##و
+##ي
+##۩
+##ก
+##ง
+##น
+##ม
+##ย
+##ร
+##อ
+##า
+##เ
+##๑
+##་
+##ღ
+##ᄀ
+##ᄁ
+##ᄂ
+##ᄃ
+##ᄅ
+##ᄆ
+##ᄇ
+##ᄈ
+##ᄉ
+##ᄋ
+##ᄌ
+##ᄎ
+##ᄏ
+##ᄐ
+##ᄑ
+##ᄒ
+##ᅢ
+##ᅣ
+##ᅥ
+##ᅦ
+##ᅧ
+##ᅨ
+##ᅪ
+##ᅬ
+##ᅭ
+##ᅮ
+##ᅯ
+##ᅲ
+##ᅳ
+##ᅴ
+##ᆷ
+##ᆸ
+##ᆺ
+##ᆻ
+##ᗜ
+##ᵃ
+##ᵉ
+##ᵍ
+##ᵏ
+##ᵐ
+##ᵒ
+##ᵘ
+##‖
+##„
+##†
+##•
+##‥
+##‧
+##
+##‰
+##′
+##″
+##‹
+##›
+##※
+##‿
+##⁄
+##ⁱ
+##⁺
+##ⁿ
+##₁
+##₃
+##₄
+##€
+##№
+##ⅰ
+##ⅱ
+##ⅲ
+##ⅳ
+##ⅴ
+##↔
+##↗
+##↘
+##⇒
+##∀
+##−
+##∕
+##∙
+##√
+##∞
+##∟
+##∠
+##∣
+##∩
+##∮
+##∶
+##∼
+##∽
+##≈
+##≒
+##≡
+##≤
+##≥
+##≦
+##≧
+##≪
+##≫
+##⊙
+##⋅
+##⋈
+##⋯
+##⌒
+##①
+##②
+##③
+##④
+##⑤
+##⑥
+##⑦
+##⑧
+##⑨
+##⑩
+##⑴
+##⑵
+##⑶
+##⑷
+##⑸
+##⒈
+##⒉
+##⒊
+##⒋
+##ⓒ
+##ⓔ
+##ⓘ
+##━
+##┃
+##┆
+##┊
+##┌
+##└
+##├
+##┣
+##═
+##║
+##╚
+##╞
+##╠
+##╭
+##╮
+##╯
+##╰
+##╱
+##╳
+##▂
+##▃
+##▅
+##▇
+##▉
+##▋
+##▌
+##▍
+##▎
+##□
+##▪
+##▫
+##▬
+##△
+##▶
+##►
+##▽
+##◇
+##◕
+##◠
+##◢
+##◤
+##☀
+##☕
+##☞
+##☺
+##☼
+##♀
+##♂
+##♠
+##♡
+##♣
+##♦
+##♫
+##♬
+##✈
+##✔
+##✕
+##✖
+##✦
+##✨
+##✪
+##✰
+##✿
+##❀
+##➜
+##➤
+##⦿
+##、
+##。
+##〃
+##々
+##〇
+##〈
+##〉
+##《
+##》
+##「
+##」
+##『
+##』
+##【
+##】
+##〓
+##〔
+##〕
+##〖
+##〗
+##〜
+##〝
+##〞
+##ぃ
+##ぇ
+##ぬ
+##ふ
+##ほ
+##む
+##ゃ
+##ゅ
+##ゆ
+##ょ
+##゜
+##ゝ
+##ァ
+##ゥ
+##エ
+##ォ
+##ケ
+##サ
+##セ
+##ソ
+##ッ
+##ニ
+##ヌ
+##ネ
+##ノ
+##ヘ
+##モ
+##ャ
+##ヤ
+##ュ
+##ユ
+##ョ
+##ヨ
+##ワ
+##ヲ
+##・
+##ヽ
+##ㄅ
+##ㄆ
+##ㄇ
+##ㄉ
+##ㄋ
+##ㄌ
+##ㄍ
+##ㄎ
+##ㄏ
+##ㄒ
+##ㄚ
+##ㄛ
+##ㄞ
+##ㄟ
+##ㄢ
+##ㄤ
+##ㄥ
+##ㄧ
+##ㄨ
+##ㆍ
+##㈦
+##㊣
+##㗎
+##一
+##丁
+##七
+##万
+##丈
+##三
+##上
+##下
+##不
+##与
+##丐
+##丑
+##专
+##且
+##丕
+##世
+##丘
+##丙
+##业
+##丛
+##东
+##丝
+##丞
+##丟
+##両
+##丢
+##两
+##严
+##並
+##丧
+##丨
+##个
+##丫
+##中
+##丰
+##串
+##临
+##丶
+##丸
+##丹
+##为
+##主
+##丼
+##丽
+##举
+##丿
+##乂
+##乃
+##久
+##么
+##义
+##之
+##乌
+##乍
+##乎
+##乏
+##乐
+##乒
+##乓
+##乔
+##乖
+##乗
+##乘
+##乙
+##乜
+##九
+##乞
+##也
+##习
+##乡
+##书
+##乩
+##买
+##乱
+##乳
+##乾
+##亀
+##亂
+##了
+##予
+##争
+##事
+##二
+##于
+##亏
+##云
+##互
+##五
+##井
+##亘
+##亙
+##亚
+##些
+##亜
+##亞
+##亟
+##亡
+##亢
+##交
+##亥
+##亦
+##产
+##亨
+##亩
+##享
+##京
+##亭
+##亮
+##亲
+##亳
+##亵
+##人
+##亿
+##什
+##仁
+##仃
+##仄
+##仅
+##仆
+##仇
+##今
+##介
+##仍
+##从
+##仏
+##仑
+##仓
+##仔
+##仕
+##他
+##仗
+##付
+##仙
+##仝
+##仞
+##仟
+##代
+##令
+##以
+##仨
+##仪
+##们
+##仮
+##仰
+##仲
+##件
+##价
+##任
+##份
+##仿
+##企
+##伉
+##伊
+##伍
+##伎
+##伏
+##伐
+##休
+##伕
+##众
+##优
+##伙
+##会
+##伝
+##伞
+##伟
+##传
+##伢
+##伤
+##伦
+##伪
+##伫
+##伯
+##估
+##伴
+##伶
+##伸
+##伺
+##似
+##伽
+##佃
+##但
+##佇
+##佈
+##位
+##低
+##住
+##佐
+##佑
+##体
+##佔
+##何
+##佗
+##佘
+##余
+##佚
+##佛
+##作
+##佝
+##佞
+##佟
+##你
+##佢
+##佣
+##佤
+##佥
+##佩
+##佬
+##佯
+##佰
+##佳
+##併
+##佶
+##佻
+##佼
+##使
+##侃
+##侄
+##來
+##侈
+##例
+##侍
+##侏
+##侑
+##侖
+##侗
+##供
+##依
+##侠
+##価
+##侣
+##侥
+##侦
+##侧
+##侨
+##侬
+##侮
+##侯
+##侵
+##侶
+##侷
+##便
+##係
+##促
+##俄
+##俊
+##俎
+##俏
+##俐
+##俑
+##俗
+##俘
+##俚
+##保
+##俞
+##俟
+##俠
+##信
+##俨
+##俩
+##俪
+##俬
+##俭
+##修
+##俯
+##俱
+##俳
+##俸
+##俺
+##俾
+##倆
+##倉
+##個
+##倌
+##倍
+##倏
+##們
+##倒
+##倔
+##倖
+##倘
+##候
+##倚
+##倜
+##借
+##倡
+##値
+##倦
+##倩
+##倪
+##倫
+##倬
+##倭
+##倶
+##债
+##值
+##倾
+##偃
+##假
+##偈
+##偉
+##偌
+##偎
+##偏
+##偕
+##做
+##停
+##健
+##側
+##偵
+##偶
+##偷
+##偻
+##偽
+##偿
+##傀
+##傅
+##傍
+##傑
+##傘
+##備
+##傚
+##傢
+##傣
+##傥
+##储
+##傩
+##催
+##傭
+##傲
+##傳
+##債
+##傷
+##傻
+##傾
+##僅
+##働
+##像
+##僑
+##僕
+##僖
+##僚
+##僥
+##僧
+##僭
+##僮
+##僱
+##僵
+##價
+##僻
+##儀
+##儂
+##億
+##儆
+##儉
+##儋
+##儒
+##儕
+##儘
+##償
+##儡
+##優
+##儲
+##儷
+##儼
+##儿
+##兀
+##允
+##元
+##兄
+##充
+##兆
+##兇
+##先
+##光
+##克
+##兌
+##免
+##児
+##兑
+##兒
+##兔
+##兖
+##党
+##兜
+##兢
+##入
+##內
+##全
+##兩
+##八
+##公
+##六
+##兮
+##兰
+##共
+##兲
+##关
+##兴
+##兵
+##其
+##具
+##典
+##兹
+##养
+##兼
+##兽
+##冀
+##内
+##円
+##冇
+##冈
+##冉
+##冊
+##册
+##再
+##冏
+##冒
+##冕
+##冗
+##写
+##军
+##农
+##冠
+##冢
+##冤
+##冥
+##冨
+##冪
+##冬
+##冯
+##冰
+##冲
+##决
+##况
+##冶
+##冷
+##冻
+##冼
+##冽
+##冾
+##净
+##凄
+##准
+##凇
+##凈
+##凉
+##凋
+##凌
+##凍
+##减
+##凑
+##凛
+##凜
+##凝
+##几
+##凡
+##凤
+##処
+##凪
+##凭
+##凯
+##凰
+##凱
+##凳
+##凶
+##凸
+##凹
+##出
+##击
+##函
+##凿
+##刀
+##刁
+##刃
+##分
+##切
+##刈
+##刊
+##刍
+##刎
+##刑
+##划
+##列
+##刘
+##则
+##刚
+##创
+##初
+##删
+##判
+##別
+##刨
+##利
+##刪
+##别
+##刮
+##到
+##制
+##刷
+##券
+##刹
+##刺
+##刻
+##刽
+##剁
+##剂
+##剃
+##則
+##剉
+##削
+##剋
+##剌
+##前
+##剎
+##剐
+##剑
+##剔
+##剖
+##剛
+##剜
+##剝
+##剣
+##剤
+##剥
+##剧
+##剩
+##剪
+##副
+##割
+##創
+##剷
+##剽
+##剿
+##劃
+##劇
+##劈
+##劉
+##劊
+##劍
+##劏
+##劑
+##力
+##劝
+##办
+##功
+##加
+##务
+##劣
+##动
+##助
+##努
+##劫
+##劭
+##励
+##劲
+##劳
+##労
+##劵
+##効
+##劾
+##势
+##勁
+##勃
+##勇
+##勉
+##勋
+##勐
+##勒
+##動
+##勖
+##勘
+##務
+##勛
+##勝
+##勞
+##募
+##勢
+##勤
+##勧
+##勳
+##勵
+##勸
+##勺
+##勻
+##勾
+##勿
+##匀
+##包
+##匆
+##匈
+##匍
+##匐
+##匕
+##化
+##北
+##匙
+##匝
+##匠
+##匡
+##匣
+##匪
+##匮
+##匯
+##匱
+##匹
+##区
+##医
+##匾
+##匿
+##區
+##十
+##千
+##卅
+##升
+##午
+##卉
+##半
+##卍
+##华
+##协
+##卑
+##卒
+##卓
+##協
+##单
+##卖
+##南
+##単
+##博
+##卜
+##卞
+##卟
+##占
+##卡
+##卢
+##卤
+##卦
+##卧
+##卫
+##卮
+##卯
+##印
+##危
+##即
+##却
+##卵
+##卷
+##卸
+##卻
+##卿
+##厂
+##厄
+##厅
+##历
+##厉
+##压
+##厌
+##厕
+##厘
+##厚
+##厝
+##原
+##厢
+##厥
+##厦
+##厨
+##厩
+##厭
+##厮
+##厲
+##厳
+##去
+##县
+##叁
+##参
+##參
+##又
+##叉
+##及
+##友
+##双
+##反
+##収
+##发
+##叔
+##取
+##受
+##变
+##叙
+##叛
+##叟
+##叠
+##叡
+##叢
+##口
+##古
+##句
+##另
+##叨
+##叩
+##只
+##叫
+##召
+##叭
+##叮
+##可
+##台
+##叱
+##史
+##右
+##叵
+##叶
+##号
+##司
+##叹
+##叻
+##叼
+##叽
+##吁
+##吃
+##各
+##吆
+##合
+##吉
+##吊
+##吋
+##同
+##名
+##后
+##吏
+##吐
+##向
+##吒
+##吓
+##吕
+##吖
+##吗
+##君
+##吝
+##吞
+##吟
+##吠
+##吡
+##否
+##吧
+##吨
+##吩
+##含
+##听
+##吭
+##吮
+##启
+##吱
+##吳
+##吴
+##吵
+##吶
+##吸
+##吹
+##吻
+##吼
+##吽
+##吾
+##呀
+##呂
+##呃
+##呆
+##呈
+##告
+##呋
+##呎
+##呐
+##呓
+##呕
+##呗
+##员
+##呛
+##呜
+##呢
+##呤
+##呦
+##周
+##呱
+##呲
+##味
+##呵
+##呷
+##呸
+##呻
+##呼
+##命
+##咀
+##咁
+##咂
+##咄
+##咆
+##咋
+##和
+##咎
+##咏
+##咐
+##咒
+##咔
+##咕
+##咖
+##咗
+##咘
+##咙
+##咚
+##咛
+##咣
+##咤
+##咦
+##咧
+##咨
+##咩
+##咪
+##咫
+##咬
+##咭
+##咯
+##咱
+##咲
+##咳
+##咸
+##咻
+##咽
+##咿
+##哀
+##品
+##哂
+##哄
+##哆
+##哇
+##哈
+##哉
+##哋
+##哌
+##响
+##哎
+##哏
+##哐
+##哑
+##哒
+##哔
+##哗
+##哟
+##員
+##哥
+##哦
+##哧
+##哨
+##哩
+##哪
+##哭
+##哮
+##哲
+##哺
+##哼
+##哽
+##唁
+##唄
+##唆
+##唇
+##唉
+##唏
+##唐
+##唑
+##唔
+##唠
+##唤
+##唧
+##唬
+##售
+##唯
+##唰
+##唱
+##唳
+##唷
+##唸
+##唾
+##啃
+##啄
+##商
+##啉
+##啊
+##問
+##啓
+##啕
+##啖
+##啜
+##啞
+##啟
+##啡
+##啤
+##啥
+##啦
+##啧
+##啪
+##啫
+##啬
+##啮
+##啰
+##啱
+##啲
+##啵
+##啶
+##啷
+##啸
+##啻
+##啼
+##啾
+##喀
+##喂
+##喃
+##善
+##喆
+##喇
+##喉
+##喊
+##喋
+##喎
+##喏
+##喔
+##喘
+##喙
+##喚
+##喜
+##喝
+##喟
+##喧
+##喪
+##喫
+##喬
+##單
+##喰
+##喱
+##喲
+##喳
+##喵
+##営
+##喷
+##喹
+##喺
+##喻
+##喽
+##嗅
+##嗆
+##嗇
+##嗎
+##嗑
+##嗒
+##嗓
+##嗔
+##嗖
+##嗚
+##嗜
+##嗝
+##嗟
+##嗡
+##嗣
+##嗤
+##嗦
+##嗨
+##嗪
+##嗬
+##嗯
+##嗰
+##嗲
+##嗳
+##嗶
+##嗷
+##嗽
+##嘀
+##嘅
+##嘆
+##嘈
+##嘉
+##嘌
+##嘍
+##嘎
+##嘔
+##嘖
+##嘗
+##嘘
+##嘚
+##嘛
+##嘜
+##嘞
+##嘟
+##嘢
+##嘣
+##嘤
+##嘧
+##嘩
+##嘭
+##嘮
+##嘯
+##嘰
+##嘱
+##嘲
+##嘴
+##嘶
+##嘸
+##嘹
+##嘻
+##嘿
+##噁
+##噌
+##噎
+##噓
+##噔
+##噗
+##噙
+##噜
+##噠
+##噢
+##噤
+##器
+##噩
+##噪
+##噬
+##噱
+##噴
+##噶
+##噸
+##噹
+##噻
+##噼
+##嚀
+##嚇
+##嚎
+##嚏
+##嚐
+##嚓
+##嚕
+##嚟
+##嚣
+##嚥
+##嚨
+##嚮
+##嚴
+##嚷
+##嚼
+##囂
+##囉
+##囊
+##囍
+##囑
+##囔
+##囗
+##囚
+##四
+##囝
+##回
+##囟
+##因
+##囡
+##团
+##団
+##囤
+##囧
+##囪
+##囫
+##园
+##困
+##囱
+##囲
+##図
+##围
+##囹
+##固
+##国
+##图
+##囿
+##圃
+##圄
+##圆
+##圈
+##國
+##圍
+##圏
+##園
+##圓
+##圖
+##團
+##圜
+##土
+##圣
+##圧
+##在
+##圩
+##圭
+##地
+##圳
+##场
+##圻
+##圾
+##址
+##坂
+##均
+##坊
+##坍
+##坎
+##坏
+##坐
+##坑
+##块
+##坚
+##坛
+##坝
+##坞
+##坟
+##坠
+##坡
+##坤
+##坦
+##坨
+##坪
+##坯
+##坳
+##坵
+##坷
+##垂
+##垃
+##垄
+##型
+##垒
+##垚
+##垛
+##垠
+##垢
+##垣
+##垦
+##垩
+##垫
+##垭
+##垮
+##垵
+##埂
+##埃
+##埋
+##城
+##埔
+##埕
+##埗
+##域
+##埠
+##埤
+##埵
+##執
+##埸
+##培
+##基
+##埼
+##堀
+##堂
+##堃
+##堅
+##堆
+##堇
+##堑
+##堕
+##堙
+##堡
+##堤
+##堪
+##堯
+##堰
+##報
+##場
+##堵
+##堺
+##堿
+##塊
+##塌
+##塑
+##塔
+##塗
+##塘
+##塚
+##塞
+##塢
+##塩
+##填
+##塬
+##塭
+##塵
+##塾
+##墀
+##境
+##墅
+##墉
+##墊
+##墒
+##墓
+##増
+##墘
+##墙
+##墜
+##增
+##墟
+##墨
+##墩
+##墮
+##墳
+##墻
+##墾
+##壁
+##壅
+##壆
+##壇
+##壊
+##壑
+##壓
+##壕
+##壘
+##壞
+##壟
+##壢
+##壤
+##壩
+##士
+##壬
+##壮
+##壯
+##声
+##売
+##壳
+##壶
+##壹
+##壺
+##壽
+##处
+##备
+##変
+##复
+##夏
+##夔
+##夕
+##外
+##夙
+##多
+##夜
+##够
+##夠
+##夢
+##夥
+##大
+##天
+##太
+##夫
+##夭
+##央
+##夯
+##失
+##头
+##夷
+##夸
+##夹
+##夺
+##夾
+##奂
+##奄
+##奇
+##奈
+##奉
+##奋
+##奎
+##奏
+##奐
+##契
+##奔
+##奕
+##奖
+##套
+##奘
+##奚
+##奠
+##奢
+##奥
+##奧
+##奪
+##奬
+##奮
+##女
+##奴
+##奶
+##奸
+##她
+##好
+##如
+##妃
+##妄
+##妆
+##妇
+##妈
+##妊
+##妍
+##妒
+##妓
+##妖
+##妘
+##妙
+##妝
+##妞
+##妣
+##妤
+##妥
+##妨
+##妩
+##妪
+##妮
+##妲
+##妳
+##妹
+##妻
+##妾
+##姆
+##姉
+##姊
+##始
+##姍
+##姐
+##姑
+##姒
+##姓
+##委
+##姗
+##姚
+##姜
+##姝
+##姣
+##姥
+##姦
+##姨
+##姪
+##姫
+##姬
+##姹
+##姻
+##姿
+##威
+##娃
+##娄
+##娅
+##娆
+##娇
+##娉
+##娑
+##娓
+##娘
+##娛
+##娜
+##娟
+##娠
+##娣
+##娥
+##娩
+##娱
+##娲
+##娴
+##娶
+##娼
+##婀
+##婁
+##婆
+##婉
+##婊
+##婕
+##婚
+##婢
+##婦
+##婧
+##婪
+##婭
+##婴
+##婵
+##婶
+##婷
+##婺
+##婿
+##媒
+##媚
+##媛
+##媞
+##媧
+##媲
+##媳
+##媽
+##媾
+##嫁
+##嫂
+##嫉
+##嫌
+##嫑
+##嫔
+##嫖
+##嫘
+##嫚
+##嫡
+##嫣
+##嫦
+##嫩
+##嫲
+##嫵
+##嫻
+##嬅
+##嬉
+##嬌
+##嬗
+##嬛
+##嬢
+##嬤
+##嬪
+##嬰
+##嬴
+##嬷
+##嬸
+##嬿
+##孀
+##孃
+##子
+##孑
+##孔
+##孕
+##孖
+##字
+##存
+##孙
+##孚
+##孛
+##孜
+##孝
+##孟
+##孢
+##季
+##孤
+##学
+##孩
+##孪
+##孫
+##孬
+##孰
+##孱
+##孳
+##孵
+##學
+##孺
+##孽
+##孿
+##宁
+##它
+##宅
+##宇
+##守
+##安
+##宋
+##完
+##宏
+##宓
+##宕
+##宗
+##官
+##宙
+##定
+##宛
+##宜
+##宝
+##实
+##実
+##宠
+##审
+##客
+##宣
+##室
+##宥
+##宦
+##宪
+##宫
+##宮
+##宰
+##害
+##宴
+##宵
+##家
+##宸
+##容
+##宽
+##宾
+##宿
+##寂
+##寄
+##寅
+##密
+##寇
+##富
+##寐
+##寒
+##寓
+##寛
+##寝
+##寞
+##察
+##寡
+##寢
+##寥
+##實
+##寧
+##寨
+##審
+##寫
+##寬
+##寮
+##寰
+##寵
+##寶
+##寸
+##对
+##寺
+##寻
+##导
+##対
+##寿
+##封
+##専
+##射
+##将
+##將
+##專
+##尉
+##尊
+##尋
+##對
+##導
+##小
+##少
+##尔
+##尕
+##尖
+##尘
+##尚
+##尝
+##尤
+##尧
+##尬
+##就
+##尴
+##尷
+##尸
+##尹
+##尺
+##尻
+##尼
+##尽
+##尾
+##尿
+##局
+##屁
+##层
+##屄
+##居
+##屆
+##屈
+##屉
+##届
+##屋
+##屌
+##屍
+##屎
+##屏
+##屐
+##屑
+##展
+##屜
+##属
+##屠
+##屡
+##屢
+##層
+##履
+##屬
+##屯
+##山
+##屹
+##屿
+##岀
+##岁
+##岂
+##岌
+##岐
+##岑
+##岔
+##岖
+##岗
+##岘
+##岙
+##岚
+##岛
+##岡
+##岩
+##岫
+##岬
+##岭
+##岱
+##岳
+##岷
+##岸
+##峇
+##峋
+##峒
+##峙
+##峡
+##峤
+##峥
+##峦
+##峨
+##峪
+##峭
+##峯
+##峰
+##峴
+##島
+##峻
+##峽
+##崁
+##崂
+##崆
+##崇
+##崎
+##崑
+##崔
+##崖
+##崗
+##崙
+##崛
+##崧
+##崩
+##崭
+##崴
+##崽
+##嵇
+##嵊
+##嵋
+##嵌
+##嵐
+##嵘
+##嵩
+##嵬
+##嵯
+##嶂
+##嶄
+##嶇
+##嶋
+##嶙
+##嶺
+##嶼
+##嶽
+##巅
+##巍
+##巒
+##巔
+##巖
+##川
+##州
+##巡
+##巢
+##工
+##左
+##巧
+##巨
+##巩
+##巫
+##差
+##己
+##已
+##巳
+##巴
+##巷
+##巻
+##巽
+##巾
+##巿
+##币
+##市
+##布
+##帅
+##帆
+##师
+##希
+##帐
+##帑
+##帕
+##帖
+##帘
+##帚
+##帛
+##帜
+##帝
+##帥
+##带
+##帧
+##師
+##席
+##帮
+##帯
+##帰
+##帳
+##帶
+##帷
+##常
+##帼
+##帽
+##幀
+##幂
+##幄
+##幅
+##幌
+##幔
+##幕
+##幟
+##幡
+##幢
+##幣
+##幫
+##干
+##平
+##年
+##并
+##幸
+##幹
+##幺
+##幻
+##幼
+##幽
+##幾
+##广
+##庁
+##広
+##庄
+##庆
+##庇
+##床
+##序
+##庐
+##库
+##应
+##底
+##庖
+##店
+##庙
+##庚
+##府
+##庞
+##废
+##庠
+##度
+##座
+##庫
+##庭
+##庵
+##庶
+##康
+##庸
+##庹
+##庾
+##廁
+##廂
+##廃
+##廈
+##廉
+##廊
+##廓
+##廖
+##廚
+##廝
+##廟
+##廠
+##廢
+##廣
+##廬
+##廳
+##延
+##廷
+##建
+##廿
+##开
+##弁
+##异
+##弃
+##弄
+##弈
+##弊
+##弋
+##式
+##弑
+##弒
+##弓
+##弔
+##引
+##弗
+##弘
+##弛
+##弟
+##张
+##弥
+##弦
+##弧
+##弩
+##弭
+##弯
+##弱
+##張
+##強
+##弹
+##强
+##弼
+##弾
+##彅
+##彆
+##彈
+##彌
+##彎
+##归
+##当
+##录
+##彗
+##彙
+##彝
+##形
+##彤
+##彥
+##彦
+##彧
+##彩
+##彪
+##彫
+##彬
+##彭
+##彰
+##影
+##彷
+##役
+##彻
+##彼
+##彿
+##往
+##征
+##径
+##待
+##徇
+##很
+##徉
+##徊
+##律
+##後
+##徐
+##徑
+##徒
+##従
+##徕
+##得
+##徘
+##徙
+##徜
+##從
+##徠
+##御
+##徨
+##復
+##循
+##徬
+##微
+##徳
+##徴
+##徵
+##德
+##徹
+##徼
+##徽
+##心
+##必
+##忆
+##忌
+##忍
+##忏
+##忐
+##忑
+##忒
+##忖
+##志
+##忘
+##忙
+##応
+##忠
+##忡
+##忤
+##忧
+##忪
+##快
+##忱
+##念
+##忻
+##忽
+##忿
+##怀
+##态
+##怂
+##怅
+##怆
+##怎
+##怏
+##怒
+##怔
+##怕
+##怖
+##怙
+##怜
+##思
+##怠
+##怡
+##急
+##怦
+##性
+##怨
+##怪
+##怯
+##怵
+##总
+##怼
+##恁
+##恃
+##恆
+##恋
+##恍
+##恐
+##恒
+##恕
+##恙
+##恚
+##恢
+##恣
+##恤
+##恥
+##恨
+##恩
+##恪
+##恫
+##恬
+##恭
+##息
+##恰
+##恳
+##恵
+##恶
+##恸
+##恺
+##恻
+##恼
+##恿
+##悄
+##悅
+##悉
+##悌
+##悍
+##悔
+##悖
+##悚
+##悟
+##悠
+##患
+##悦
+##您
+##悩
+##悪
+##悬
+##悯
+##悱
+##悲
+##悴
+##悵
+##悶
+##悸
+##悻
+##悼
+##悽
+##情
+##惆
+##惇
+##惊
+##惋
+##惑
+##惕
+##惘
+##惚
+##惜
+##惟
+##惠
+##惡
+##惦
+##惧
+##惨
+##惩
+##惫
+##惬
+##惭
+##惮
+##惯
+##惰
+##惱
+##想
+##惴
+##惶
+##惹
+##惺
+##愁
+##愆
+##愈
+##愉
+##愍
+##意
+##愕
+##愚
+##愛
+##愜
+##感
+##愣
+##愤
+##愧
+##愫
+##愷
+##愿
+##慄
+##慈
+##態
+##慌
+##慎
+##慑
+##慕
+##慘
+##慚
+##慟
+##慢
+##慣
+##慧
+##慨
+##慫
+##慮
+##慰
+##慳
+##慵
+##慶
+##慷
+##慾
+##憂
+##憊
+##憋
+##憎
+##憐
+##憑
+##憔
+##憚
+##憤
+##憧
+##憨
+##憩
+##憫
+##憬
+##憲
+##憶
+##憾
+##懂
+##懇
+##懈
+##應
+##懊
+##懋
+##懑
+##懒
+##懦
+##懲
+##懵
+##懶
+##懷
+##懸
+##懺
+##懼
+##懾
+##懿
+##戀
+##戈
+##戊
+##戌
+##戍
+##戎
+##戏
+##成
+##我
+##戒
+##戕
+##或
+##战
+##戚
+##戛
+##戟
+##戡
+##戦
+##截
+##戬
+##戮
+##戰
+##戲
+##戳
+##戴
+##戶
+##户
+##戸
+##戻
+##戾
+##房
+##所
+##扁
+##扇
+##扈
+##扉
+##手
+##才
+##扎
+##扑
+##扒
+##打
+##扔
+##払
+##托
+##扛
+##扣
+##扦
+##执
+##扩
+##扪
+##扫
+##扬
+##扭
+##扮
+##扯
+##扰
+##扱
+##扳
+##扶
+##批
+##扼
+##找
+##承
+##技
+##抄
+##抉
+##把
+##抑
+##抒
+##抓
+##投
+##抖
+##抗
+##折
+##抚
+##抛
+##抜
+##択
+##抟
+##抠
+##抡
+##抢
+##护
+##报
+##抨
+##披
+##抬
+##抱
+##抵
+##抹
+##押
+##抽
+##抿
+##拂
+##拄
+##担
+##拆
+##拇
+##拈
+##拉
+##拋
+##拌
+##拍
+##拎
+##拐
+##拒
+##拓
+##拔
+##拖
+##拗
+##拘
+##拙
+##拚
+##招
+##拜
+##拟
+##拡
+##拢
+##拣
+##拥
+##拦
+##拧
+##拨
+##择
+##括
+##拭
+##拮
+##拯
+##拱
+##拳
+##拴
+##拷
+##拼
+##拽
+##拾
+##拿
+##持
+##挂
+##指
+##挈
+##按
+##挎
+##挑
+##挖
+##挙
+##挚
+##挛
+##挝
+##挞
+##挟
+##挠
+##挡
+##挣
+##挤
+##挥
+##挨
+##挪
+##挫
+##振
+##挲
+##挹
+##挺
+##挽
+##挾
+##捂
+##捅
+##捆
+##捉
+##捋
+##捌
+##捍
+##捎
+##捏
+##捐
+##捕
+##捞
+##损
+##捡
+##换
+##捣
+##捧
+##捨
+##捩
+##据
+##捱
+##捲
+##捶
+##捷
+##捺
+##捻
+##掀
+##掂
+##掃
+##掇
+##授
+##掉
+##掌
+##掏
+##掐
+##排
+##掖
+##掘
+##掙
+##掛
+##掠
+##採
+##探
+##掣
+##接
+##控
+##推
+##掩
+##措
+##掬
+##掰
+##掲
+##掳
+##掴
+##掷
+##掸
+##掺
+##揀
+##揃
+##揄
+##揆
+##揉
+##揍
+##描
+##提
+##插
+##揖
+##揚
+##換
+##握
+##揣
+##揩
+##揪
+##揭
+##揮
+##援
+##揶
+##揸
+##揹
+##揽
+##搀
+##搁
+##搂
+##搅
+##損
+##搏
+##搐
+##搓
+##搔
+##搖
+##搗
+##搜
+##搞
+##搡
+##搪
+##搬
+##搭
+##搵
+##搶
+##携
+##搽
+##摀
+##摁
+##摄
+##摆
+##摇
+##摈
+##摊
+##摒
+##摔
+##摘
+##摞
+##摟
+##摧
+##摩
+##摯
+##摳
+##摸
+##摹
+##摺
+##摻
+##撂
+##撃
+##撅
+##撇
+##撈
+##撐
+##撑
+##撒
+##撓
+##撕
+##撚
+##撞
+##撤
+##撥
+##撩
+##撫
+##撬
+##播
+##撮
+##撰
+##撲
+##撵
+##撷
+##撸
+##撻
+##撼
+##撿
+##擀
+##擁
+##擂
+##擄
+##擅
+##擇
+##擊
+##擋
+##操
+##擎
+##擒
+##擔
+##擘
+##據
+##擞
+##擠
+##擡
+##擢
+##擦
+##擬
+##擰
+##擱
+##擲
+##擴
+##擷
+##擺
+##擼
+##擾
+##攀
+##攏
+##攒
+##攔
+##攘
+##攙
+##攜
+##攝
+##攞
+##攢
+##攣
+##攤
+##攥
+##攪
+##攫
+##攬
+##支
+##收
+##攸
+##改
+##攻
+##放
+##政
+##故
+##效
+##敌
+##敍
+##敎
+##敏
+##救
+##敕
+##敖
+##敗
+##敘
+##教
+##敛
+##敝
+##敞
+##敢
+##散
+##敦
+##敬
+##数
+##敲
+##整
+##敵
+##敷
+##數
+##斂
+##斃
+##文
+##斋
+##斌
+##斎
+##斐
+##斑
+##斓
+##斗
+##料
+##斛
+##斜
+##斟
+##斡
+##斤
+##斥
+##斧
+##斩
+##斫
+##斬
+##断
+##斯
+##新
+##斷
+##方
+##於
+##施
+##旁
+##旃
+##旅
+##旋
+##旌
+##旎
+##族
+##旖
+##旗
+##无
+##既
+##日
+##旦
+##旧
+##旨
+##早
+##旬
+##旭
+##旮
+##旱
+##时
+##旷
+##旺
+##旻
+##昀
+##昂
+##昆
+##昇
+##昉
+##昊
+##昌
+##明
+##昏
+##易
+##昔
+##昕
+##昙
+##星
+##映
+##春
+##昧
+##昨
+##昭
+##是
+##昱
+##昴
+##昵
+##昶
+##昼
+##显
+##晁
+##時
+##晃
+##晉
+##晋
+##晌
+##晏
+##晒
+##晓
+##晔
+##晕
+##晖
+##晗
+##晚
+##晝
+##晞
+##晟
+##晤
+##晦
+##晨
+##晩
+##普
+##景
+##晰
+##晴
+##晶
+##晷
+##智
+##晾
+##暂
+##暄
+##暇
+##暈
+##暉
+##暌
+##暐
+##暑
+##暖
+##暗
+##暝
+##暢
+##暧
+##暨
+##暫
+##暮
+##暱
+##暴
+##暸
+##暹
+##曄
+##曆
+##曇
+##曉
+##曖
+##曙
+##曜
+##曝
+##曠
+##曦
+##曬
+##曰
+##曲
+##曳
+##更
+##書
+##曹
+##曼
+##曾
+##替
+##最
+##會
+##月
+##有
+##朋
+##服
+##朐
+##朔
+##朕
+##朗
+##望
+##朝
+##期
+##朦
+##朧
+##木
+##未
+##末
+##本
+##札
+##朮
+##术
+##朱
+##朴
+##朵
+##机
+##朽
+##杀
+##杂
+##权
+##杆
+##杈
+##杉
+##李
+##杏
+##材
+##村
+##杓
+##杖
+##杜
+##杞
+##束
+##杠
+##条
+##来
+##杨
+##杭
+##杯
+##杰
+##東
+##杳
+##杵
+##杷
+##杼
+##松
+##板
+##极
+##构
+##枇
+##枉
+##枋
+##析
+##枕
+##林
+##枚
+##果
+##枝
+##枢
+##枣
+##枪
+##枫
+##枭
+##枯
+##枰
+##枱
+##枳
+##架
+##枷
+##枸
+##柄
+##柏
+##某
+##柑
+##柒
+##染
+##柔
+##柘
+##柚
+##柜
+##柞
+##柠
+##柢
+##查
+##柩
+##柬
+##柯
+##柱
+##柳
+##柴
+##柵
+##査
+##柿
+##栀
+##栃
+##栄
+##栅
+##标
+##栈
+##栉
+##栋
+##栎
+##栏
+##树
+##栓
+##栖
+##栗
+##校
+##栩
+##株
+##样
+##核
+##根
+##格
+##栽
+##栾
+##桀
+##桁
+##桂
+##桃
+##桅
+##框
+##案
+##桉
+##桌
+##桎
+##桐
+##桑
+##桓
+##桔
+##桜
+##桠
+##桡
+##桢
+##档
+##桥
+##桦
+##桧
+##桨
+##桩
+##桶
+##桿
+##梁
+##梅
+##梆
+##梏
+##梓
+##梗
+##條
+##梟
+##梢
+##梦
+##梧
+##梨
+##梭
+##梯
+##械
+##梳
+##梵
+##梶
+##检
+##棂
+##棄
+##棉
+##棋
+##棍
+##棒
+##棕
+##棗
+##棘
+##棚
+##棟
+##棠
+##棣
+##棧
+##森
+##棱
+##棲
+##棵
+##棹
+##棺
+##椁
+##椅
+##椋
+##植
+##椎
+##椒
+##検
+##椪
+##椭
+##椰
+##椹
+##椽
+##椿
+##楂
+##楊
+##楓
+##楔
+##楚
+##楝
+##楞
+##楠
+##楣
+##楨
+##楫
+##業
+##楮
+##極
+##楷
+##楸
+##楹
+##楼
+##楽
+##概
+##榄
+##榆
+##榈
+##榉
+##榔
+##榕
+##榖
+##榛
+##榜
+##榨
+##榫
+##榭
+##榮
+##榱
+##榴
+##榷
+##榻
+##槁
+##槃
+##構
+##槌
+##槍
+##槎
+##槐
+##槓
+##様
+##槛
+##槟
+##槤
+##槭
+##槲
+##槳
+##槻
+##槽
+##槿
+##樁
+##樂
+##樊
+##樑
+##樓
+##標
+##樞
+##樟
+##模
+##樣
+##権
+##横
+##樫
+##樯
+##樱
+##樵
+##樸
+##樹
+##樺
+##樽
+##樾
+##橄
+##橇
+##橋
+##橐
+##橘
+##橙
+##機
+##橡
+##橢
+##橫
+##橱
+##橹
+##橼
+##檀
+##檄
+##檎
+##檐
+##檔
+##檗
+##檜
+##檢
+##檬
+##檯
+##檳
+##檸
+##檻
+##櫃
+##櫚
+##櫛
+##櫥
+##櫸
+##櫻
+##欄
+##權
+##欒
+##欖
+##欠
+##次
+##欢
+##欣
+##欧
+##欲
+##欸
+##欺
+##欽
+##款
+##歆
+##歇
+##歉
+##歌
+##歎
+##歐
+##歓
+##歙
+##歛
+##歡
+##止
+##正
+##此
+##步
+##武
+##歧
+##歩
+##歪
+##歯
+##歲
+##歳
+##歴
+##歷
+##歸
+##歹
+##死
+##歼
+##殁
+##殃
+##殆
+##殇
+##殉
+##殊
+##残
+##殒
+##殓
+##殖
+##殘
+##殞
+##殡
+##殤
+##殭
+##殯
+##殲
+##殴
+##段
+##殷
+##殺
+##殼
+##殿
+##毀
+##毁
+##毂
+##毅
+##毆
+##毋
+##母
+##毎
+##每
+##毒
+##毓
+##比
+##毕
+##毗
+##毘
+##毙
+##毛
+##毡
+##毫
+##毯
+##毽
+##氈
+##氏
+##氐
+##民
+##氓
+##气
+##氖
+##気
+##氙
+##氛
+##氟
+##氡
+##氢
+##氣
+##氤
+##氦
+##氧
+##氨
+##氪
+##氫
+##氮
+##氯
+##氰
+##氲
+##水
+##氷
+##永
+##氹
+##氾
+##汀
+##汁
+##求
+##汆
+##汇
+##汉
+##汎
+##汐
+##汕
+##汗
+##汙
+##汛
+##汝
+##汞
+##江
+##池
+##污
+##汤
+##汨
+##汩
+##汪
+##汰
+##汲
+##汴
+##汶
+##汹
+##決
+##汽
+##汾
+##沁
+##沂
+##沃
+##沅
+##沈
+##沉
+##沌
+##沏
+##沐
+##沒
+##沓
+##沖
+##沙
+##沛
+##沟
+##没
+##沢
+##沣
+##沥
+##沦
+##沧
+##沪
+##沫
+##沭
+##沮
+##沱
+##河
+##沸
+##油
+##治
+##沼
+##沽
+##沾
+##沿
+##況
+##泄
+##泉
+##泊
+##泌
+##泓
+##法
+##泗
+##泛
+##泞
+##泠
+##泡
+##波
+##泣
+##泥
+##注
+##泪
+##泫
+##泮
+##泯
+##泰
+##泱
+##泳
+##泵
+##泷
+##泸
+##泻
+##泼
+##泽
+##泾
+##洁
+##洄
+##洋
+##洒
+##洗
+##洙
+##洛
+##洞
+##津
+##洩
+##洪
+##洮
+##洱
+##洲
+##洵
+##洶
+##洸
+##洹
+##活
+##洼
+##洽
+##派
+##流
+##浃
+##浄
+##浅
+##浆
+##浇
+##浊
+##测
+##济
+##浏
+##浑
+##浒
+##浓
+##浔
+##浙
+##浚
+##浜
+##浣
+##浦
+##浩
+##浪
+##浬
+##浮
+##浯
+##浴
+##海
+##浸
+##涂
+##涅
+##涇
+##消
+##涉
+##涌
+##涎
+##涓
+##涔
+##涕
+##涙
+##涛
+##涝
+##涞
+##涟
+##涠
+##涡
+##涣
+##涤
+##润
+##涧
+##涨
+##涩
+##涪
+##涮
+##涯
+##液
+##涵
+##涸
+##涼
+##涿
+##淀
+##淄
+##淅
+##淆
+##淇
+##淋
+##淌
+##淑
+##淒
+##淖
+##淘
+##淙
+##淚
+##淞
+##淡
+##淤
+##淦
+##淨
+##淩
+##淪
+##淫
+##淬
+##淮
+##深
+##淳
+##淵
+##混
+##淹
+##淺
+##添
+##淼
+##清
+##済
+##渉
+##渊
+##渋
+##渍
+##渎
+##渐
+##渔
+##渗
+##渙
+##渚
+##減
+##渝
+##渠
+##渡
+##渣
+##渤
+##渥
+##渦
+##温
+##測
+##渭
+##港
+##渲
+##渴
+##游
+##渺
+##渾
+##湃
+##湄
+##湊
+##湍
+##湖
+##湘
+##湛
+##湟
+##湧
+##湫
+##湮
+##湯
+##湳
+##湾
+##湿
+##満
+##溃
+##溅
+##溉
+##溏
+##源
+##準
+##溜
+##溝
+##溟
+##溢
+##溥
+##溧
+##溪
+##溫
+##溯
+##溱
+##溴
+##溶
+##溺
+##溼
+##滁
+##滂
+##滄
+##滅
+##滇
+##滋
+##滌
+##滑
+##滓
+##滔
+##滕
+##滙
+##滚
+##滝
+##滞
+##滟
+##满
+##滢
+##滤
+##滥
+##滦
+##滨
+##滩
+##滬
+##滯
+##滲
+##滴
+##滷
+##滸
+##滾
+##滿
+##漁
+##漂
+##漆
+##漉
+##漏
+##漓
+##演
+##漕
+##漠
+##漢
+##漣
+##漩
+##漪
+##漫
+##漬
+##漯
+##漱
+##漲
+##漳
+##漸
+##漾
+##漿
+##潆
+##潇
+##潋
+##潍
+##潑
+##潔
+##潘
+##潛
+##潜
+##潞
+##潟
+##潢
+##潤
+##潦
+##潧
+##潭
+##潮
+##潰
+##潴
+##潸
+##潺
+##潼
+##澀
+##澄
+##澆
+##澈
+##澍
+##澎
+##澗
+##澜
+##澡
+##澤
+##澧
+##澱
+##澳
+##澹
+##激
+##濁
+##濂
+##濃
+##濑
+##濒
+##濕
+##濘
+##濛
+##濟
+##濠
+##濡
+##濤
+##濫
+##濬
+##濮
+##濯
+##濱
+##濺
+##濾
+##瀅
+##瀆
+##瀉
+##瀋
+##瀏
+##瀑
+##瀕
+##瀘
+##瀚
+##瀛
+##瀝
+##瀞
+##瀟
+##瀧
+##瀨
+##瀬
+##瀰
+##瀾
+##灌
+##灏
+##灑
+##灘
+##灝
+##灞
+##灣
+##火
+##灬
+##灭
+##灯
+##灰
+##灵
+##灶
+##灸
+##灼
+##災
+##灾
+##灿
+##炀
+##炁
+##炅
+##炉
+##炊
+##炎
+##炒
+##炔
+##炕
+##炖
+##炙
+##炜
+##炫
+##炬
+##炭
+##炮
+##炯
+##炳
+##炷
+##炸
+##点
+##為
+##炼
+##炽
+##烁
+##烂
+##烃
+##烈
+##烊
+##烏
+##烘
+##烙
+##烛
+##烟
+##烤
+##烦
+##烧
+##烨
+##烩
+##烫
+##烬
+##热
+##烯
+##烷
+##烹
+##烽
+##焉
+##焊
+##焕
+##焖
+##焗
+##焘
+##焙
+##焚
+##焜
+##無
+##焦
+##焯
+##焰
+##焱
+##然
+##焼
+##煅
+##煉
+##煊
+##煌
+##煎
+##煒
+##煖
+##煙
+##煜
+##煞
+##煤
+##煥
+##煦
+##照
+##煨
+##煩
+##煮
+##煲
+##煸
+##煽
+##熄
+##熊
+##熏
+##熒
+##熔
+##熙
+##熟
+##熠
+##熨
+##熬
+##熱
+##熵
+##熹
+##熾
+##燁
+##燃
+##燄
+##燈
+##燉
+##燊
+##燎
+##燒
+##燔
+##燕
+##燙
+##燜
+##營
+##燥
+##燦
+##燧
+##燭
+##燮
+##燴
+##燻
+##燼
+##燿
+##爆
+##爍
+##爐
+##爛
+##爪
+##爬
+##爭
+##爰
+##爱
+##爲
+##爵
+##父
+##爷
+##爸
+##爹
+##爺
+##爻
+##爽
+##爾
+##牆
+##片
+##版
+##牌
+##牍
+##牒
+##牙
+##牛
+##牝
+##牟
+##牠
+##牡
+##牢
+##牦
+##牧
+##物
+##牯
+##牲
+##牴
+##牵
+##特
+##牺
+##牽
+##犀
+##犁
+##犄
+##犊
+##犍
+##犒
+##犢
+##犧
+##犬
+##犯
+##状
+##犷
+##犸
+##犹
+##狀
+##狂
+##狄
+##狈
+##狎
+##狐
+##狒
+##狗
+##狙
+##狞
+##狠
+##狡
+##狩
+##独
+##狭
+##狮
+##狰
+##狱
+##狸
+##狹
+##狼
+##狽
+##猎
+##猕
+##猖
+##猗
+##猙
+##猛
+##猜
+##猝
+##猥
+##猩
+##猪
+##猫
+##猬
+##献
+##猴
+##猶
+##猷
+##猾
+##猿
+##獄
+##獅
+##獎
+##獐
+##獒
+##獗
+##獠
+##獣
+##獨
+##獭
+##獰
+##獲
+##獵
+##獷
+##獸
+##獺
+##獻
+##獼
+##獾
+##玄
+##率
+##玉
+##王
+##玑
+##玖
+##玛
+##玟
+##玠
+##玥
+##玩
+##玫
+##玮
+##环
+##现
+##玲
+##玳
+##玷
+##玺
+##玻
+##珀
+##珂
+##珅
+##珈
+##珉
+##珊
+##珍
+##珏
+##珐
+##珑
+##珙
+##珞
+##珠
+##珣
+##珥
+##珩
+##珪
+##班
+##珮
+##珲
+##珺
+##現
+##球
+##琅
+##理
+##琇
+##琉
+##琊
+##琍
+##琏
+##琐
+##琛
+##琢
+##琥
+##琦
+##琨
+##琪
+##琬
+##琮
+##琰
+##琲
+##琳
+##琴
+##琵
+##琶
+##琺
+##琼
+##瑀
+##瑁
+##瑄
+##瑋
+##瑕
+##瑗
+##瑙
+##瑚
+##瑛
+##瑜
+##瑞
+##瑟
+##瑠
+##瑣
+##瑤
+##瑩
+##瑪
+##瑯
+##瑰
+##瑶
+##瑾
+##璀
+##璁
+##璃
+##璇
+##璉
+##璋
+##璎
+##璐
+##璜
+##璞
+##璟
+##璧
+##璨
+##環
+##璽
+##璿
+##瓊
+##瓏
+##瓒
+##瓜
+##瓢
+##瓣
+##瓤
+##瓦
+##瓮
+##瓯
+##瓴
+##瓶
+##瓷
+##甄
+##甌
+##甕
+##甘
+##甙
+##甚
+##甜
+##生
+##產
+##産
+##甥
+##甦
+##用
+##甩
+##甫
+##甬
+##甭
+##甯
+##田
+##由
+##甲
+##申
+##电
+##男
+##甸
+##町
+##画
+##甾
+##畀
+##畅
+##界
+##畏
+##畑
+##畔
+##留
+##畜
+##畝
+##畢
+##略
+##畦
+##番
+##畫
+##異
+##畲
+##畳
+##畴
+##當
+##畸
+##畹
+##畿
+##疆
+##疇
+##疊
+##疏
+##疑
+##疔
+##疖
+##疗
+##疙
+##疚
+##疝
+##疟
+##疡
+##疣
+##疤
+##疥
+##疫
+##疮
+##疯
+##疱
+##疲
+##疳
+##疵
+##疸
+##疹
+##疼
+##疽
+##疾
+##痂
+##病
+##症
+##痈
+##痉
+##痊
+##痍
+##痒
+##痔
+##痕
+##痘
+##痙
+##痛
+##痞
+##痠
+##痢
+##痣
+##痤
+##痧
+##痨
+##痪
+##痫
+##痰
+##痱
+##痴
+##痹
+##痺
+##痼
+##痿
+##瘀
+##瘁
+##瘋
+##瘍
+##瘓
+##瘘
+##瘙
+##瘟
+##瘠
+##瘡
+##瘢
+##瘤
+##瘦
+##瘧
+##瘩
+##瘪
+##瘫
+##瘴
+##瘸
+##瘾
+##療
+##癇
+##癌
+##癒
+##癖
+##癜
+##癞
+##癡
+##癢
+##癣
+##癥
+##癫
+##癬
+##癮
+##癱
+##癲
+##癸
+##発
+##登
+##發
+##白
+##百
+##皂
+##的
+##皆
+##皇
+##皈
+##皋
+##皎
+##皑
+##皓
+##皖
+##皙
+##皚
+##皮
+##皰
+##皱
+##皴
+##皺
+##皿
+##盂
+##盃
+##盅
+##盆
+##盈
+##益
+##盎
+##盏
+##盐
+##监
+##盒
+##盔
+##盖
+##盗
+##盘
+##盛
+##盜
+##盞
+##盟
+##盡
+##監
+##盤
+##盥
+##盧
+##盪
+##目
+##盯
+##盱
+##盲
+##直
+##相
+##盹
+##盼
+##盾
+##省
+##眈
+##眉
+##看
+##県
+##眙
+##眞
+##真
+##眠
+##眦
+##眨
+##眩
+##眯
+##眶
+##眷
+##眸
+##眺
+##眼
+##眾
+##着
+##睁
+##睇
+##睏
+##睐
+##睑
+##睛
+##睜
+##睞
+##睡
+##睢
+##督
+##睥
+##睦
+##睨
+##睪
+##睫
+##睬
+##睹
+##睽
+##睾
+##睿
+##瞄
+##瞅
+##瞇
+##瞋
+##瞌
+##瞎
+##瞑
+##瞒
+##瞓
+##瞞
+##瞟
+##瞠
+##瞥
+##瞧
+##瞩
+##瞪
+##瞬
+##瞭
+##瞰
+##瞳
+##瞻
+##瞼
+##瞿
+##矇
+##矍
+##矗
+##矚
+##矛
+##矜
+##矢
+##矣
+##知
+##矩
+##矫
+##短
+##矮
+##矯
+##石
+##矶
+##矽
+##矾
+##矿
+##码
+##砂
+##砌
+##砍
+##砒
+##研
+##砖
+##砗
+##砚
+##砝
+##砣
+##砥
+##砧
+##砭
+##砰
+##砲
+##破
+##砷
+##砸
+##砺
+##砼
+##砾
+##础
+##硅
+##硐
+##硒
+##硕
+##硝
+##硫
+##硬
+##确
+##硯
+##硼
+##碁
+##碇
+##碉
+##碌
+##碍
+##碎
+##碑
+##碓
+##碗
+##碘
+##碚
+##碛
+##碟
+##碣
+##碧
+##碩
+##碰
+##碱
+##碳
+##碴
+##確
+##碼
+##碾
+##磁
+##磅
+##磊
+##磋
+##磐
+##磕
+##磚
+##磡
+##磨
+##磬
+##磯
+##磲
+##磷
+##磺
+##礁
+##礎
+##礙
+##礡
+##礦
+##礪
+##礫
+##礴
+##示
+##礼
+##社
+##祀
+##祁
+##祂
+##祇
+##祈
+##祉
+##祎
+##祐
+##祕
+##祖
+##祗
+##祚
+##祛
+##祜
+##祝
+##神
+##祟
+##祠
+##祢
+##祥
+##票
+##祭
+##祯
+##祷
+##祸
+##祺
+##祿
+##禀
+##禁
+##禄
+##禅
+##禍
+##禎
+##福
+##禛
+##禦
+##禧
+##禪
+##禮
+##禱
+##禹
+##禺
+##离
+##禽
+##禾
+##禿
+##秀
+##私
+##秃
+##秆
+##秉
+##秋
+##种
+##科
+##秒
+##秘
+##租
+##秣
+##秤
+##秦
+##秧
+##秩
+##秭
+##积
+##称
+##秸
+##移
+##秽
+##稀
+##稅
+##程
+##稍
+##税
+##稔
+##稗
+##稚
+##稜
+##稞
+##稟
+##稠
+##稣
+##種
+##稱
+##稲
+##稳
+##稷
+##稹
+##稻
+##稼
+##稽
+##稿
+##穀
+##穂
+##穆
+##穌
+##積
+##穎
+##穗
+##穢
+##穩
+##穫
+##穴
+##究
+##穷
+##穹
+##空
+##穿
+##突
+##窃
+##窄
+##窈
+##窍
+##窑
+##窒
+##窓
+##窕
+##窖
+##窗
+##窘
+##窜
+##窝
+##窟
+##窠
+##窥
+##窦
+##窨
+##窩
+##窪
+##窮
+##窯
+##窺
+##窿
+##竄
+##竅
+##竇
+##竊
+##立
+##竖
+##站
+##竜
+##竞
+##竟
+##章
+##竣
+##童
+##竭
+##端
+##競
+##竹
+##竺
+##竽
+##竿
+##笃
+##笆
+##笈
+##笋
+##笏
+##笑
+##笔
+##笙
+##笛
+##笞
+##笠
+##符
+##笨
+##第
+##笹
+##笺
+##笼
+##筆
+##等
+##筊
+##筋
+##筍
+##筏
+##筐
+##筑
+##筒
+##答
+##策
+##筛
+##筝
+##筠
+##筱
+##筲
+##筵
+##筷
+##筹
+##签
+##简
+##箇
+##箋
+##箍
+##箏
+##箐
+##箔
+##箕
+##算
+##箝
+##管
+##箩
+##箫
+##箭
+##箱
+##箴
+##箸
+##節
+##篁
+##範
+##篆
+##篇
+##築
+##篑
+##篓
+##篙
+##篝
+##篠
+##篡
+##篤
+##篩
+##篪
+##篮
+##篱
+##篷
+##簇
+##簌
+##簍
+##簡
+##簦
+##簧
+##簪
+##簫
+##簷
+##簸
+##簽
+##簾
+##簿
+##籁
+##籃
+##籌
+##籍
+##籐
+##籟
+##籠
+##籤
+##籬
+##籮
+##籲
+##米
+##类
+##籼
+##籽
+##粄
+##粉
+##粑
+##粒
+##粕
+##粗
+##粘
+##粟
+##粤
+##粥
+##粧
+##粪
+##粮
+##粱
+##粲
+##粳
+##粵
+##粹
+##粼
+##粽
+##精
+##粿
+##糅
+##糊
+##糍
+##糕
+##糖
+##糗
+##糙
+##糜
+##糞
+##糟
+##糠
+##糧
+##糬
+##糯
+##糰
+##糸
+##系
+##糾
+##紀
+##紂
+##約
+##紅
+##紉
+##紊
+##紋
+##納
+##紐
+##紓
+##純
+##紗
+##紘
+##紙
+##級
+##紛
+##紜
+##素
+##紡
+##索
+##紧
+##紫
+##紮
+##累
+##細
+##紳
+##紹
+##紺
+##終
+##絃
+##組
+##絆
+##経
+##結
+##絕
+##絞
+##絡
+##絢
+##給
+##絨
+##絮
+##統
+##絲
+##絳
+##絵
+##絶
+##絹
+##綁
+##綏
+##綑
+##經
+##継
+##続
+##綜
+##綠
+##綢
+##綦
+##綫
+##綬
+##維
+##綱
+##網
+##綴
+##綵
+##綸
+##綺
+##綻
+##綽
+##綾
+##綿
+##緊
+##緋
+##総
+##緑
+##緒
+##緘
+##線
+##緝
+##緞
+##締
+##緣
+##編
+##緩
+##緬
+##緯
+##練
+##緹
+##緻
+##縁
+##縄
+##縈
+##縛
+##縝
+##縣
+##縫
+##縮
+##縱
+##縴
+##縷
+##總
+##績
+##繁
+##繃
+##繆
+##繇
+##繋
+##織
+##繕
+##繚
+##繞
+##繡
+##繩
+##繪
+##繫
+##繭
+##繳
+##繹
+##繼
+##繽
+##纂
+##續
+##纍
+##纏
+##纓
+##纔
+##纖
+##纜
+##纠
+##红
+##纣
+##纤
+##约
+##级
+##纨
+##纪
+##纫
+##纬
+##纭
+##纯
+##纰
+##纱
+##纲
+##纳
+##纵
+##纶
+##纷
+##纸
+##纹
+##纺
+##纽
+##纾
+##线
+##绀
+##练
+##组
+##绅
+##细
+##织
+##终
+##绊
+##绍
+##绎
+##经
+##绑
+##绒
+##结
+##绔
+##绕
+##绘
+##给
+##绚
+##绛
+##络
+##绝
+##绞
+##统
+##绡
+##绢
+##绣
+##绥
+##绦
+##继
+##绩
+##绪
+##绫
+##续
+##绮
+##绯
+##绰
+##绳
+##维
+##绵
+##绶
+##绷
+##绸
+##绻
+##综
+##绽
+##绾
+##绿
+##缀
+##缄
+##缅
+##缆
+##缇
+##缈
+##缉
+##缎
+##缓
+##缔
+##缕
+##编
+##缘
+##缙
+##缚
+##缜
+##缝
+##缠
+##缢
+##缤
+##缥
+##缨
+##缩
+##缪
+##缭
+##缮
+##缰
+##缱
+##缴
+##缸
+##缺
+##缽
+##罂
+##罄
+##罌
+##罐
+##网
+##罔
+##罕
+##罗
+##罚
+##罡
+##罢
+##罩
+##罪
+##置
+##罰
+##署
+##罵
+##罷
+##罹
+##羁
+##羅
+##羈
+##羊
+##羌
+##美
+##羔
+##羚
+##羞
+##羟
+##羡
+##羣
+##群
+##羥
+##羧
+##羨
+##義
+##羯
+##羲
+##羸
+##羹
+##羽
+##羿
+##翁
+##翅
+##翊
+##翌
+##翎
+##習
+##翔
+##翘
+##翟
+##翠
+##翡
+##翦
+##翩
+##翰
+##翱
+##翳
+##翹
+##翻
+##翼
+##耀
+##老
+##考
+##耄
+##者
+##耆
+##耋
+##而
+##耍
+##耐
+##耒
+##耕
+##耗
+##耘
+##耙
+##耦
+##耨
+##耳
+##耶
+##耷
+##耸
+##耻
+##耽
+##耿
+##聂
+##聆
+##聊
+##聋
+##职
+##聒
+##联
+##聖
+##聘
+##聚
+##聞
+##聪
+##聯
+##聰
+##聲
+##聳
+##聴
+##聶
+##職
+##聽
+##聾
+##聿
+##肃
+##肄
+##肅
+##肆
+##肇
+##肉
+##肋
+##肌
+##肏
+##肓
+##肖
+##肘
+##肚
+##肛
+##肝
+##肠
+##股
+##肢
+##肤
+##肥
+##肩
+##肪
+##肮
+##肯
+##肱
+##育
+##肴
+##肺
+##肽
+##肾
+##肿
+##胀
+##胁
+##胃
+##胄
+##胆
+##背
+##胍
+##胎
+##胖
+##胚
+##胛
+##胜
+##胝
+##胞
+##胡
+##胤
+##胥
+##胧
+##胫
+##胭
+##胯
+##胰
+##胱
+##胳
+##胴
+##胶
+##胸
+##胺
+##能
+##脂
+##脅
+##脆
+##脇
+##脈
+##脉
+##脊
+##脍
+##脏
+##脐
+##脑
+##脓
+##脖
+##脘
+##脚
+##脛
+##脣
+##脩
+##脫
+##脯
+##脱
+##脲
+##脳
+##脸
+##脹
+##脾
+##腆
+##腈
+##腊
+##腋
+##腌
+##腎
+##腐
+##腑
+##腓
+##腔
+##腕
+##腥
+##腦
+##腩
+##腫
+##腭
+##腮
+##腰
+##腱
+##腳
+##腴
+##腸
+##腹
+##腺
+##腻
+##腼
+##腾
+##腿
+##膀
+##膈
+##膊
+##膏
+##膑
+##膘
+##膚
+##膛
+##膜
+##膝
+##膠
+##膦
+##膨
+##膩
+##膳
+##膺
+##膻
+##膽
+##膾
+##膿
+##臀
+##臂
+##臃
+##臆
+##臉
+##臊
+##臍
+##臓
+##臘
+##臟
+##臣
+##臥
+##臧
+##臨
+##自
+##臬
+##臭
+##至
+##致
+##臺
+##臻
+##臼
+##臾
+##舀
+##舂
+##舅
+##舆
+##與
+##興
+##舉
+##舊
+##舌
+##舍
+##舎
+##舐
+##舒
+##舔
+##舖
+##舗
+##舛
+##舜
+##舞
+##舟
+##航
+##舫
+##般
+##舰
+##舱
+##舵
+##舶
+##舷
+##舸
+##船
+##舺
+##舾
+##艇
+##艋
+##艘
+##艙
+##艦
+##艮
+##良
+##艰
+##艱
+##色
+##艳
+##艷
+##艹
+##艺
+##艾
+##节
+##芃
+##芈
+##芊
+##芋
+##芍
+##芎
+##芒
+##芙
+##芜
+##芝
+##芡
+##芥
+##芦
+##芩
+##芪
+##芫
+##芬
+##芭
+##芮
+##芯
+##花
+##芳
+##芷
+##芸
+##芹
+##芻
+##芽
+##芾
+##苁
+##苄
+##苇
+##苋
+##苍
+##苏
+##苑
+##苒
+##苓
+##苔
+##苕
+##苗
+##苛
+##苜
+##苞
+##苟
+##苡
+##苣
+##若
+##苦
+##苫
+##苯
+##英
+##苷
+##苹
+##苻
+##茁
+##茂
+##范
+##茄
+##茅
+##茉
+##茎
+##茏
+##茗
+##茜
+##茧
+##茨
+##茫
+##茬
+##茭
+##茯
+##茱
+##茲
+##茴
+##茵
+##茶
+##茸
+##茹
+##茼
+##荀
+##荃
+##荆
+##草
+##荊
+##荏
+##荐
+##荒
+##荔
+##荖
+##荘
+##荚
+##荞
+##荟
+##荠
+##荡
+##荣
+##荤
+##荥
+##荧
+##荨
+##荪
+##荫
+##药
+##荳
+##荷
+##荸
+##荻
+##荼
+##荽
+##莅
+##莆
+##莉
+##莊
+##莎
+##莒
+##莓
+##莖
+##莘
+##莞
+##莠
+##莢
+##莧
+##莪
+##莫
+##莱
+##莲
+##莴
+##获
+##莹
+##莺
+##莽
+##莿
+##菀
+##菁
+##菅
+##菇
+##菈
+##菊
+##菌
+##菏
+##菓
+##菖
+##菘
+##菜
+##菟
+##菠
+##菡
+##菩
+##華
+##菱
+##菲
+##菸
+##菽
+##萁
+##萃
+##萄
+##萊
+##萋
+##萌
+##萍
+##萎
+##萘
+##萝
+##萤
+##营
+##萦
+##萧
+##萨
+##萩
+##萬
+##萱
+##萵
+##萸
+##萼
+##落
+##葆
+##葉
+##著
+##葚
+##葛
+##葡
+##董
+##葦
+##葩
+##葫
+##葬
+##葭
+##葯
+##葱
+##葳
+##葵
+##葷
+##葺
+##蒂
+##蒋
+##蒐
+##蒔
+##蒙
+##蒜
+##蒞
+##蒟
+##蒡
+##蒨
+##蒲
+##蒸
+##蒹
+##蒻
+##蒼
+##蒿
+##蓁
+##蓄
+##蓆
+##蓉
+##蓋
+##蓑
+##蓓
+##蓖
+##蓝
+##蓟
+##蓦
+##蓬
+##蓮
+##蓼
+##蓿
+##蔑
+##蔓
+##蔔
+##蔗
+##蔘
+##蔚
+##蔡
+##蔣
+##蔥
+##蔫
+##蔬
+##蔭
+##蔵
+##蔷
+##蔺
+##蔻
+##蔼
+##蔽
+##蕁
+##蕃
+##蕈
+##蕉
+##蕊
+##蕎
+##蕙
+##蕤
+##蕨
+##蕩
+##蕪
+##蕭
+##蕲
+##蕴
+##蕻
+##蕾
+##薄
+##薅
+##薇
+##薈
+##薊
+##薏
+##薑
+##薔
+##薙
+##薛
+##薦
+##薨
+##薩
+##薪
+##薬
+##薯
+##薰
+##薹
+##藉
+##藍
+##藏
+##藐
+##藓
+##藕
+##藜
+##藝
+##藤
+##藥
+##藩
+##藹
+##藻
+##藿
+##蘆
+##蘇
+##蘊
+##蘋
+##蘑
+##蘚
+##蘭
+##蘸
+##蘼
+##蘿
+##虎
+##虏
+##虐
+##虑
+##虔
+##處
+##虚
+##虛
+##虜
+##虞
+##號
+##虢
+##虧
+##虫
+##虬
+##虱
+##虹
+##虻
+##虽
+##虾
+##蚀
+##蚁
+##蚂
+##蚊
+##蚌
+##蚓
+##蚕
+##蚜
+##蚝
+##蚣
+##蚤
+##蚩
+##蚪
+##蚯
+##蚱
+##蚵
+##蛀
+##蛆
+##蛇
+##蛊
+##蛋
+##蛎
+##蛐
+##蛔
+##蛙
+##蛛
+##蛟
+##蛤
+##蛭
+##蛮
+##蛰
+##蛳
+##蛹
+##蛻
+##蛾
+##蜀
+##蜂
+##蜃
+##蜆
+##蜇
+##蜈
+##蜊
+##蜍
+##蜒
+##蜓
+##蜕
+##蜗
+##蜘
+##蜚
+##蜜
+##蜡
+##蜢
+##蜥
+##蜱
+##蜴
+##蜷
+##蜻
+##蜿
+##蝇
+##蝈
+##蝉
+##蝌
+##蝎
+##蝕
+##蝗
+##蝙
+##蝟
+##蝠
+##蝦
+##蝨
+##蝴
+##蝶
+##蝸
+##蝼
+##螂
+##螃
+##融
+##螞
+##螢
+##螨
+##螯
+##螳
+##螺
+##蟀
+##蟄
+##蟆
+##蟋
+##蟎
+##蟑
+##蟒
+##蟠
+##蟬
+##蟲
+##蟹
+##蟻
+##蟾
+##蠅
+##蠍
+##蠔
+##蠕
+##蠛
+##蠟
+##蠡
+##蠢
+##蠣
+##蠱
+##蠶
+##蠹
+##蠻
+##血
+##衄
+##衅
+##衆
+##行
+##衍
+##術
+##衔
+##街
+##衙
+##衛
+##衝
+##衞
+##衡
+##衢
+##衣
+##补
+##表
+##衩
+##衫
+##衬
+##衮
+##衰
+##衲
+##衷
+##衹
+##衾
+##衿
+##袁
+##袂
+##袄
+##袅
+##袈
+##袋
+##袍
+##袒
+##袖
+##袜
+##袞
+##袤
+##袪
+##被
+##袭
+##袱
+##裁
+##裂
+##装
+##裆
+##裊
+##裏
+##裔
+##裕
+##裘
+##裙
+##補
+##裝
+##裟
+##裡
+##裤
+##裨
+##裱
+##裳
+##裴
+##裸
+##裹
+##製
+##裾
+##褂
+##複
+##褐
+##褒
+##褓
+##褔
+##褚
+##褥
+##褪
+##褫
+##褲
+##褶
+##褻
+##襁
+##襄
+##襟
+##襠
+##襪
+##襬
+##襯
+##襲
+##西
+##要
+##覃
+##覆
+##覇
+##見
+##規
+##覓
+##視
+##覚
+##覦
+##覧
+##親
+##覬
+##観
+##覷
+##覺
+##覽
+##觀
+##见
+##观
+##规
+##觅
+##视
+##览
+##觉
+##觊
+##觎
+##觐
+##觑
+##角
+##觞
+##解
+##觥
+##触
+##觸
+##言
+##訂
+##計
+##訊
+##討
+##訓
+##訕
+##訖
+##託
+##記
+##訛
+##訝
+##訟
+##訣
+##訥
+##訪
+##設
+##許
+##訳
+##訴
+##訶
+##診
+##註
+##証
+##詆
+##詐
+##詔
+##評
+##詛
+##詞
+##詠
+##詡
+##詢
+##詣
+##試
+##詩
+##詫
+##詬
+##詭
+##詮
+##詰
+##話
+##該
+##詳
+##詹
+##詼
+##誅
+##誇
+##誉
+##誌
+##認
+##誓
+##誕
+##誘
+##語
+##誠
+##誡
+##誣
+##誤
+##誥
+##誦
+##誨
+##說
+##説
+##読
+##誰
+##課
+##誹
+##誼
+##調
+##諄
+##談
+##請
+##諏
+##諒
+##論
+##諗
+##諜
+##諡
+##諦
+##諧
+##諫
+##諭
+##諮
+##諱
+##諳
+##諷
+##諸
+##諺
+##諾
+##謀
+##謁
+##謂
+##謄
+##謊
+##謎
+##謐
+##謔
+##謗
+##謙
+##講
+##謝
+##謠
+##謨
+##謬
+##謹
+##謾
+##譁
+##證
+##譎
+##譏
+##識
+##譙
+##譚
+##譜
+##警
+##譬
+##譯
+##議
+##譲
+##譴
+##護
+##譽
+##讀
+##變
+##讓
+##讚
+##讞
+##计
+##订
+##认
+##讥
+##讧
+##讨
+##让
+##讪
+##讫
+##训
+##议
+##讯
+##记
+##讲
+##讳
+##讴
+##讶
+##讷
+##许
+##讹
+##论
+##讼
+##讽
+##设
+##访
+##诀
+##证
+##诃
+##评
+##诅
+##识
+##诈
+##诉
+##诊
+##诋
+##词
+##诏
+##译
+##试
+##诗
+##诘
+##诙
+##诚
+##诛
+##话
+##诞
+##诟
+##诠
+##诡
+##询
+##诣
+##诤
+##该
+##详
+##诧
+##诩
+##诫
+##诬
+##语
+##误
+##诰
+##诱
+##诲
+##说
+##诵
+##诶
+##请
+##诸
+##诺
+##读
+##诽
+##课
+##诿
+##谀
+##谁
+##调
+##谄
+##谅
+##谆
+##谈
+##谊
+##谋
+##谌
+##谍
+##谎
+##谏
+##谐
+##谑
+##谒
+##谓
+##谔
+##谕
+##谗
+##谘
+##谙
+##谚
+##谛
+##谜
+##谟
+##谢
+##谣
+##谤
+##谥
+##谦
+##谧
+##谨
+##谩
+##谪
+##谬
+##谭
+##谯
+##谱
+##谲
+##谴
+##谶
+##谷
+##豁
+##豆
+##豇
+##豈
+##豉
+##豊
+##豌
+##豎
+##豐
+##豔
+##豚
+##象
+##豢
+##豪
+##豫
+##豬
+##豹
+##豺
+##貂
+##貅
+##貌
+##貓
+##貔
+##貘
+##貝
+##貞
+##負
+##財
+##貢
+##貧
+##貨
+##販
+##貪
+##貫
+##責
+##貯
+##貰
+##貳
+##貴
+##貶
+##買
+##貸
+##費
+##貼
+##貽
+##貿
+##賀
+##賁
+##賂
+##賃
+##賄
+##資
+##賈
+##賊
+##賑
+##賓
+##賜
+##賞
+##賠
+##賡
+##賢
+##賣
+##賤
+##賦
+##質
+##賬
+##賭
+##賴
+##賺
+##購
+##賽
+##贅
+##贈
+##贊
+##贍
+##贏
+##贓
+##贖
+##贛
+##贝
+##贞
+##负
+##贡
+##财
+##责
+##贤
+##败
+##账
+##货
+##质
+##贩
+##贪
+##贫
+##贬
+##购
+##贮
+##贯
+##贰
+##贱
+##贲
+##贴
+##贵
+##贷
+##贸
+##费
+##贺
+##贻
+##贼
+##贾
+##贿
+##赁
+##赂
+##赃
+##资
+##赅
+##赈
+##赊
+##赋
+##赌
+##赎
+##赏
+##赐
+##赓
+##赔
+##赖
+##赘
+##赚
+##赛
+##赝
+##赞
+##赠
+##赡
+##赢
+##赣
+##赤
+##赦
+##赧
+##赫
+##赭
+##走
+##赳
+##赴
+##赵
+##赶
+##起
+##趁
+##超
+##越
+##趋
+##趕
+##趙
+##趟
+##趣
+##趨
+##足
+##趴
+##趵
+##趸
+##趺
+##趾
+##跃
+##跄
+##跆
+##跋
+##跌
+##跎
+##跑
+##跖
+##跚
+##跛
+##距
+##跟
+##跡
+##跤
+##跨
+##跩
+##跪
+##路
+##跳
+##践
+##跷
+##跹
+##跺
+##跻
+##踉
+##踊
+##踌
+##踏
+##踐
+##踝
+##踞
+##踟
+##踢
+##踩
+##踪
+##踮
+##踱
+##踴
+##踵
+##踹
+##蹂
+##蹄
+##蹇
+##蹈
+##蹉
+##蹊
+##蹋
+##蹑
+##蹒
+##蹙
+##蹟
+##蹣
+##蹤
+##蹦
+##蹩
+##蹬
+##蹭
+##蹲
+##蹴
+##蹶
+##蹺
+##蹼
+##蹿
+##躁
+##躇
+##躉
+##躊
+##躋
+##躍
+##躏
+##躪
+##身
+##躬
+##躯
+##躲
+##躺
+##軀
+##車
+##軋
+##軌
+##軍
+##軒
+##軟
+##転
+##軸
+##軼
+##軽
+##軾
+##較
+##載
+##輒
+##輓
+##輔
+##輕
+##輛
+##輝
+##輟
+##輩
+##輪
+##輯
+##輸
+##輻
+##輾
+##輿
+##轄
+##轅
+##轆
+##轉
+##轍
+##轎
+##轟
+##车
+##轧
+##轨
+##轩
+##转
+##轭
+##轮
+##软
+##轰
+##轲
+##轴
+##轶
+##轻
+##轼
+##载
+##轿
+##较
+##辄
+##辅
+##辆
+##辇
+##辈
+##辉
+##辊
+##辍
+##辐
+##辑
+##输
+##辕
+##辖
+##辗
+##辘
+##辙
+##辛
+##辜
+##辞
+##辟
+##辣
+##辦
+##辨
+##辩
+##辫
+##辭
+##辮
+##辯
+##辰
+##辱
+##農
+##边
+##辺
+##辻
+##込
+##辽
+##达
+##迁
+##迂
+##迄
+##迅
+##过
+##迈
+##迎
+##运
+##近
+##返
+##还
+##这
+##进
+##远
+##违
+##连
+##迟
+##迢
+##迤
+##迥
+##迦
+##迩
+##迪
+##迫
+##迭
+##述
+##迴
+##迷
+##迸
+##迹
+##迺
+##追
+##退
+##送
+##适
+##逃
+##逅
+##逆
+##选
+##逊
+##逍
+##透
+##逐
+##递
+##途
+##逕
+##逗
+##這
+##通
+##逛
+##逝
+##逞
+##速
+##造
+##逢
+##連
+##逮
+##週
+##進
+##逵
+##逶
+##逸
+##逻
+##逼
+##逾
+##遁
+##遂
+##遅
+##遇
+##遊
+##運
+##遍
+##過
+##遏
+##遐
+##遑
+##遒
+##道
+##達
+##違
+##遗
+##遙
+##遛
+##遜
+##遞
+##遠
+##遢
+##遣
+##遥
+##遨
+##適
+##遭
+##遮
+##遲
+##遴
+##遵
+##遶
+##遷
+##選
+##遺
+##遼
+##遽
+##避
+##邀
+##邁
+##邂
+##邃
+##還
+##邇
+##邈
+##邊
+##邋
+##邏
+##邑
+##邓
+##邕
+##邛
+##邝
+##邢
+##那
+##邦
+##邨
+##邪
+##邬
+##邮
+##邯
+##邰
+##邱
+##邳
+##邵
+##邸
+##邹
+##邺
+##邻
+##郁
+##郅
+##郊
+##郎
+##郑
+##郜
+##郝
+##郡
+##郢
+##郤
+##郦
+##郧
+##部
+##郫
+##郭
+##郴
+##郵
+##郷
+##郸
+##都
+##鄂
+##鄉
+##鄒
+##鄔
+##鄙
+##鄞
+##鄢
+##鄧
+##鄭
+##鄰
+##鄱
+##鄲
+##鄺
+##酉
+##酊
+##酋
+##酌
+##配
+##酐
+##酒
+##酗
+##酚
+##酝
+##酢
+##酣
+##酥
+##酩
+##酪
+##酬
+##酮
+##酯
+##酰
+##酱
+##酵
+##酶
+##酷
+##酸
+##酿
+##醃
+##醇
+##醉
+##醋
+##醍
+##醐
+##醒
+##醚
+##醛
+##醜
+##醞
+##醣
+##醪
+##醫
+##醬
+##醮
+##醯
+##醴
+##醺
+##釀
+##釁
+##采
+##釉
+##释
+##釋
+##里
+##重
+##野
+##量
+##釐
+##金
+##釗
+##釘
+##釜
+##針
+##釣
+##釦
+##釧
+##釵
+##鈀
+##鈉
+##鈍
+##鈎
+##鈔
+##鈕
+##鈞
+##鈣
+##鈦
+##鈪
+##鈴
+##鈺
+##鈾
+##鉀
+##鉄
+##鉅
+##鉉
+##鉑
+##鉗
+##鉚
+##鉛
+##鉤
+##鉴
+##鉻
+##銀
+##銃
+##銅
+##銑
+##銓
+##銖
+##銘
+##銜
+##銬
+##銭
+##銮
+##銳
+##銷
+##銹
+##鋁
+##鋅
+##鋒
+##鋤
+##鋪
+##鋰
+##鋸
+##鋼
+##錄
+##錐
+##錘
+##錚
+##錠
+##錢
+##錦
+##錨
+##錫
+##錮
+##錯
+##録
+##錳
+##錶
+##鍊
+##鍋
+##鍍
+##鍛
+##鍥
+##鍰
+##鍵
+##鍺
+##鍾
+##鎂
+##鎊
+##鎌
+##鎏
+##鎔
+##鎖
+##鎗
+##鎚
+##鎧
+##鎬
+##鎮
+##鎳
+##鏈
+##鏖
+##鏗
+##鏘
+##鏞
+##鏟
+##鏡
+##鏢
+##鏤
+##鏽
+##鐘
+##鐮
+##鐲
+##鐳
+##鐵
+##鐸
+##鐺
+##鑄
+##鑊
+##鑑
+##鑒
+##鑣
+##鑫
+##鑰
+##鑲
+##鑼
+##鑽
+##鑾
+##鑿
+##针
+##钉
+##钊
+##钎
+##钏
+##钒
+##钓
+##钗
+##钙
+##钛
+##钜
+##钝
+##钞
+##钟
+##钠
+##钡
+##钢
+##钣
+##钤
+##钥
+##钦
+##钧
+##钨
+##钩
+##钮
+##钯
+##钰
+##钱
+##钳
+##钴
+##钵
+##钺
+##钻
+##钼
+##钾
+##钿
+##铀
+##铁
+##铂
+##铃
+##铄
+##铅
+##铆
+##铉
+##铎
+##铐
+##铛
+##铜
+##铝
+##铠
+##铡
+##铢
+##铣
+##铤
+##铨
+##铩
+##铬
+##铭
+##铮
+##铰
+##铲
+##铵
+##银
+##铸
+##铺
+##链
+##铿
+##销
+##锁
+##锂
+##锄
+##锅
+##锆
+##锈
+##锉
+##锋
+##锌
+##锏
+##锐
+##锑
+##错
+##锚
+##锟
+##锡
+##锢
+##锣
+##锤
+##锥
+##锦
+##锭
+##键
+##锯
+##锰
+##锲
+##锵
+##锹
+##锺
+##锻
+##镀
+##镁
+##镂
+##镇
+##镉
+##镌
+##镍
+##镐
+##镑
+##镕
+##镖
+##镗
+##镛
+##镜
+##镣
+##镭
+##镯
+##镰
+##镳
+##镶
+##長
+##长
+##門
+##閃
+##閉
+##開
+##閎
+##閏
+##閑
+##閒
+##間
+##閔
+##閘
+##閡
+##関
+##閣
+##閥
+##閨
+##閩
+##閱
+##閲
+##閹
+##閻
+##閾
+##闆
+##闇
+##闊
+##闌
+##闍
+##闔
+##闕
+##闖
+##闘
+##關
+##闡
+##闢
+##门
+##闪
+##闫
+##闭
+##问
+##闯
+##闰
+##闲
+##间
+##闵
+##闷
+##闸
+##闹
+##闺
+##闻
+##闽
+##闾
+##阀
+##阁
+##阂
+##阅
+##阆
+##阇
+##阈
+##阉
+##阎
+##阐
+##阑
+##阔
+##阕
+##阖
+##阙
+##阚
+##阜
+##队
+##阡
+##阪
+##阮
+##阱
+##防
+##阳
+##阴
+##阵
+##阶
+##阻
+##阿
+##陀
+##陂
+##附
+##际
+##陆
+##陇
+##陈
+##陋
+##陌
+##降
+##限
+##陕
+##陛
+##陝
+##陞
+##陟
+##陡
+##院
+##陣
+##除
+##陨
+##险
+##陪
+##陰
+##陲
+##陳
+##陵
+##陶
+##陷
+##陸
+##険
+##陽
+##隅
+##隆
+##隈
+##隊
+##隋
+##隍
+##階
+##随
+##隐
+##隔
+##隕
+##隘
+##隙
+##際
+##障
+##隠
+##隣
+##隧
+##隨
+##險
+##隱
+##隴
+##隶
+##隸
+##隻
+##隼
+##隽
+##难
+##雀
+##雁
+##雄
+##雅
+##集
+##雇
+##雉
+##雋
+##雌
+##雍
+##雎
+##雏
+##雑
+##雒
+##雕
+##雖
+##雙
+##雛
+##雜
+##雞
+##離
+##難
+##雨
+##雪
+##雯
+##雰
+##雲
+##雳
+##零
+##雷
+##雹
+##電
+##雾
+##需
+##霁
+##霄
+##霆
+##震
+##霈
+##霉
+##霊
+##霍
+##霎
+##霏
+##霑
+##霓
+##霖
+##霜
+##霞
+##霧
+##霭
+##霰
+##露
+##霸
+##霹
+##霽
+##霾
+##靂
+##靄
+##靈
+##青
+##靓
+##靖
+##静
+##靚
+##靛
+##靜
+##非
+##靠
+##靡
+##面
+##靥
+##靦
+##革
+##靳
+##靴
+##靶
+##靼
+##鞅
+##鞋
+##鞍
+##鞏
+##鞑
+##鞘
+##鞠
+##鞣
+##鞦
+##鞭
+##韆
+##韋
+##韌
+##韓
+##韜
+##韦
+##韧
+##韩
+##韬
+##韭
+##音
+##韵
+##韶
+##韻
+##響
+##頁
+##頂
+##頃
+##項
+##順
+##須
+##頌
+##預
+##頑
+##頒
+##頓
+##頗
+##領
+##頜
+##頡
+##頤
+##頫
+##頭
+##頰
+##頷
+##頸
+##頹
+##頻
+##頼
+##顆
+##題
+##額
+##顎
+##顏
+##顔
+##願
+##顛
+##類
+##顧
+##顫
+##顯
+##顱
+##顴
+##页
+##顶
+##顷
+##项
+##顺
+##须
+##顼
+##顽
+##顾
+##顿
+##颁
+##颂
+##预
+##颅
+##领
+##颇
+##颈
+##颉
+##颊
+##颌
+##颍
+##颐
+##频
+##颓
+##颔
+##颖
+##颗
+##题
+##颚
+##颛
+##颜
+##额
+##颞
+##颠
+##颡
+##颢
+##颤
+##颦
+##颧
+##風
+##颯
+##颱
+##颳
+##颶
+##颼
+##飄
+##飆
+##风
+##飒
+##飓
+##飕
+##飘
+##飙
+##飚
+##飛
+##飞
+##食
+##飢
+##飨
+##飩
+##飪
+##飯
+##飲
+##飼
+##飽
+##飾
+##餃
+##餅
+##餉
+##養
+##餌
+##餐
+##餒
+##餓
+##餘
+##餚
+##餛
+##餞
+##餡
+##館
+##餮
+##餵
+##餾
+##饅
+##饈
+##饋
+##饌
+##饍
+##饑
+##饒
+##饕
+##饗
+##饞
+##饥
+##饨
+##饪
+##饬
+##饭
+##饮
+##饯
+##饰
+##饱
+##饲
+##饴
+##饵
+##饶
+##饷
+##饺
+##饼
+##饽
+##饿
+##馀
+##馁
+##馄
+##馅
+##馆
+##馈
+##馋
+##馍
+##馏
+##馒
+##馔
+##首
+##馗
+##香
+##馥
+##馨
+##馬
+##馭
+##馮
+##馳
+##馴
+##駁
+##駄
+##駅
+##駆
+##駐
+##駒
+##駕
+##駛
+##駝
+##駭
+##駱
+##駿
+##騁
+##騎
+##騏
+##験
+##騙
+##騨
+##騰
+##騷
+##驀
+##驅
+##驊
+##驍
+##驒
+##驕
+##驗
+##驚
+##驛
+##驟
+##驢
+##驥
+##马
+##驭
+##驮
+##驯
+##驰
+##驱
+##驳
+##驴
+##驶
+##驷
+##驸
+##驹
+##驻
+##驼
+##驾
+##驿
+##骁
+##骂
+##骄
+##骅
+##骆
+##骇
+##骈
+##骊
+##骋
+##验
+##骏
+##骐
+##骑
+##骗
+##骚
+##骛
+##骜
+##骞
+##骠
+##骡
+##骤
+##骥
+##骧
+##骨
+##骯
+##骰
+##骶
+##骷
+##骸
+##骼
+##髂
+##髅
+##髋
+##髏
+##髒
+##髓
+##體
+##髖
+##高
+##髦
+##髪
+##髮
+##髯
+##髻
+##鬃
+##鬆
+##鬍
+##鬓
+##鬚
+##鬟
+##鬢
+##鬣
+##鬥
+##鬧
+##鬱
+##鬼
+##魁
+##魂
+##魄
+##魅
+##魇
+##魍
+##魏
+##魔
+##魘
+##魚
+##魯
+##魷
+##鮑
+##鮨
+##鮪
+##鮭
+##鮮
+##鯉
+##鯊
+##鯖
+##鯛
+##鯨
+##鯰
+##鯽
+##鰍
+##鰓
+##鰭
+##鰲
+##鰻
+##鰾
+##鱈
+##鱉
+##鱔
+##鱗
+##鱷
+##鱸
+##鱼
+##鱿
+##鲁
+##鲈
+##鲍
+##鲑
+##鲛
+##鲜
+##鲟
+##鲢
+##鲤
+##鲨
+##鲫
+##鲱
+##鲲
+##鲶
+##鲷
+##鲸
+##鳃
+##鳄
+##鳅
+##鳌
+##鳍
+##鳕
+##鳖
+##鳗
+##鳝
+##鳞
+##鳥
+##鳩
+##鳳
+##鳴
+##鳶
+##鴉
+##鴕
+##鴛
+##鴦
+##鴨
+##鴻
+##鴿
+##鵑
+##鵜
+##鵝
+##鵡
+##鵬
+##鵰
+##鵲
+##鶘
+##鶩
+##鶯
+##鶴
+##鷗
+##鷲
+##鷹
+##鷺
+##鸚
+##鸞
+##鸟
+##鸠
+##鸡
+##鸢
+##鸣
+##鸥
+##鸦
+##鸨
+##鸪
+##鸭
+##鸯
+##鸳
+##鸵
+##鸽
+##鸾
+##鸿
+##鹂
+##鹃
+##鹄
+##鹅
+##鹈
+##鹉
+##鹊
+##鹌
+##鹏
+##鹑
+##鹕
+##鹘
+##鹜
+##鹞
+##鹤
+##鹦
+##鹧
+##鹫
+##鹭
+##鹰
+##鹳
+##鹵
+##鹹
+##鹼
+##鹽
+##鹿
+##麂
+##麋
+##麒
+##麓
+##麗
+##麝
+##麟
+##麥
+##麦
+##麩
+##麴
+##麵
+##麸
+##麺
+##麻
+##麼
+##麽
+##麾
+##黃
+##黄
+##黍
+##黎
+##黏
+##黑
+##黒
+##黔
+##默
+##黛
+##黜
+##黝
+##點
+##黠
+##黨
+##黯
+##黴
+##鼋
+##鼎
+##鼐
+##鼓
+##鼠
+##鼬
+##鼹
+##鼻
+##鼾
+##齁
+##齊
+##齋
+##齐
+##齒
+##齡
+##齢
+##齣
+##齦
+##齿
+##龄
+##龅
+##龈
+##龊
+##龋
+##龌
+##龍
+##龐
+##龔
+##龕
+##龙
+##龚
+##龛
+##龜
+##龟
+##︰
+##︱
+##︶
+##︿
+##﹁
+##﹂
+##﹍
+##﹏
+##﹐
+##﹑
+##﹒
+##﹔
+##﹕
+##﹖
+##﹗
+##﹙
+##﹚
+##﹝
+##﹞
+##﹡
+##﹣
+##!
+##"
+###
+##$
+##%
+##&
+##'
+##(
+##)
+##*
+##,
+##-
+##.
+##/
+##:
+##;
+##<
+##?
+##@
+##[
+##\
+##]
+##^
+##_
+##`
+##f
+##h
+##j
+##u
+##w
+##z
+##{
+##}
+##。
+##「
+##」
+##、
+##・
+##ッ
+##ー
+##イ
+##ク
+##シ
+##ス
+##ト
+##ノ
+##フ
+##ラ
+##ル
+##ン
+##゙
+##゚
+## ̄
+##¥
+##👍
+##🔥
+##😂
+##😎
diff --git a/bert_gen.py b/bert_gen.py
new file mode 100644
index 0000000000000000000000000000000000000000..467655b2c4171608ad690fe7dec350db85f84f1b
--- /dev/null
+++ b/bert_gen.py
@@ -0,0 +1,53 @@
+import torch
+from torch.utils.data import DataLoader
+from multiprocessing import Pool
+import commons
+import utils
+from data_utils import TextAudioSpeakerLoader, TextAudioSpeakerCollate
+from tqdm import tqdm
+import warnings
+
+from text import cleaned_text_to_sequence, get_bert
+
+config_path = 'configs/config.json'
+hps = utils.get_hparams_from_file(config_path)
+
+def process_line(line):
+ _id, spk, language_str, text, phones, tone, word2ph = line.strip().split("|")
+ phone = phones.split(" ")
+ tone = [int(i) for i in tone.split(" ")]
+ word2ph = [int(i) for i in word2ph.split(" ")]
+ w2pho = [i for i in word2ph]
+ word2ph = [i for i in word2ph]
+ phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
+
+ if hps.data.add_blank:
+ phone = commons.intersperse(phone, 0)
+ tone = commons.intersperse(tone, 0)
+ language = commons.intersperse(language, 0)
+ for i in range(len(word2ph)):
+ word2ph[i] = word2ph[i] * 2
+ word2ph[0] += 1
+ wav_path = f'{_id}'
+
+ bert_path = wav_path.replace(".wav", ".bert.pt")
+ try:
+ bert = torch.load(bert_path)
+ assert bert.shape[-1] == len(phone)
+ except:
+ bert = get_bert(text, word2ph, language_str)
+ assert bert.shape[-1] == len(phone)
+ torch.save(bert, bert_path)
+
+
+if __name__ == '__main__':
+ lines = []
+ with open(hps.data.training_files, encoding='utf-8' ) as f:
+ lines.extend(f.readlines())
+
+ # with open(hps.data.validation_files, encoding='utf-8' ) as f:
+ # lines.extend(f.readlines())
+
+ with Pool(processes=2) as pool: #A100 40GB suitable config,if coom,please decrease the processess number.
+ for _ in tqdm(pool.imap_unordered(process_line, lines)):
+ pass
diff --git a/commons.py b/commons.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ad0444b61cbadaa388619986c2889c707d873ce
--- /dev/null
+++ b/commons.py
@@ -0,0 +1,161 @@
+import math
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+def init_weights(m, mean=0.0, std=0.01):
+ classname = m.__class__.__name__
+ if classname.find("Conv") != -1:
+ m.weight.data.normal_(mean, std)
+
+
+def get_padding(kernel_size, dilation=1):
+ return int((kernel_size*dilation - dilation)/2)
+
+
+def convert_pad_shape(pad_shape):
+ l = pad_shape[::-1]
+ pad_shape = [item for sublist in l for item in sublist]
+ return pad_shape
+
+
+def intersperse(lst, item):
+ result = [item] * (len(lst) * 2 + 1)
+ result[1::2] = lst
+ return result
+
+
+def kl_divergence(m_p, logs_p, m_q, logs_q):
+ """KL(P||Q)"""
+ kl = (logs_q - logs_p) - 0.5
+ kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
+ return kl
+
+
+def rand_gumbel(shape):
+ """Sample from the Gumbel distribution, protect from overflows."""
+ uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
+ return -torch.log(-torch.log(uniform_samples))
+
+
+def rand_gumbel_like(x):
+ g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
+ return g
+
+
+def slice_segments(x, ids_str, segment_size=4):
+ ret = torch.zeros_like(x[:, :, :segment_size])
+ for i in range(x.size(0)):
+ idx_str = ids_str[i]
+ idx_end = idx_str + segment_size
+ ret[i] = x[i, :, idx_str:idx_end]
+ return ret
+
+
+def rand_slice_segments(x, x_lengths=None, segment_size=4):
+ b, d, t = x.size()
+ if x_lengths is None:
+ x_lengths = t
+ ids_str_max = x_lengths - segment_size + 1
+ ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
+ ret = slice_segments(x, ids_str, segment_size)
+ return ret, ids_str
+
+
+def get_timing_signal_1d(
+ length, channels, min_timescale=1.0, max_timescale=1.0e4):
+ position = torch.arange(length, dtype=torch.float)
+ num_timescales = channels // 2
+ log_timescale_increment = (
+ math.log(float(max_timescale) / float(min_timescale)) /
+ (num_timescales - 1))
+ inv_timescales = min_timescale * torch.exp(
+ torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
+ scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
+ signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
+ signal = F.pad(signal, [0, 0, 0, channels % 2])
+ signal = signal.view(1, channels, length)
+ return signal
+
+
+def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
+ b, channels, length = x.size()
+ signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
+ return x + signal.to(dtype=x.dtype, device=x.device)
+
+
+def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
+ b, channels, length = x.size()
+ signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
+ return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
+
+
+def subsequent_mask(length):
+ mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
+ return mask
+
+
+@torch.jit.script
+def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
+ n_channels_int = n_channels[0]
+ in_act = input_a + input_b
+ t_act = torch.tanh(in_act[:, :n_channels_int, :])
+ s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
+ acts = t_act * s_act
+ return acts
+
+
+def convert_pad_shape(pad_shape):
+ l = pad_shape[::-1]
+ pad_shape = [item for sublist in l for item in sublist]
+ return pad_shape
+
+
+def shift_1d(x):
+ x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
+ return x
+
+
+def sequence_mask(length, max_length=None):
+ if max_length is None:
+ max_length = length.max()
+ x = torch.arange(max_length, dtype=length.dtype, device=length.device)
+ return x.unsqueeze(0) < length.unsqueeze(1)
+
+
+def generate_path(duration, mask):
+ """
+ duration: [b, 1, t_x]
+ mask: [b, 1, t_y, t_x]
+ """
+ device = duration.device
+
+ b, _, t_y, t_x = mask.shape
+ cum_duration = torch.cumsum(duration, -1)
+
+ cum_duration_flat = cum_duration.view(b * t_x)
+ path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
+ path = path.view(b, t_x, t_y)
+ path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
+ path = path.unsqueeze(1).transpose(2,3) * mask
+ return path
+
+
+def clip_grad_value_(parameters, clip_value, norm_type=2):
+ if isinstance(parameters, torch.Tensor):
+ parameters = [parameters]
+ parameters = list(filter(lambda p: p.grad is not None, parameters))
+ norm_type = float(norm_type)
+ if clip_value is not None:
+ clip_value = float(clip_value)
+
+ total_norm = 0
+ for p in parameters:
+ param_norm = p.grad.data.norm(norm_type)
+ total_norm += param_norm.item() ** norm_type
+ if clip_value is not None:
+ p.grad.data.clamp_(min=-clip_value, max=clip_value)
+ total_norm = total_norm ** (1. / norm_type)
+ return total_norm
diff --git a/configs/config.json b/configs/config.json
new file mode 100644
index 0000000000000000000000000000000000000000..5f08648536ee245534ee61ab229fae4cafbc4b66
--- /dev/null
+++ b/configs/config.json
@@ -0,0 +1,95 @@
+{
+ "train": {
+ "log_interval": 10,
+ "eval_interval": 500,
+ "seed": 52,
+ "epochs": 2000,
+ "learning_rate": 0.00015,
+ "betas": [
+ 0.8,
+ 0.99
+ ],
+ "eps": 1e-09,
+ "batch_size": 14,
+ "fp16_run": false,
+ "lr_decay": 0.999875,
+ "segment_size": 16384,
+ "init_lr_ratio": 1,
+ "warmup_epochs": 0,
+ "c_mel": 45,
+ "c_kl": 1.0
+ },
+ "data": {
+ "use_mel_posterior_encoder": false,
+ "training_files": "filelists/train.list",
+ "validation_files": "filelists/val.list",
+ "max_wav_value": 32768.0,
+ "sampling_rate": 44100,
+ "filter_length": 2048,
+ "hop_length": 512,
+ "win_length": 2048,
+ "n_mel_channels": 128,
+ "mel_fmin": 0.0,
+ "mel_fmax": null,
+ "add_blank": true,
+ "n_speakers": 1,
+ "cleaned_text": true,
+ "spk2id": {
+ "default": 0
+ }
+ },
+ "model": {
+ "use_spk_conditioned_encoder": true,
+ "use_noise_scaled_mas": true,
+ "use_mel_posterior_encoder": false,
+ "use_duration_discriminator": true,
+ "inter_channels": 192,
+ "hidden_channels": 192,
+ "filter_channels": 768,
+ "n_heads": 2,
+ "n_layers": 6,
+ "kernel_size": 3,
+ "p_dropout": 0.1,
+ "resblock": "1",
+ "resblock_kernel_sizes": [
+ 3,
+ 7,
+ 11
+ ],
+ "resblock_dilation_sizes": [
+ [
+ 1,
+ 3,
+ 5
+ ],
+ [
+ 1,
+ 3,
+ 5
+ ],
+ [
+ 1,
+ 3,
+ 5
+ ]
+ ],
+ "upsample_rates": [
+ 8,
+ 8,
+ 2,
+ 2,
+ 2
+ ],
+ "upsample_initial_channel": 512,
+ "upsample_kernel_sizes": [
+ 16,
+ 16,
+ 8,
+ 2,
+ 2
+ ],
+ "n_layers_q": 3,
+ "use_spectral_norm": false,
+ "gin_channels": 256
+ }
+}
\ No newline at end of file
diff --git a/data_utils.py b/data_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c98d3dc8b9572bd05859033a74d155425a2a2ab
--- /dev/null
+++ b/data_utils.py
@@ -0,0 +1,332 @@
+import time
+import os
+import random
+import numpy as np
+import torch
+import torch.utils.data
+import torchaudio
+import commons
+from mel_processing import spectrogram_torch, mel_spectrogram_torch, spec_to_mel_torch
+from utils import load_wav_to_torch, load_filepaths_and_text
+from text import cleaned_text_to_sequence, get_bert
+
+"""Multi speaker version"""
+
+
+class TextAudioSpeakerLoader(torch.utils.data.Dataset):
+ """
+ 1) loads audio, speaker_id, text pairs
+ 2) normalizes text and converts them to sequences of integers
+ 3) computes spectrograms from audio files.
+ """
+
+ def __init__(self, audiopaths_sid_text, hparams):
+ self.audiopaths_sid_text = load_filepaths_and_text(audiopaths_sid_text)
+ self.max_wav_value = hparams.max_wav_value
+ self.sampling_rate = hparams.sampling_rate
+ self.filter_length = hparams.filter_length
+ self.hop_length = hparams.hop_length
+ self.win_length = hparams.win_length
+ self.sampling_rate = hparams.sampling_rate
+ self.spk_map = hparams.spk2id
+ self.hparams = hparams
+
+ self.use_mel_spec_posterior = getattr(hparams, "use_mel_posterior_encoder", False)
+ if self.use_mel_spec_posterior:
+ self.n_mel_channels = getattr(hparams, "n_mel_channels", 80)
+
+ self.cleaned_text = getattr(hparams, "cleaned_text", False)
+
+ self.add_blank = hparams.add_blank
+ self.min_text_len = getattr(hparams, "min_text_len", 1)
+ self.max_text_len = getattr(hparams, "max_text_len", 300)
+
+ random.seed(1234)
+ random.shuffle(self.audiopaths_sid_text)
+ self._filter()
+
+ def _filter(self):
+ """
+ Filter text & store spec lengths
+ """
+ # Store spectrogram lengths for Bucketing
+ # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
+ # spec_length = wav_length // hop_length
+
+ audiopaths_sid_text_new = []
+ lengths = []
+ skipped = 0
+ for _id, spk, language, text, phones, tone, word2ph in self.audiopaths_sid_text:
+ audiopath = f'{_id}'
+ if self.min_text_len <= len(phones) and len(phones) <= self.max_text_len:
+ phones = phones.split(" ")
+ tone = [int(i) for i in tone.split(" ")]
+ word2ph = [int(i) for i in word2ph.split(" ")]
+ audiopaths_sid_text_new.append([audiopath, spk, language, text, phones, tone, word2ph])
+ lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
+ else:
+ skipped += 1
+ print("skipped: ", skipped, ", total: ", len(self.audiopaths_sid_text))
+ self.audiopaths_sid_text = audiopaths_sid_text_new
+ self.lengths = lengths
+
+ def get_audio_text_speaker_pair(self, audiopath_sid_text):
+ # separate filename, speaker_id and text
+ audiopath, sid, language, text, phones, tone, word2ph = audiopath_sid_text
+
+ bert, phones, tone, language = self.get_text(text, word2ph, phones, tone, language, audiopath)
+
+ spec, wav = self.get_audio(audiopath)
+ sid = torch.LongTensor([int(self.spk_map[sid])])
+ return (phones, spec, wav, sid, tone, language, bert)
+
+ def get_audio(self, filename):
+ audio_norm, sampling_rate = torchaudio.load(filename, frame_offset=0, num_frames=-1, normalize=True, channels_first=True)
+ '''
+ audio, sampling_rate = load_wav_to_torch(filename)
+ if sampling_rate != self.sampling_rate:
+ raise ValueError("{} {} SR doesn't match target {} SR".format(
+ sampling_rate, self.sampling_rate))
+ audio_norm = audio / self.max_wav_value
+ audio_norm = audio_norm.unsqueeze(0)
+ '''
+ spec_filename = filename.replace(".wav", ".spec.pt")
+ if self.use_mel_spec_posterior:
+ spec_filename = spec_filename.replace(".spec.pt", ".mel.pt")
+ if os.path.exists(spec_filename):
+ spec = torch.load(spec_filename)
+ else:
+ if self.use_mel_spec_posterior:
+ # if os.path.exists(filename.replace(".wav", ".spec.pt")):
+ # # spec, n_fft, num_mels, sampling_rate, fmin, fmax
+ # spec = spec_to_mel_torch(
+ # torch.load(filename.replace(".wav", ".spec.pt")),
+ # self.filter_length, self.n_mel_channels, self.sampling_rate,
+ # self.hparams.mel_fmin, self.hparams.mel_fmax)
+ spec = mel_spectrogram_torch(audio_norm, self.filter_length,
+ self.n_mel_channels, self.sampling_rate, self.hop_length,
+ self.win_length, self.hparams.mel_fmin, self.hparams.mel_fmax, center=False)
+ else:
+ spec = spectrogram_torch(audio_norm, self.filter_length,
+ self.sampling_rate, self.hop_length, self.win_length,
+ center=False)
+ spec = torch.squeeze(spec, 0)
+ torch.save(spec, spec_filename)
+ return spec, audio_norm
+
+ def get_text(self, text, word2ph, phone, tone, language_str, wav_path):
+ # print(text, word2ph,phone, tone, language_str)
+ pold = phone
+ w2pho = [i for i in word2ph]
+ word2ph = [i for i in word2ph]
+ phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
+ pold2 = phone
+
+ if self.add_blank:
+ p1 = len(phone)
+ phone = commons.intersperse(phone, 0)
+ p2 = len(phone)
+ t1 = len(tone)
+ tone = commons.intersperse(tone, 0)
+ t2 = len(tone)
+ language = commons.intersperse(language, 0)
+ for i in range(len(word2ph)):
+ word2ph[i] = word2ph[i] * 2
+ word2ph[0] += 1
+ bert_path = wav_path.replace(".wav", ".bert.pt")
+ try:
+ bert = torch.load(bert_path)
+ assert bert.shape[-1] == len(phone)
+ except:
+ bert = get_bert(text, word2ph, language_str)
+ torch.save(bert, bert_path)
+ #print(bert.shape[-1], bert_path, text, pold)
+ assert bert.shape[-1] == len(phone)
+
+ assert bert.shape[-1] == len(phone), (
+ bert.shape, len(phone), sum(word2ph), p1, p2, t1, t2, pold, pold2, word2ph, text, w2pho)
+ phone = torch.LongTensor(phone)
+ tone = torch.LongTensor(tone)
+ language = torch.LongTensor(language)
+ return bert, phone, tone, language
+
+ def get_sid(self, sid):
+ sid = torch.LongTensor([int(sid)])
+ return sid
+
+ def __getitem__(self, index):
+ return self.get_audio_text_speaker_pair(self.audiopaths_sid_text[index])
+
+ def __len__(self):
+ return len(self.audiopaths_sid_text)
+
+
+class TextAudioSpeakerCollate():
+ """ Zero-pads model inputs and targets
+ """
+
+ def __init__(self, return_ids=False):
+ self.return_ids = return_ids
+
+ def __call__(self, batch):
+ """Collate's training batch from normalized text, audio and speaker identities
+ PARAMS
+ ------
+ batch: [text_normalized, spec_normalized, wav_normalized, sid]
+ """
+ # Right zero-pad all one-hot text sequences to max input length
+ _, ids_sorted_decreasing = torch.sort(
+ torch.LongTensor([x[1].size(1) for x in batch]),
+ dim=0, descending=True)
+
+ max_text_len = max([len(x[0]) for x in batch])
+ max_spec_len = max([x[1].size(1) for x in batch])
+ max_wav_len = max([x[2].size(1) for x in batch])
+
+ text_lengths = torch.LongTensor(len(batch))
+ spec_lengths = torch.LongTensor(len(batch))
+ wav_lengths = torch.LongTensor(len(batch))
+ sid = torch.LongTensor(len(batch))
+
+ text_padded = torch.LongTensor(len(batch), max_text_len)
+ tone_padded = torch.LongTensor(len(batch), max_text_len)
+ language_padded = torch.LongTensor(len(batch), max_text_len)
+ bert_padded = torch.FloatTensor(len(batch), 1024, max_text_len)
+
+ spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len)
+ wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
+ text_padded.zero_()
+ tone_padded.zero_()
+ language_padded.zero_()
+ spec_padded.zero_()
+ wav_padded.zero_()
+ bert_padded.zero_()
+ for i in range(len(ids_sorted_decreasing)):
+ row = batch[ids_sorted_decreasing[i]]
+
+ text = row[0]
+ text_padded[i, :text.size(0)] = text
+ text_lengths[i] = text.size(0)
+
+ spec = row[1]
+ spec_padded[i, :, :spec.size(1)] = spec
+ spec_lengths[i] = spec.size(1)
+
+ wav = row[2]
+ wav_padded[i, :, :wav.size(1)] = wav
+ wav_lengths[i] = wav.size(1)
+
+ sid[i] = row[3]
+
+ tone = row[4]
+ tone_padded[i, :tone.size(0)] = tone
+
+ language = row[5]
+ language_padded[i, :language.size(0)] = language
+
+ bert = row[6]
+ bert_padded[i, :, :bert.size(1)] = bert
+
+ return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, sid, tone_padded, language_padded, bert_padded
+
+
+class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
+ """
+ Maintain similar input lengths in a batch.
+ Length groups are specified by boundaries.
+ Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}.
+
+ It removes samples which are not included in the boundaries.
+ Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded.
+ """
+
+ def __init__(self, dataset, batch_size, boundaries, num_replicas=None, rank=None, shuffle=True):
+ super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
+ self.lengths = dataset.lengths
+ self.batch_size = batch_size
+ self.boundaries = boundaries
+
+ self.buckets, self.num_samples_per_bucket = self._create_buckets()
+ self.total_size = sum(self.num_samples_per_bucket)
+ self.num_samples = self.total_size // self.num_replicas
+
+ def _create_buckets(self):
+ buckets = [[] for _ in range(len(self.boundaries) - 1)]
+ for i in range(len(self.lengths)):
+ length = self.lengths[i]
+ idx_bucket = self._bisect(length)
+ if idx_bucket != -1:
+ buckets[idx_bucket].append(i)
+
+ for i in range(len(buckets) - 1, 0, -1):
+ if len(buckets[i]) == 0:
+ buckets.pop(i)
+ self.boundaries.pop(i + 1)
+
+ num_samples_per_bucket = []
+ for i in range(len(buckets)):
+ len_bucket = len(buckets[i])
+ total_batch_size = self.num_replicas * self.batch_size
+ rem = (total_batch_size - (len_bucket % total_batch_size)) % total_batch_size
+ num_samples_per_bucket.append(len_bucket + rem)
+ return buckets, num_samples_per_bucket
+
+ def __iter__(self):
+ # deterministically shuffle based on epoch
+ g = torch.Generator()
+ g.manual_seed(self.epoch)
+
+ indices = []
+ if self.shuffle:
+ for bucket in self.buckets:
+ indices.append(torch.randperm(len(bucket), generator=g).tolist())
+ else:
+ for bucket in self.buckets:
+ indices.append(list(range(len(bucket))))
+
+ batches = []
+ for i in range(len(self.buckets)):
+ bucket = self.buckets[i]
+ len_bucket = len(bucket)
+ if (len_bucket == 0):
+ continue
+ ids_bucket = indices[i]
+ num_samples_bucket = self.num_samples_per_bucket[i]
+
+ # add extra samples to make it evenly divisible
+ rem = num_samples_bucket - len_bucket
+ ids_bucket = ids_bucket + ids_bucket * (rem // len_bucket) + ids_bucket[:(rem % len_bucket)]
+
+ # subsample
+ ids_bucket = ids_bucket[self.rank::self.num_replicas]
+
+ # batching
+ for j in range(len(ids_bucket) // self.batch_size):
+ batch = [bucket[idx] for idx in ids_bucket[j * self.batch_size:(j + 1) * self.batch_size]]
+ batches.append(batch)
+
+ if self.shuffle:
+ batch_ids = torch.randperm(len(batches), generator=g).tolist()
+ batches = [batches[i] for i in batch_ids]
+ self.batches = batches
+
+ assert len(self.batches) * self.batch_size == self.num_samples
+ return iter(self.batches)
+
+ def _bisect(self, x, lo=0, hi=None):
+ if hi is None:
+ hi = len(self.boundaries) - 1
+
+ if hi > lo:
+ mid = (hi + lo) // 2
+ if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]:
+ return mid
+ elif x <= self.boundaries[mid]:
+ return self._bisect(x, lo, mid)
+ else:
+ return self._bisect(x, mid + 1, hi)
+ else:
+ return -1
+
+ def __len__(self):
+ return self.num_samples // self.batch_size
diff --git a/losses.py b/losses.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb22a0e834dd87edaa37bb8190eee2c3c7abe0d5
--- /dev/null
+++ b/losses.py
@@ -0,0 +1,61 @@
+import torch
+from torch.nn import functional as F
+
+import commons
+
+
+def feature_loss(fmap_r, fmap_g):
+ loss = 0
+ for dr, dg in zip(fmap_r, fmap_g):
+ for rl, gl in zip(dr, dg):
+ rl = rl.float().detach()
+ gl = gl.float()
+ loss += torch.mean(torch.abs(rl - gl))
+
+ return loss * 2
+
+
+def discriminator_loss(disc_real_outputs, disc_generated_outputs):
+ loss = 0
+ r_losses = []
+ g_losses = []
+ for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
+ dr = dr.float()
+ dg = dg.float()
+ r_loss = torch.mean((1-dr)**2)
+ g_loss = torch.mean(dg**2)
+ loss += (r_loss + g_loss)
+ r_losses.append(r_loss.item())
+ g_losses.append(g_loss.item())
+
+ return loss, r_losses, g_losses
+
+
+def generator_loss(disc_outputs):
+ loss = 0
+ gen_losses = []
+ for dg in disc_outputs:
+ dg = dg.float()
+ l = torch.mean((1-dg)**2)
+ gen_losses.append(l)
+ loss += l
+
+ return loss, gen_losses
+
+
+def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
+ """
+ z_p, logs_q: [b, h, t_t]
+ m_p, logs_p: [b, h, t_t]
+ """
+ z_p = z_p.float()
+ logs_q = logs_q.float()
+ m_p = m_p.float()
+ logs_p = logs_p.float()
+ z_mask = z_mask.float()
+
+ kl = logs_p - logs_q - 0.5
+ kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p)
+ kl = torch.sum(kl * z_mask)
+ l = kl / torch.sum(z_mask)
+ return l
diff --git a/mel_processing.py b/mel_processing.py
new file mode 100644
index 0000000000000000000000000000000000000000..50435ecf88ef4fb6c1d47f3e6edd04c3ea7d3e80
--- /dev/null
+++ b/mel_processing.py
@@ -0,0 +1,112 @@
+import math
+import os
+import random
+import torch
+from torch import nn
+import torch.nn.functional as F
+import torch.utils.data
+import numpy as np
+import librosa
+import librosa.util as librosa_util
+from librosa.util import normalize, pad_center, tiny
+from scipy.signal import get_window
+from scipy.io.wavfile import read
+from librosa.filters import mel as librosa_mel_fn
+
+MAX_WAV_VALUE = 32768.0
+
+
+def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
+ """
+ PARAMS
+ ------
+ C: compression factor
+ """
+ return torch.log(torch.clamp(x, min=clip_val) * C)
+
+
+def dynamic_range_decompression_torch(x, C=1):
+ """
+ PARAMS
+ ------
+ C: compression factor used to compress
+ """
+ return torch.exp(x) / C
+
+
+def spectral_normalize_torch(magnitudes):
+ output = dynamic_range_compression_torch(magnitudes)
+ return output
+
+
+def spectral_de_normalize_torch(magnitudes):
+ output = dynamic_range_decompression_torch(magnitudes)
+ return output
+
+
+mel_basis = {}
+hann_window = {}
+
+
+def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
+ if torch.min(y) < -1.:
+ print('min value is ', torch.min(y))
+ if torch.max(y) > 1.:
+ print('max value is ', torch.max(y))
+
+ global hann_window
+ dtype_device = str(y.dtype) + '_' + str(y.device)
+ wnsize_dtype_device = str(win_size) + '_' + dtype_device
+ if wnsize_dtype_device not in hann_window:
+ hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
+
+ y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
+ y = y.squeeze(1)
+
+ spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
+ center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
+
+ spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
+ return spec
+
+
+def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
+ global mel_basis
+ dtype_device = str(spec.dtype) + '_' + str(spec.device)
+ fmax_dtype_device = str(fmax) + '_' + dtype_device
+ if fmax_dtype_device not in mel_basis:
+ mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
+ mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
+ spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
+ spec = spectral_normalize_torch(spec)
+ return spec
+
+
+def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
+ if torch.min(y) < -1.:
+ print('min value is ', torch.min(y))
+ if torch.max(y) > 1.:
+ print('max value is ', torch.max(y))
+
+ global mel_basis, hann_window
+ dtype_device = str(y.dtype) + '_' + str(y.device)
+ fmax_dtype_device = str(fmax) + '_' + dtype_device
+ wnsize_dtype_device = str(win_size) + '_' + dtype_device
+ if fmax_dtype_device not in mel_basis:
+ mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
+ mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
+ if wnsize_dtype_device not in hann_window:
+ hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
+
+ y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
+ y = y.squeeze(1)
+
+ spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
+ center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
+
+ spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
+
+ spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
+ spec = spectral_normalize_torch(spec)
+
+ return spec
diff --git a/models.py b/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4afe44d883691610c5903e602a3ca245fcb3a5c
--- /dev/null
+++ b/models.py
@@ -0,0 +1,707 @@
+import copy
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import commons
+import modules
+import attentions
+import monotonic_align
+
+from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
+from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
+
+from commons import init_weights, get_padding
+from text import symbols, num_tones, num_languages
+class DurationDiscriminator(nn.Module): #vits2
+ def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
+ super().__init__()
+
+ self.in_channels = in_channels
+ self.filter_channels = filter_channels
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.gin_channels = gin_channels
+
+ self.drop = nn.Dropout(p_dropout)
+ self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size//2)
+ self.norm_1 = modules.LayerNorm(filter_channels)
+ self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
+ self.norm_2 = modules.LayerNorm(filter_channels)
+ self.dur_proj = nn.Conv1d(1, filter_channels, 1)
+
+ self.pre_out_conv_1 = nn.Conv1d(2*filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
+ self.pre_out_norm_1 = modules.LayerNorm(filter_channels)
+ self.pre_out_conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
+ self.pre_out_norm_2 = modules.LayerNorm(filter_channels)
+
+ if gin_channels != 0:
+ self.cond = nn.Conv1d(gin_channels, in_channels, 1)
+
+ self.output_layer = nn.Sequential(
+ nn.Linear(filter_channels, 1),
+ nn.Sigmoid()
+ )
+
+ def forward_probability(self, x, x_mask, dur, g=None):
+ dur = self.dur_proj(dur)
+ x = torch.cat([x, dur], dim=1)
+ x = self.pre_out_conv_1(x * x_mask)
+ x = torch.relu(x)
+ x = self.pre_out_norm_1(x)
+ x = self.drop(x)
+ x = self.pre_out_conv_2(x * x_mask)
+ x = torch.relu(x)
+ x = self.pre_out_norm_2(x)
+ x = self.drop(x)
+ x = x * x_mask
+ x = x.transpose(1, 2)
+ output_prob = self.output_layer(x)
+ return output_prob
+
+ def forward(self, x, x_mask, dur_r, dur_hat, g=None):
+ x = torch.detach(x)
+ if g is not None:
+ g = torch.detach(g)
+ x = x + self.cond(g)
+ x = self.conv_1(x * x_mask)
+ x = torch.relu(x)
+ x = self.norm_1(x)
+ x = self.drop(x)
+ x = self.conv_2(x * x_mask)
+ x = torch.relu(x)
+ x = self.norm_2(x)
+ x = self.drop(x)
+
+ output_probs = []
+ for dur in [dur_r, dur_hat]:
+ output_prob = self.forward_probability(x, x_mask, dur, g)
+ output_probs.append(output_prob)
+
+ return output_probs
+
+class TransformerCouplingBlock(nn.Module):
+ def __init__(self,
+ channels,
+ hidden_channels,
+ filter_channels,
+ n_heads,
+ n_layers,
+ kernel_size,
+ p_dropout,
+ n_flows=4,
+ gin_channels=0,
+ share_parameter=False
+ ):
+
+ super().__init__()
+ self.channels = channels
+ self.hidden_channels = hidden_channels
+ self.kernel_size = kernel_size
+ self.n_layers = n_layers
+ self.n_flows = n_flows
+ self.gin_channels = gin_channels
+
+ self.flows = nn.ModuleList()
+
+ self.wn = attentions.FFT(hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout, isflow = True, gin_channels = self.gin_channels) if share_parameter else None
+
+ for i in range(n_flows):
+ self.flows.append(
+ modules.TransformerCouplingLayer(channels, hidden_channels, kernel_size, n_layers, n_heads, p_dropout, filter_channels, mean_only=True, wn_sharing_parameter=self.wn, gin_channels = self.gin_channels))
+ self.flows.append(modules.Flip())
+
+ def forward(self, x, x_mask, g=None, reverse=False):
+ if not reverse:
+ for flow in self.flows:
+ x, _ = flow(x, x_mask, g=g, reverse=reverse)
+ else:
+ for flow in reversed(self.flows):
+ x = flow(x, x_mask, g=g, reverse=reverse)
+ return x
+
+class StochasticDurationPredictor(nn.Module):
+ def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
+ super().__init__()
+ filter_channels = in_channels # it needs to be removed from future version.
+ self.in_channels = in_channels
+ self.filter_channels = filter_channels
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.n_flows = n_flows
+ self.gin_channels = gin_channels
+
+ self.log_flow = modules.Log()
+ self.flows = nn.ModuleList()
+ self.flows.append(modules.ElementwiseAffine(2))
+ for i in range(n_flows):
+ self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
+ self.flows.append(modules.Flip())
+
+ self.post_pre = nn.Conv1d(1, filter_channels, 1)
+ self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
+ self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
+ self.post_flows = nn.ModuleList()
+ self.post_flows.append(modules.ElementwiseAffine(2))
+ for i in range(4):
+ self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
+ self.post_flows.append(modules.Flip())
+
+ self.pre = nn.Conv1d(in_channels, filter_channels, 1)
+ self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
+ self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
+ if gin_channels != 0:
+ self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
+
+ def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
+ x = torch.detach(x)
+ x = self.pre(x)
+ if g is not None:
+ g = torch.detach(g)
+ x = x + self.cond(g)
+ x = self.convs(x, x_mask)
+ x = self.proj(x) * x_mask
+
+ if not reverse:
+ flows = self.flows
+ assert w is not None
+
+ logdet_tot_q = 0
+ h_w = self.post_pre(w)
+ h_w = self.post_convs(h_w, x_mask)
+ h_w = self.post_proj(h_w) * x_mask
+ e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
+ z_q = e_q
+ for flow in self.post_flows:
+ z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
+ logdet_tot_q += logdet_q
+ z_u, z1 = torch.split(z_q, [1, 1], 1)
+ u = torch.sigmoid(z_u) * x_mask
+ z0 = (w - u) * x_mask
+ logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1, 2])
+ logq = torch.sum(-0.5 * (math.log(2 * math.pi) + (e_q ** 2)) * x_mask, [1, 2]) - logdet_tot_q
+
+ logdet_tot = 0
+ z0, logdet = self.log_flow(z0, x_mask)
+ logdet_tot += logdet
+ z = torch.cat([z0, z1], 1)
+ for flow in flows:
+ z, logdet = flow(z, x_mask, g=x, reverse=reverse)
+ logdet_tot = logdet_tot + logdet
+ nll = torch.sum(0.5 * (math.log(2 * math.pi) + (z ** 2)) * x_mask, [1, 2]) - logdet_tot
+ return nll + logq # [b]
+ else:
+ flows = list(reversed(self.flows))
+ flows = flows[:-2] + [flows[-1]] # remove a useless vflow
+ z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
+ for flow in flows:
+ z = flow(z, x_mask, g=x, reverse=reverse)
+ z0, z1 = torch.split(z, [1, 1], 1)
+ logw = z0
+ return logw
+
+
+class DurationPredictor(nn.Module):
+ def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
+ super().__init__()
+
+ self.in_channels = in_channels
+ self.filter_channels = filter_channels
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.gin_channels = gin_channels
+
+ self.drop = nn.Dropout(p_dropout)
+ self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size // 2)
+ self.norm_1 = modules.LayerNorm(filter_channels)
+ self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size // 2)
+ self.norm_2 = modules.LayerNorm(filter_channels)
+ self.proj = nn.Conv1d(filter_channels, 1, 1)
+
+ if gin_channels != 0:
+ self.cond = nn.Conv1d(gin_channels, in_channels, 1)
+
+ def forward(self, x, x_mask, g=None):
+ x = torch.detach(x)
+ if g is not None:
+ g = torch.detach(g)
+ x = x + self.cond(g)
+ x = self.conv_1(x * x_mask)
+ x = torch.relu(x)
+ x = self.norm_1(x)
+ x = self.drop(x)
+ x = self.conv_2(x * x_mask)
+ x = torch.relu(x)
+ x = self.norm_2(x)
+ x = self.drop(x)
+ x = self.proj(x * x_mask)
+ return x * x_mask
+
+
+class TextEncoder(nn.Module):
+ def __init__(self,
+ n_vocab,
+ out_channels,
+ hidden_channels,
+ filter_channels,
+ n_heads,
+ n_layers,
+ kernel_size,
+ p_dropout,
+ gin_channels=0):
+ super().__init__()
+ self.n_vocab = n_vocab
+ self.out_channels = out_channels
+ self.hidden_channels = hidden_channels
+ self.filter_channels = filter_channels
+ self.n_heads = n_heads
+ self.n_layers = n_layers
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.gin_channels = gin_channels
+ self.emb = nn.Embedding(len(symbols), hidden_channels)
+ nn.init.normal_(self.emb.weight, 0.0, hidden_channels ** -0.5)
+ self.tone_emb = nn.Embedding(num_tones, hidden_channels)
+ nn.init.normal_(self.tone_emb.weight, 0.0, hidden_channels ** -0.5)
+ self.language_emb = nn.Embedding(num_languages, hidden_channels)
+ nn.init.normal_(self.language_emb.weight, 0.0, hidden_channels ** -0.5)
+ self.bert_proj = nn.Conv1d(1024, hidden_channels, 1)
+
+ self.encoder = attentions.Encoder(
+ hidden_channels,
+ filter_channels,
+ n_heads,
+ n_layers,
+ kernel_size,
+ p_dropout,
+ gin_channels=self.gin_channels)
+ self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+ def forward(self, x, x_lengths, tone, language, bert, g=None):
+ x = (self.emb(x)+ self.tone_emb(tone)+ self.language_emb(language)+self.bert_proj(bert).transpose(1,2)) * math.sqrt(self.hidden_channels) # [b, t, h]
+ x = torch.transpose(x, 1, -1) # [b, h, t]
+ x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+
+ x = self.encoder(x * x_mask, x_mask, g=g)
+ stats = self.proj(x) * x_mask
+
+ m, logs = torch.split(stats, self.out_channels, dim=1)
+ return x, m, logs, x_mask
+
+
+class ResidualCouplingBlock(nn.Module):
+ def __init__(self,
+ channels,
+ hidden_channels,
+ kernel_size,
+ dilation_rate,
+ n_layers,
+ n_flows=4,
+ gin_channels=0):
+ super().__init__()
+ self.channels = channels
+ self.hidden_channels = hidden_channels
+ self.kernel_size = kernel_size
+ self.dilation_rate = dilation_rate
+ self.n_layers = n_layers
+ self.n_flows = n_flows
+ self.gin_channels = gin_channels
+
+ self.flows = nn.ModuleList()
+ for i in range(n_flows):
+ self.flows.append(
+ modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers,
+ gin_channels=gin_channels, mean_only=True))
+ self.flows.append(modules.Flip())
+
+ def forward(self, x, x_mask, g=None, reverse=False):
+ if not reverse:
+ for flow in self.flows:
+ x, _ = flow(x, x_mask, g=g, reverse=reverse)
+ else:
+ for flow in reversed(self.flows):
+ x = flow(x, x_mask, g=g, reverse=reverse)
+ return x
+
+
+class PosteriorEncoder(nn.Module):
+ def __init__(self,
+ in_channels,
+ out_channels,
+ hidden_channels,
+ kernel_size,
+ dilation_rate,
+ n_layers,
+ gin_channels=0):
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.hidden_channels = hidden_channels
+ self.kernel_size = kernel_size
+ self.dilation_rate = dilation_rate
+ self.n_layers = n_layers
+ self.gin_channels = gin_channels
+
+ self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+ self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
+ self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+ def forward(self, x, x_lengths, g=None):
+ x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+ x = self.pre(x) * x_mask
+ x = self.enc(x, x_mask, g=g)
+ stats = self.proj(x) * x_mask
+ m, logs = torch.split(stats, self.out_channels, dim=1)
+ z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
+ return z, m, logs, x_mask
+
+
+class Generator(torch.nn.Module):
+ def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates,
+ upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
+ super(Generator, self).__init__()
+ self.num_kernels = len(resblock_kernel_sizes)
+ self.num_upsamples = len(upsample_rates)
+ self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
+ resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
+
+ self.ups = nn.ModuleList()
+ for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
+ self.ups.append(weight_norm(
+ ConvTranspose1d(upsample_initial_channel // (2 ** i), upsample_initial_channel // (2 ** (i + 1)),
+ k, u, padding=(k - u) // 2)))
+
+ self.resblocks = nn.ModuleList()
+ for i in range(len(self.ups)):
+ ch = upsample_initial_channel // (2 ** (i + 1))
+ for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
+ self.resblocks.append(resblock(ch, k, d))
+
+ self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
+ self.ups.apply(init_weights)
+
+ if gin_channels != 0:
+ self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
+
+ def forward(self, x, g=None):
+ x = self.conv_pre(x)
+ if g is not None:
+ x = x + self.cond(g)
+
+ for i in range(self.num_upsamples):
+ x = F.leaky_relu(x, modules.LRELU_SLOPE)
+ x = self.ups[i](x)
+ xs = None
+ for j in range(self.num_kernels):
+ if xs is None:
+ xs = self.resblocks[i * self.num_kernels + j](x)
+ else:
+ xs += self.resblocks[i * self.num_kernels + j](x)
+ x = xs / self.num_kernels
+ x = F.leaky_relu(x)
+ x = self.conv_post(x)
+ x = torch.tanh(x)
+
+ return x
+
+ def remove_weight_norm(self):
+ print('Removing weight norm...')
+ for l in self.ups:
+ remove_weight_norm(l)
+ for l in self.resblocks:
+ l.remove_weight_norm()
+
+
+class DiscriminatorP(torch.nn.Module):
+ def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
+ super(DiscriminatorP, self).__init__()
+ self.period = period
+ self.use_spectral_norm = use_spectral_norm
+ norm_f = weight_norm if use_spectral_norm == False else spectral_norm
+ self.convs = nn.ModuleList([
+ norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+ norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+ norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+ norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+ norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
+ ])
+ self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
+
+ def forward(self, x):
+ fmap = []
+
+ # 1d to 2d
+ b, c, t = x.shape
+ if t % self.period != 0: # pad first
+ n_pad = self.period - (t % self.period)
+ x = F.pad(x, (0, n_pad), "reflect")
+ t = t + n_pad
+ x = x.view(b, c, t // self.period, self.period)
+
+ for l in self.convs:
+ x = l(x)
+ x = F.leaky_relu(x, modules.LRELU_SLOPE)
+ fmap.append(x)
+ x = self.conv_post(x)
+ fmap.append(x)
+ x = torch.flatten(x, 1, -1)
+
+ return x, fmap
+
+
+class DiscriminatorS(torch.nn.Module):
+ def __init__(self, use_spectral_norm=False):
+ super(DiscriminatorS, self).__init__()
+ norm_f = weight_norm if use_spectral_norm == False else spectral_norm
+ self.convs = nn.ModuleList([
+ norm_f(Conv1d(1, 16, 15, 1, padding=7)),
+ norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
+ norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
+ norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
+ norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
+ norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
+ ])
+ self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
+
+ def forward(self, x):
+ fmap = []
+
+ for l in self.convs:
+ x = l(x)
+ x = F.leaky_relu(x, modules.LRELU_SLOPE)
+ fmap.append(x)
+ x = self.conv_post(x)
+ fmap.append(x)
+ x = torch.flatten(x, 1, -1)
+
+ return x, fmap
+
+
+class MultiPeriodDiscriminator(torch.nn.Module):
+ def __init__(self, use_spectral_norm=False):
+ super(MultiPeriodDiscriminator, self).__init__()
+ periods = [2, 3, 5, 7, 11]
+
+ discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
+ discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
+ self.discriminators = nn.ModuleList(discs)
+
+ def forward(self, y, y_hat):
+ y_d_rs = []
+ y_d_gs = []
+ fmap_rs = []
+ fmap_gs = []
+ for i, d in enumerate(self.discriminators):
+ y_d_r, fmap_r = d(y)
+ y_d_g, fmap_g = d(y_hat)
+ y_d_rs.append(y_d_r)
+ y_d_gs.append(y_d_g)
+ fmap_rs.append(fmap_r)
+ fmap_gs.append(fmap_g)
+
+ return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+
+class ReferenceEncoder(nn.Module):
+ '''
+ inputs --- [N, Ty/r, n_mels*r] mels
+ outputs --- [N, ref_enc_gru_size]
+ '''
+
+ def __init__(self, spec_channels, gin_channels=0):
+
+ super().__init__()
+ self.spec_channels = spec_channels
+ ref_enc_filters = [32, 32, 64, 64, 128, 128]
+ K = len(ref_enc_filters)
+ filters = [1] + ref_enc_filters
+ convs = [weight_norm(nn.Conv2d(in_channels=filters[i],
+ out_channels=filters[i + 1],
+ kernel_size=(3, 3),
+ stride=(2, 2),
+ padding=(1, 1))) for i in range(K)]
+ self.convs = nn.ModuleList(convs)
+ # self.wns = nn.ModuleList([weight_norm(num_features=ref_enc_filters[i]) for i in range(K)])
+
+ out_channels = self.calculate_channels(spec_channels, 3, 2, 1, K)
+ self.gru = nn.GRU(input_size=ref_enc_filters[-1] * out_channels,
+ hidden_size=256 // 2,
+ batch_first=True)
+ self.proj = nn.Linear(128, gin_channels)
+
+ def forward(self, inputs, mask=None):
+ N = inputs.size(0)
+ out = inputs.view(N, 1, -1, self.spec_channels) # [N, 1, Ty, n_freqs]
+ for conv in self.convs:
+ out = conv(out)
+ # out = wn(out)
+ out = F.relu(out) # [N, 128, Ty//2^K, n_mels//2^K]
+
+ out = out.transpose(1, 2) # [N, Ty//2^K, 128, n_mels//2^K]
+ T = out.size(1)
+ N = out.size(0)
+ out = out.contiguous().view(N, T, -1) # [N, Ty//2^K, 128*n_mels//2^K]
+
+ self.gru.flatten_parameters()
+ memory, out = self.gru(out) # out --- [1, N, 128]
+
+ return self.proj(out.squeeze(0))
+
+ def calculate_channels(self, L, kernel_size, stride, pad, n_convs):
+ for i in range(n_convs):
+ L = (L - kernel_size + 2 * pad) // stride + 1
+ return L
+
+
+class SynthesizerTrn(nn.Module):
+ """
+ Synthesizer for Training
+ """
+
+ def __init__(self,
+ n_vocab,
+ spec_channels,
+ segment_size,
+ inter_channels,
+ hidden_channels,
+ filter_channels,
+ n_heads,
+ n_layers,
+ kernel_size,
+ p_dropout,
+ resblock,
+ resblock_kernel_sizes,
+ resblock_dilation_sizes,
+ upsample_rates,
+ upsample_initial_channel,
+ upsample_kernel_sizes,
+ n_speakers=256,
+ gin_channels=256,
+ use_sdp=True,
+ n_flow_layer = 4,
+ n_layers_trans_flow = 3,
+ flow_share_parameter = False,
+ use_transformer_flow = True,
+ **kwargs):
+
+ super().__init__()
+ self.n_vocab = n_vocab
+ self.spec_channels = spec_channels
+ self.inter_channels = inter_channels
+ self.hidden_channels = hidden_channels
+ self.filter_channels = filter_channels
+ self.n_heads = n_heads
+ self.n_layers = n_layers
+ self.kernel_size = kernel_size
+ self.p_dropout = p_dropout
+ self.resblock = resblock
+ self.resblock_kernel_sizes = resblock_kernel_sizes
+ self.resblock_dilation_sizes = resblock_dilation_sizes
+ self.upsample_rates = upsample_rates
+ self.upsample_initial_channel = upsample_initial_channel
+ self.upsample_kernel_sizes = upsample_kernel_sizes
+ self.segment_size = segment_size
+ self.n_speakers = n_speakers
+ self.gin_channels = gin_channels
+ self.n_layers_trans_flow = n_layers_trans_flow
+ self.use_spk_conditioned_encoder = kwargs.get("use_spk_conditioned_encoder", True)
+ self.use_sdp = use_sdp
+ self.use_noise_scaled_mas = kwargs.get("use_noise_scaled_mas", False)
+ self.mas_noise_scale_initial = kwargs.get("mas_noise_scale_initial", 0.01)
+ self.noise_scale_delta = kwargs.get("noise_scale_delta", 2e-6)
+ self.current_mas_noise_scale = self.mas_noise_scale_initial
+ if self.use_spk_conditioned_encoder and gin_channels > 0:
+ self.enc_gin_channels = gin_channels
+ self.enc_p = TextEncoder(n_vocab,
+ inter_channels,
+ hidden_channels,
+ filter_channels,
+ n_heads,
+ n_layers,
+ kernel_size,
+ p_dropout,
+ gin_channels=self.enc_gin_channels)
+ self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates,
+ upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels)
+ self.enc_q = PosteriorEncoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16,
+ gin_channels=gin_channels)
+ if use_transformer_flow:
+ self.flow = TransformerCouplingBlock(inter_channels, hidden_channels, filter_channels, n_heads, n_layers_trans_flow, 5, p_dropout, n_flow_layer, gin_channels=gin_channels,share_parameter= flow_share_parameter)
+ else:
+ self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, n_flow_layer, gin_channels=gin_channels)
+ self.sdp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
+ self.dp = DurationPredictor(hidden_channels, 256, 3, 0.5, gin_channels=gin_channels)
+
+ if n_speakers >= 1:
+ self.emb_g = nn.Embedding(n_speakers, gin_channels)
+ else:
+ self.ref_enc = ReferenceEncoder(spec_channels, gin_channels)
+
+ def forward(self, x, x_lengths, y, y_lengths, sid, tone, language, bert):
+ if self.n_speakers > 0:
+ g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
+ else:
+ g = self.ref_enc(y.transpose(1,2)).unsqueeze(-1)
+ x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert,g=g)
+ z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
+ z_p = self.flow(z, y_mask, g=g)
+
+ with torch.no_grad():
+ # negative cross-entropy
+ s_p_sq_r = torch.exp(-2 * logs_p) # [b, d, t]
+ neg_cent1 = torch.sum(-0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True) # [b, 1, t_s]
+ neg_cent2 = torch.matmul(-0.5 * (z_p ** 2).transpose(1, 2),
+ s_p_sq_r) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
+ neg_cent3 = torch.matmul(z_p.transpose(1, 2), (m_p * s_p_sq_r)) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
+ neg_cent4 = torch.sum(-0.5 * (m_p ** 2) * s_p_sq_r, [1], keepdim=True) # [b, 1, t_s]
+ neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
+ if self.use_noise_scaled_mas:
+ epsilon = torch.std(neg_cent) * torch.randn_like(neg_cent) * self.current_mas_noise_scale
+ neg_cent = neg_cent + epsilon
+
+ attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
+ attn = monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1)).unsqueeze(1).detach()
+
+ w = attn.sum(2)
+
+ l_length_sdp = self.sdp(x, x_mask, w, g=g)
+ l_length_sdp = l_length_sdp / torch.sum(x_mask)
+
+ logw_ = torch.log(w + 1e-6) * x_mask
+ logw = self.dp(x, x_mask, g=g)
+ l_length_dp = torch.sum((logw - logw_) ** 2, [1, 2]) / torch.sum(x_mask) # for averaging
+
+ l_length = l_length_dp + l_length_sdp
+
+ # expand prior
+ m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
+ logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
+
+ z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
+ o = self.dec(z_slice, g=g)
+ return o, l_length, attn, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q), (x, logw, logw_)
+
+ def infer(self, x, x_lengths, sid, tone, language, bert, noise_scale=.667, length_scale=1, noise_scale_w=0.8, max_len=None, sdp_ratio=0,y=None):
+ #x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert)
+ # g = self.gst(y)
+ if self.n_speakers > 0:
+ g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
+ else:
+ g = self.ref_enc(y.transpose(1,2)).unsqueeze(-1)
+ x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert,g=g)
+ logw = self.sdp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w) * (sdp_ratio) + self.dp(x, x_mask, g=g) * (1 - sdp_ratio)
+ w = torch.exp(logw) * x_mask * length_scale
+ w_ceil = torch.ceil(w)
+ y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
+ y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
+ attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
+ attn = commons.generate_path(w_ceil, attn_mask)
+
+ m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
+ logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1,
+ 2) # [b, t', t], [b, t, d] -> [b, d, t']
+
+ z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
+ z = self.flow(z_p, y_mask, g=g, reverse=True)
+ o = self.dec((z * y_mask)[:, :, :max_len], g=g)
+ return o, attn, y_mask, (z, z_p, m_p, logs_p)
diff --git a/modules.py b/modules.py
new file mode 100644
index 0000000000000000000000000000000000000000..92e0f32a51c472bfd1659a50a95a95d195281d2b
--- /dev/null
+++ b/modules.py
@@ -0,0 +1,452 @@
+import copy
+import math
+import numpy as np
+import scipy
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
+from torch.nn.utils import weight_norm, remove_weight_norm
+
+import commons
+from commons import init_weights, get_padding
+from transforms import piecewise_rational_quadratic_transform
+from attentions import Encoder
+
+LRELU_SLOPE = 0.1
+
+class LayerNorm(nn.Module):
+ def __init__(self, channels, eps=1e-5):
+ super().__init__()
+ self.channels = channels
+ self.eps = eps
+
+ self.gamma = nn.Parameter(torch.ones(channels))
+ self.beta = nn.Parameter(torch.zeros(channels))
+
+ def forward(self, x):
+ x = x.transpose(1, -1)
+ x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
+ return x.transpose(1, -1)
+
+class ConvReluNorm(nn.Module):
+ def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
+ super().__init__()
+ self.in_channels = in_channels
+ self.hidden_channels = hidden_channels
+ self.out_channels = out_channels
+ self.kernel_size = kernel_size
+ self.n_layers = n_layers
+ self.p_dropout = p_dropout
+ assert n_layers > 1, "Number of layers should be larger than 0."
+
+ self.conv_layers = nn.ModuleList()
+ self.norm_layers = nn.ModuleList()
+ self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
+ self.norm_layers.append(LayerNorm(hidden_channels))
+ self.relu_drop = nn.Sequential(
+ nn.ReLU(),
+ nn.Dropout(p_dropout))
+ for _ in range(n_layers-1):
+ self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
+ self.norm_layers.append(LayerNorm(hidden_channels))
+ self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
+ self.proj.weight.data.zero_()
+ self.proj.bias.data.zero_()
+
+ def forward(self, x, x_mask):
+ x_org = x
+ for i in range(self.n_layers):
+ x = self.conv_layers[i](x * x_mask)
+ x = self.norm_layers[i](x)
+ x = self.relu_drop(x)
+ x = x_org + self.proj(x)
+ return x * x_mask
+
+
+class DDSConv(nn.Module):
+ """
+ Dialted and Depth-Separable Convolution
+ """
+ def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
+ super().__init__()
+ self.channels = channels
+ self.kernel_size = kernel_size
+ self.n_layers = n_layers
+ self.p_dropout = p_dropout
+
+ self.drop = nn.Dropout(p_dropout)
+ self.convs_sep = nn.ModuleList()
+ self.convs_1x1 = nn.ModuleList()
+ self.norms_1 = nn.ModuleList()
+ self.norms_2 = nn.ModuleList()
+ for i in range(n_layers):
+ dilation = kernel_size ** i
+ padding = (kernel_size * dilation - dilation) // 2
+ self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size,
+ groups=channels, dilation=dilation, padding=padding
+ ))
+ self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
+ self.norms_1.append(LayerNorm(channels))
+ self.norms_2.append(LayerNorm(channels))
+
+ def forward(self, x, x_mask, g=None):
+ if g is not None:
+ x = x + g
+ for i in range(self.n_layers):
+ y = self.convs_sep[i](x * x_mask)
+ y = self.norms_1[i](y)
+ y = F.gelu(y)
+ y = self.convs_1x1[i](y)
+ y = self.norms_2[i](y)
+ y = F.gelu(y)
+ y = self.drop(y)
+ x = x + y
+ return x * x_mask
+
+
+class WN(torch.nn.Module):
+ def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0):
+ super(WN, self).__init__()
+ assert(kernel_size % 2 == 1)
+ self.hidden_channels =hidden_channels
+ self.kernel_size = kernel_size,
+ self.dilation_rate = dilation_rate
+ self.n_layers = n_layers
+ self.gin_channels = gin_channels
+ self.p_dropout = p_dropout
+
+ self.in_layers = torch.nn.ModuleList()
+ self.res_skip_layers = torch.nn.ModuleList()
+ self.drop = nn.Dropout(p_dropout)
+
+ if gin_channels != 0:
+ cond_layer = torch.nn.Conv1d(gin_channels, 2*hidden_channels*n_layers, 1)
+ self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
+
+ for i in range(n_layers):
+ dilation = dilation_rate ** i
+ padding = int((kernel_size * dilation - dilation) / 2)
+ in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
+ dilation=dilation, padding=padding)
+ in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
+ self.in_layers.append(in_layer)
+
+ # last one is not necessary
+ if i < n_layers - 1:
+ res_skip_channels = 2 * hidden_channels
+ else:
+ res_skip_channels = hidden_channels
+
+ res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
+ res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
+ self.res_skip_layers.append(res_skip_layer)
+
+ def forward(self, x, x_mask, g=None, **kwargs):
+ output = torch.zeros_like(x)
+ n_channels_tensor = torch.IntTensor([self.hidden_channels])
+
+ if g is not None:
+ g = self.cond_layer(g)
+
+ for i in range(self.n_layers):
+ x_in = self.in_layers[i](x)
+ if g is not None:
+ cond_offset = i * 2 * self.hidden_channels
+ g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
+ else:
+ g_l = torch.zeros_like(x_in)
+
+ acts = commons.fused_add_tanh_sigmoid_multiply(
+ x_in,
+ g_l,
+ n_channels_tensor)
+ acts = self.drop(acts)
+
+ res_skip_acts = self.res_skip_layers[i](acts)
+ if i < self.n_layers - 1:
+ res_acts = res_skip_acts[:,:self.hidden_channels,:]
+ x = (x + res_acts) * x_mask
+ output = output + res_skip_acts[:,self.hidden_channels:,:]
+ else:
+ output = output + res_skip_acts
+ return output * x_mask
+
+ def remove_weight_norm(self):
+ if self.gin_channels != 0:
+ torch.nn.utils.remove_weight_norm(self.cond_layer)
+ for l in self.in_layers:
+ torch.nn.utils.remove_weight_norm(l)
+ for l in self.res_skip_layers:
+ torch.nn.utils.remove_weight_norm(l)
+
+
+class ResBlock1(torch.nn.Module):
+ def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
+ super(ResBlock1, self).__init__()
+ self.convs1 = nn.ModuleList([
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
+ padding=get_padding(kernel_size, dilation[0]))),
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
+ padding=get_padding(kernel_size, dilation[1]))),
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
+ padding=get_padding(kernel_size, dilation[2])))
+ ])
+ self.convs1.apply(init_weights)
+
+ self.convs2 = nn.ModuleList([
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
+ padding=get_padding(kernel_size, 1))),
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
+ padding=get_padding(kernel_size, 1))),
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
+ padding=get_padding(kernel_size, 1)))
+ ])
+ self.convs2.apply(init_weights)
+
+ def forward(self, x, x_mask=None):
+ for c1, c2 in zip(self.convs1, self.convs2):
+ xt = F.leaky_relu(x, LRELU_SLOPE)
+ if x_mask is not None:
+ xt = xt * x_mask
+ xt = c1(xt)
+ xt = F.leaky_relu(xt, LRELU_SLOPE)
+ if x_mask is not None:
+ xt = xt * x_mask
+ xt = c2(xt)
+ x = xt + x
+ if x_mask is not None:
+ x = x * x_mask
+ return x
+
+ def remove_weight_norm(self):
+ for l in self.convs1:
+ remove_weight_norm(l)
+ for l in self.convs2:
+ remove_weight_norm(l)
+
+
+class ResBlock2(torch.nn.Module):
+ def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
+ super(ResBlock2, self).__init__()
+ self.convs = nn.ModuleList([
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
+ padding=get_padding(kernel_size, dilation[0]))),
+ weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
+ padding=get_padding(kernel_size, dilation[1])))
+ ])
+ self.convs.apply(init_weights)
+
+ def forward(self, x, x_mask=None):
+ for c in self.convs:
+ xt = F.leaky_relu(x, LRELU_SLOPE)
+ if x_mask is not None:
+ xt = xt * x_mask
+ xt = c(xt)
+ x = xt + x
+ if x_mask is not None:
+ x = x * x_mask
+ return x
+
+ def remove_weight_norm(self):
+ for l in self.convs:
+ remove_weight_norm(l)
+
+
+class Log(nn.Module):
+ def forward(self, x, x_mask, reverse=False, **kwargs):
+ if not reverse:
+ y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
+ logdet = torch.sum(-y, [1, 2])
+ return y, logdet
+ else:
+ x = torch.exp(x) * x_mask
+ return x
+
+
+class Flip(nn.Module):
+ def forward(self, x, *args, reverse=False, **kwargs):
+ x = torch.flip(x, [1])
+ if not reverse:
+ logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
+ return x, logdet
+ else:
+ return x
+
+
+class ElementwiseAffine(nn.Module):
+ def __init__(self, channels):
+ super().__init__()
+ self.channels = channels
+ self.m = nn.Parameter(torch.zeros(channels,1))
+ self.logs = nn.Parameter(torch.zeros(channels,1))
+
+ def forward(self, x, x_mask, reverse=False, **kwargs):
+ if not reverse:
+ y = self.m + torch.exp(self.logs) * x
+ y = y * x_mask
+ logdet = torch.sum(self.logs * x_mask, [1,2])
+ return y, logdet
+ else:
+ x = (x - self.m) * torch.exp(-self.logs) * x_mask
+ return x
+
+
+class ResidualCouplingLayer(nn.Module):
+ def __init__(self,
+ channels,
+ hidden_channels,
+ kernel_size,
+ dilation_rate,
+ n_layers,
+ p_dropout=0,
+ gin_channels=0,
+ mean_only=False):
+ assert channels % 2 == 0, "channels should be divisible by 2"
+ super().__init__()
+ self.channels = channels
+ self.hidden_channels = hidden_channels
+ self.kernel_size = kernel_size
+ self.dilation_rate = dilation_rate
+ self.n_layers = n_layers
+ self.half_channels = channels // 2
+ self.mean_only = mean_only
+
+ self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
+ self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, gin_channels=gin_channels)
+ self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
+ self.post.weight.data.zero_()
+ self.post.bias.data.zero_()
+
+ def forward(self, x, x_mask, g=None, reverse=False):
+ x0, x1 = torch.split(x, [self.half_channels]*2, 1)
+ h = self.pre(x0) * x_mask
+ h = self.enc(h, x_mask, g=g)
+ stats = self.post(h) * x_mask
+ if not self.mean_only:
+ m, logs = torch.split(stats, [self.half_channels]*2, 1)
+ else:
+ m = stats
+ logs = torch.zeros_like(m)
+
+ if not reverse:
+ x1 = m + x1 * torch.exp(logs) * x_mask
+ x = torch.cat([x0, x1], 1)
+ logdet = torch.sum(logs, [1,2])
+ return x, logdet
+ else:
+ x1 = (x1 - m) * torch.exp(-logs) * x_mask
+ x = torch.cat([x0, x1], 1)
+ return x
+
+
+class ConvFlow(nn.Module):
+ def __init__(self, in_channels, filter_channels, kernel_size, n_layers, num_bins=10, tail_bound=5.0):
+ super().__init__()
+ self.in_channels = in_channels
+ self.filter_channels = filter_channels
+ self.kernel_size = kernel_size
+ self.n_layers = n_layers
+ self.num_bins = num_bins
+ self.tail_bound = tail_bound
+ self.half_channels = in_channels // 2
+
+ self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
+ self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.)
+ self.proj = nn.Conv1d(filter_channels, self.half_channels * (num_bins * 3 - 1), 1)
+ self.proj.weight.data.zero_()
+ self.proj.bias.data.zero_()
+
+ def forward(self, x, x_mask, g=None, reverse=False):
+ x0, x1 = torch.split(x, [self.half_channels]*2, 1)
+ h = self.pre(x0)
+ h = self.convs(h, x_mask, g=g)
+ h = self.proj(h) * x_mask
+
+ b, c, t = x0.shape
+ h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
+
+ unnormalized_widths = h[..., :self.num_bins] / math.sqrt(self.filter_channels)
+ unnormalized_heights = h[..., self.num_bins:2*self.num_bins] / math.sqrt(self.filter_channels)
+ unnormalized_derivatives = h[..., 2 * self.num_bins:]
+
+ x1, logabsdet = piecewise_rational_quadratic_transform(x1,
+ unnormalized_widths,
+ unnormalized_heights,
+ unnormalized_derivatives,
+ inverse=reverse,
+ tails='linear',
+ tail_bound=self.tail_bound
+ )
+
+ x = torch.cat([x0, x1], 1) * x_mask
+ logdet = torch.sum(logabsdet * x_mask, [1,2])
+ if not reverse:
+ return x, logdet
+ else:
+ return x
+class TransformerCouplingLayer(nn.Module):
+ def __init__(self,
+ channels,
+ hidden_channels,
+ kernel_size,
+ n_layers,
+ n_heads,
+ p_dropout=0,
+ filter_channels=0,
+ mean_only=False,
+ wn_sharing_parameter=None,
+ gin_channels = 0
+ ):
+ assert channels % 2 == 0, "channels should be divisible by 2"
+ super().__init__()
+ self.channels = channels
+ self.hidden_channels = hidden_channels
+ self.kernel_size = kernel_size
+ self.n_layers = n_layers
+ self.half_channels = channels // 2
+ self.mean_only = mean_only
+
+ self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
+ self.enc = Encoder(hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout, isflow = True, gin_channels = gin_channels) if wn_sharing_parameter is None else wn_sharing_parameter
+ self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
+ self.post.weight.data.zero_()
+ self.post.bias.data.zero_()
+
+ def forward(self, x, x_mask, g=None, reverse=False):
+ x0, x1 = torch.split(x, [self.half_channels]*2, 1)
+ h = self.pre(x0) * x_mask
+ h = self.enc(h, x_mask, g=g)
+ stats = self.post(h) * x_mask
+ if not self.mean_only:
+ m, logs = torch.split(stats, [self.half_channels]*2, 1)
+ else:
+ m = stats
+ logs = torch.zeros_like(m)
+
+ if not reverse:
+ x1 = m + x1 * torch.exp(logs) * x_mask
+ x = torch.cat([x0, x1], 1)
+ logdet = torch.sum(logs, [1,2])
+ return x, logdet
+ else:
+ x1 = (x1 - m) * torch.exp(-logs) * x_mask
+ x = torch.cat([x0, x1], 1)
+ return x
+
+ x1, logabsdet = piecewise_rational_quadratic_transform(x1,
+ unnormalized_widths,
+ unnormalized_heights,
+ unnormalized_derivatives,
+ inverse=reverse,
+ tails='linear',
+ tail_bound=self.tail_bound
+ )
+
+ x = torch.cat([x0, x1], 1) * x_mask
+ logdet = torch.sum(logabsdet * x_mask, [1,2])
+ if not reverse:
+ return x, logdet
+ else:
+ return x
diff --git a/monotonic_align/__init__.py b/monotonic_align/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a323673bb16070d6d0fffddb939b657d0915ff1b
--- /dev/null
+++ b/monotonic_align/__init__.py
@@ -0,0 +1,20 @@
+from numpy import zeros, int32, float32
+from torch import from_numpy
+
+from .core import maximum_path_jit
+
+
+def maximum_path(neg_cent, mask):
+ """ numba optimized version.
+ neg_cent: [b, t_t, t_s]
+ mask: [b, t_t, t_s]
+ """
+ device = neg_cent.device
+ dtype = neg_cent.dtype
+ neg_cent = neg_cent.data.cpu().numpy().astype(float32)
+ path = zeros(neg_cent.shape, dtype=int32)
+
+ t_t_max = mask.sum(1)[:, 0].data.cpu().numpy().astype(int32)
+ t_s_max = mask.sum(2)[:, 0].data.cpu().numpy().astype(int32)
+ maximum_path_jit(path, neg_cent, t_t_max, t_s_max)
+ return from_numpy(path).to(device=device, dtype=dtype)
\ No newline at end of file
diff --git a/monotonic_align/core.c b/monotonic_align/core.c
new file mode 100644
index 0000000000000000000000000000000000000000..5f8af54d32474f821e9d1f4d2679d78128722596
--- /dev/null
+++ b/monotonic_align/core.c
@@ -0,0 +1,26530 @@
+/* Generated by Cython 3.0.0 */
+
+/* BEGIN: Cython Metadata
+{
+ "distutils": {
+ "name": "monotonic_align.core",
+ "sources": [
+ "core.pyx"
+ ]
+ },
+ "module_name": "monotonic_align.core"
+}
+END: Cython Metadata */
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+ #ifndef Py_LIMITED_API
+ #if CYTHON_LIMITED_API+0 > 0x03030000
+ #define Py_LIMITED_API CYTHON_LIMITED_API
+ #else
+ #define Py_LIMITED_API 0x03030000
+ #endif
+ #endif
+#endif
+
+#include "Python.h"
+#ifndef Py_PYTHON_H
+ #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+ #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#define CYTHON_ABI "3_0_0"
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x030000F0
+#define CYTHON_FUTURE_DIVISION 1
+#include
+#ifndef offsetof
+ #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
+ #ifndef __stdcall
+ #define __stdcall
+ #endif
+ #ifndef __cdecl
+ #define __cdecl
+ #endif
+ #ifndef __fastcall
+ #define __fastcall
+ #endif
+#endif
+#ifndef DL_IMPORT
+ #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+ #define DL_EXPORT(t) t
+#endif
+#define __PYX_COMMA ,
+#ifndef HAVE_LONG_LONG
+ #define HAVE_LONG_LONG
+#endif
+#ifndef PY_LONG_LONG
+ #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+ #define Py_HUGE_VAL HUGE_VAL
+#endif
+#if defined(GRAALVM_PYTHON)
+ /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+ The existence of this section does not imply that anything works or is even tested */
+ #define CYTHON_COMPILING_IN_PYPY 0
+ #define CYTHON_COMPILING_IN_CPYTHON 0
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
+ #define CYTHON_COMPILING_IN_GRAAL 1
+ #define CYTHON_COMPILING_IN_NOGIL 0
+ #undef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 0
+ #undef CYTHON_USE_TYPE_SPECS
+ #define CYTHON_USE_TYPE_SPECS 0
+ #undef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
+ #if PY_VERSION_HEX < 0x03050000
+ #undef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+ #define CYTHON_USE_ASYNC_SLOTS 1
+ #endif
+ #undef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 0
+ #undef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 0
+ #undef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #undef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 0
+ #undef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 1
+ #undef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 0
+ #undef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 0
+ #undef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 0
+ #undef CYTHON_FAST_GIL
+ #define CYTHON_FAST_GIL 0
+ #undef CYTHON_METH_FASTCALL
+ #define CYTHON_METH_FASTCALL 0
+ #undef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 0
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
+ #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+ #endif
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+ #undef CYTHON_USE_MODULE_STATE
+ #define CYTHON_USE_MODULE_STATE 0
+ #undef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE 0
+ #undef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS 0
+ #undef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK 0
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+ #endif
+#elif defined(PYPY_VERSION)
+ #define CYTHON_COMPILING_IN_PYPY 1
+ #define CYTHON_COMPILING_IN_CPYTHON 0
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
+ #define CYTHON_COMPILING_IN_GRAAL 0
+ #define CYTHON_COMPILING_IN_NOGIL 0
+ #undef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 0
+ #undef CYTHON_USE_TYPE_SPECS
+ #define CYTHON_USE_TYPE_SPECS 0
+ #undef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
+ #if PY_VERSION_HEX < 0x03050000
+ #undef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+ #define CYTHON_USE_ASYNC_SLOTS 1
+ #endif
+ #undef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 0
+ #undef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 0
+ #undef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #undef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 0
+ #undef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 1
+ #undef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 0
+ #undef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 0
+ #undef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 0
+ #undef CYTHON_FAST_GIL
+ #define CYTHON_FAST_GIL 0
+ #undef CYTHON_METH_FASTCALL
+ #define CYTHON_METH_FASTCALL 0
+ #undef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 0
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
+ #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+ #endif
+ #if PY_VERSION_HEX < 0x03090000
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+ #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+ #endif
+ #undef CYTHON_USE_MODULE_STATE
+ #define CYTHON_USE_MODULE_STATE 0
+ #undef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+ #undef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS 0
+ #undef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK 0
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+ #endif
+#elif defined(CYTHON_LIMITED_API)
+ #define CYTHON_COMPILING_IN_PYPY 0
+ #define CYTHON_COMPILING_IN_CPYTHON 0
+ #define CYTHON_COMPILING_IN_LIMITED_API 1
+ #define CYTHON_COMPILING_IN_GRAAL 0
+ #define CYTHON_COMPILING_IN_NOGIL 0
+ #undef CYTHON_CLINE_IN_TRACEBACK
+ #define CYTHON_CLINE_IN_TRACEBACK 0
+ #undef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 0
+ #undef CYTHON_USE_TYPE_SPECS
+ #define CYTHON_USE_TYPE_SPECS 1
+ #undef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
+ #undef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #undef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 0
+ #undef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 0
+ #ifndef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #endif
+ #undef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 0
+ #ifndef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 0
+ #endif
+ #undef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 0
+ #undef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 0
+ #undef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 0
+ #undef CYTHON_FAST_GIL
+ #define CYTHON_FAST_GIL 0
+ #undef CYTHON_METH_FASTCALL
+ #define CYTHON_METH_FASTCALL 0
+ #undef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 0
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
+ #define CYTHON_PEP487_INIT_SUBCLASS 1
+ #endif
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+ #undef CYTHON_USE_MODULE_STATE
+ #define CYTHON_USE_MODULE_STATE 1
+ #ifndef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE 1
+ #endif
+ #undef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS 0
+ #undef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK 0
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+ #endif
+#elif defined(PY_NOGIL)
+ #define CYTHON_COMPILING_IN_PYPY 0
+ #define CYTHON_COMPILING_IN_CPYTHON 0
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
+ #define CYTHON_COMPILING_IN_GRAAL 0
+ #define CYTHON_COMPILING_IN_NOGIL 1
+ #ifndef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 1
+ #endif
+ #undef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
+ #ifndef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 1
+ #endif
+ #undef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 0
+ #ifndef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 1
+ #endif
+ #undef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #undef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 0
+ #ifndef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 0
+ #endif
+ #ifndef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 1
+ #endif
+ #ifndef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 1
+ #endif
+ #undef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 0
+ #undef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 0
+ #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+ #endif
+ #ifndef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE 1
+ #endif
+ #undef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS 0
+ #undef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK 0
+#else
+ #define CYTHON_COMPILING_IN_PYPY 0
+ #define CYTHON_COMPILING_IN_CPYTHON 1
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
+ #define CYTHON_COMPILING_IN_GRAAL 0
+ #define CYTHON_COMPILING_IN_NOGIL 0
+ #ifndef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 1
+ #endif
+ #ifndef CYTHON_USE_TYPE_SPECS
+ #define CYTHON_USE_TYPE_SPECS 0
+ #endif
+ #ifndef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 1
+ #endif
+ #if PY_MAJOR_VERSION < 3
+ #undef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+ #define CYTHON_USE_ASYNC_SLOTS 1
+ #endif
+ #ifndef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 1
+ #endif
+ #ifndef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 1
+ #endif
+ #ifndef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 1
+ #endif
+ #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2
+ #undef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #elif !defined(CYTHON_USE_UNICODE_WRITER)
+ #define CYTHON_USE_UNICODE_WRITER 1
+ #endif
+ #ifndef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 0
+ #endif
+ #ifndef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 1
+ #endif
+ #ifndef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 1
+ #endif
+ #ifndef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 1
+ #endif
+ #ifndef CYTHON_FAST_GIL
+ #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+ #endif
+ #ifndef CYTHON_METH_FASTCALL
+ #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+ #endif
+ #ifndef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 1
+ #endif
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
+ #define CYTHON_PEP487_INIT_SUBCLASS 1
+ #endif
+ #if PY_VERSION_HEX < 0x03050000
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+ #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+ #endif
+ #ifndef CYTHON_USE_MODULE_STATE
+ #define CYTHON_USE_MODULE_STATE 0
+ #endif
+ #if PY_VERSION_HEX < 0x030400a1
+ #undef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE 0
+ #elif !defined(CYTHON_USE_TP_FINALIZE)
+ #define CYTHON_USE_TP_FINALIZE 1
+ #endif
+ #if PY_VERSION_HEX < 0x030600B1
+ #undef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS 0
+ #elif !defined(CYTHON_USE_DICT_VERSIONS)
+ #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5)
+ #endif
+ #if PY_VERSION_HEX < 0x030700A3
+ #undef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK 0
+ #elif !defined(CYTHON_USE_EXC_INFO_STACK)
+ #define CYTHON_USE_EXC_INFO_STACK 1
+ #endif
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+ #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
+#if CYTHON_USE_PYLONG_INTERNALS
+ #if PY_MAJOR_VERSION < 3
+ #include "longintrepr.h"
+ #endif
+ #undef SHIFT
+ #undef BASE
+ #undef MASK
+ #ifdef SIZEOF_VOID_P
+ enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
+ #endif
+#endif
+#ifndef __has_attribute
+ #define __has_attribute(x) 0
+#endif
+#ifndef __has_cpp_attribute
+ #define __has_cpp_attribute(x) 0
+#endif
+#ifndef CYTHON_RESTRICT
+ #if defined(__GNUC__)
+ #define CYTHON_RESTRICT __restrict__
+ #elif defined(_MSC_VER) && _MSC_VER >= 1400
+ #define CYTHON_RESTRICT __restrict
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+ #define CYTHON_RESTRICT restrict
+ #else
+ #define CYTHON_RESTRICT
+ #endif
+#endif
+#ifndef CYTHON_UNUSED
+ #if defined(__cplusplus)
+ /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+ * but leads to warnings with -pedantic, since it is a C++17 feature */
+ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+ #if __has_cpp_attribute(maybe_unused)
+ #define CYTHON_UNUSED [[maybe_unused]]
+ #endif
+ #endif
+ #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+# define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+# define CYTHON_UNUSED
+# endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+# define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+# define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_UNUSED_VAR
+# if defined(__cplusplus)
+ template void CYTHON_UNUSED_VAR( const T& ) { }
+# else
+# define CYTHON_UNUSED_VAR(x) (void)(x)
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+ #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+# define CYTHON_NCP_UNUSED
+# else
+# define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+#ifdef _MSC_VER
+ #ifndef _MSC_STDINT_H_
+ #if _MSC_VER < 1300
+ typedef unsigned char uint8_t;
+ typedef unsigned short uint16_t;
+ typedef unsigned int uint32_t;
+ #else
+ typedef unsigned __int8 uint8_t;
+ typedef unsigned __int16 uint16_t;
+ typedef unsigned __int32 uint32_t;
+ #endif
+ #endif
+ #if _MSC_VER < 1300
+ #ifdef _WIN64
+ typedef unsigned long long __pyx_uintptr_t;
+ #else
+ typedef unsigned int __pyx_uintptr_t;
+ #endif
+ #else
+ #ifdef _WIN64
+ typedef unsigned __int64 __pyx_uintptr_t;
+ #else
+ typedef unsigned __int32 __pyx_uintptr_t;
+ #endif
+ #endif
+#else
+ #include
+ typedef uintptr_t __pyx_uintptr_t;
+#endif
+#ifndef CYTHON_FALLTHROUGH
+ #if defined(__cplusplus)
+ /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+ * but leads to warnings with -pedantic, since it is a C++17 feature */
+ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+ #if __has_cpp_attribute(fallthrough)
+ #define CYTHON_FALLTHROUGH [[fallthrough]]
+ #endif
+ #endif
+ #ifndef CYTHON_FALLTHROUGH
+ #if __has_cpp_attribute(clang::fallthrough)
+ #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+ #elif __has_cpp_attribute(gnu::fallthrough)
+ #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+ #endif
+ #endif
+ #endif
+ #ifndef CYTHON_FALLTHROUGH
+ #if __has_attribute(fallthrough)
+ #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
+ #else
+ #define CYTHON_FALLTHROUGH
+ #endif
+ #endif
+ #if defined(__clang__) && defined(__apple_build_version__)
+ #if __apple_build_version__ < 7000000
+ #undef CYTHON_FALLTHROUGH
+ #define CYTHON_FALLTHROUGH
+ #endif
+ #endif
+#endif
+#ifdef __cplusplus
+ template
+ struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+ #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value)
+#else
+ #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+ #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+ #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
+
+#ifndef CYTHON_INLINE
+ #if defined(__clang__)
+ #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+ #elif defined(__GNUC__)
+ #define CYTHON_INLINE __inline__
+ #elif defined(_MSC_VER)
+ #define CYTHON_INLINE __inline
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+ #define CYTHON_INLINE inline
+ #else
+ #define CYTHON_INLINE
+ #endif
+#endif
+
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+ #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+ #define __Pyx_DefaultClassType PyClass_Type
+ #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#else
+ #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+ #define __Pyx_DefaultClassType PyType_Type
+#if PY_VERSION_HEX >= 0x030B00A1
+ static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+ PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+ PyObject *fv, PyObject *cell, PyObject* fn,
+ PyObject *name, int fline, PyObject *lnos) {
+ PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
+ PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *empty=NULL;
+ const char *fn_cstr=NULL;
+ const char *name_cstr=NULL;
+ PyCodeObject *co=NULL, *result=NULL;
+ PyObject *type, *value, *traceback;
+ PyErr_Fetch(&type, &value, &traceback);
+ if (!(kwds=PyDict_New())) goto end;
+ if (!(argcount=PyLong_FromLong(a))) goto end;
+ if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
+ if (!(posonlyargcount=PyLong_FromLong(p))) goto end;
+ if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
+ if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
+ if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
+ if (!(nlocals=PyLong_FromLong(l))) goto end;
+ if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
+ if (!(stacksize=PyLong_FromLong(s))) goto end;
+ if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
+ if (!(flags=PyLong_FromLong(f))) goto end;
+ if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
+ if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
+ if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
+ if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
+ if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
+ if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
+ if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
+ if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
+ if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
+ if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
+ if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
+ if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto end;
+ if (!(empty = PyTuple_New(0))) goto end;
+ result = (PyCodeObject*) PyObject_Call(replace, empty, kwds);
+ end:
+ Py_XDECREF((PyObject*) co);
+ Py_XDECREF(kwds);
+ Py_XDECREF(argcount);
+ Py_XDECREF(posonlyargcount);
+ Py_XDECREF(kwonlyargcount);
+ Py_XDECREF(nlocals);
+ Py_XDECREF(stacksize);
+ Py_XDECREF(replace);
+ Py_XDECREF(empty);
+ if (type) {
+ PyErr_Restore(type, value, traceback);
+ }
+ return result;
+ }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+ #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#else
+ #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#endif
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+ #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+ #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+ #define __Pyx_Py_Is(x, y) Py_Is(x, y)
+#else
+ #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+ #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+ #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+ #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+ #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+ #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+ #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+ #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+ #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+ #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+ #define CO_ASYNC_GENERATOR 0x200
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+ #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+ #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+ #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+ #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef Py_TPFLAGS_SEQUENCE
+ #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+ #define Py_TPFLAGS_MAPPING 0
+#endif
+#ifndef METH_STACKLESS
+ #define METH_STACKLESS 0
+#endif
+#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
+ #ifndef METH_FASTCALL
+ #define METH_FASTCALL 0x80
+ #endif
+ typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
+ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
+ Py_ssize_t nargs, PyObject *kwnames);
+#else
+ #define __Pyx_PyCFunctionFast _PyCFunctionFast
+ #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+#endif
+#if CYTHON_METH_FASTCALL
+ #define __Pyx_METH_FASTCALL METH_FASTCALL
+ #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+ #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+ #define __Pyx_METH_FASTCALL METH_VARARGS
+ #define __Pyx_PyCFunction_FastCall PyCFunction
+ #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+ #define __pyx_vectorcallfunc vectorcallfunc
+ #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET
+ #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+ typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+ size_t nargsf, PyObject *kwnames);
+ #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1))
+ #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+ #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0
+ #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n))
+#endif
+#if PY_VERSION_HEX < 0x030900B1
+ #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b))
+ typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+ #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b)
+ #define __Pyx_PyCMethod PyCMethod
+#endif
+#ifndef METH_METHOD
+ #define METH_METHOD 0x200
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+ #define PyObject_Malloc(s) PyMem_Malloc(s)
+ #define PyObject_Free(p) PyMem_Free(p)
+ #define PyObject_Realloc(p) PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+ #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
+#else
+ #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+ #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
+ #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x03060000
+ #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
+#elif PY_VERSION_HEX >= 0x03000000
+ #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#else
+ #define __Pyx_PyThreadState_Current _PyThreadState_Current
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+ void *result;
+ result = PyModule_GetState(op);
+ if (!result)
+ Py_FatalError("Couldn't find the module state");
+ return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+ #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+ #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name)
+#endif
+#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
+#include "pythread.h"
+#define Py_tss_NEEDS_INIT 0
+typedef int Py_tss_t;
+static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
+ *key = PyThread_create_key();
+ return 0;
+}
+static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
+ Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
+ *key = Py_tss_NEEDS_INIT;
+ return key;
+}
+static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
+ PyObject_Free(key);
+}
+static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
+ return *key != Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
+ PyThread_delete_key(*key);
+ *key = Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
+ return PyThread_set_key_value(*key, value);
+}
+static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
+ return PyThread_get_key_value(*key);
+}
+#endif
+#if PY_MAJOR_VERSION < 3
+ #if CYTHON_COMPILING_IN_PYPY
+ #if PYPY_VERSION_NUM < 0x07030600
+ #if defined(__cplusplus) && __cplusplus >= 201402L
+ [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+ #elif defined(__GNUC__) || defined(__clang__)
+ __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+ #elif defined(_MSC_VER)
+ __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+ #endif
+ static CYTHON_INLINE int PyGILState_Check(void) {
+ return 0;
+ }
+ #else // PYPY_VERSION_NUM < 0x07030600
+ #endif // PYPY_VERSION_NUM < 0x07030600
+ #else
+ static CYTHON_INLINE int PyGILState_Check(void) {
+ PyThreadState * tstate = _PyThreadState_Current;
+ return tstate && (tstate == PyGILState_GetThisThreadState());
+ }
+ #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
+#else
+#define __Pyx_PyDict_NewPresized(n) PyDict_New()
+#endif
+#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
+ #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
+ #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
+#else
+ #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)
+ #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+ PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+ if (res == NULL) PyErr_Clear();
+ return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+ return PyDict_GetItem(dict, name);
+#else
+ PyDictEntry *ep;
+ PyDictObject *mp = (PyDictObject*) dict;
+ long hash = ((PyStringObject *) name)->ob_shash;
+ assert(hash != -1);
+ ep = (mp->ma_lookup)(mp, name, hash);
+ if (ep == NULL) {
+ return NULL;
+ }
+ return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+ #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags)
+ #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+ #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext)
+#else
+ #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp))
+ #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature)
+ #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\
+ PyTypeObject *type = Py_TYPE(obj);\
+ assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+ PyObject_GC_Del(obj);\
+ Py_DECREF(type);\
+}
+#else
+#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj)
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+ #define CYTHON_PEP393_ENABLED 1
+ #define __Pyx_PyUnicode_READY(op) (0)
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u)
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U)
+ #define __Pyx_PyUnicode_KIND(u) ((void)u, (0))
+ #define __Pyx_PyUnicode_DATA(u) ((void*)u)
+ #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+ #define CYTHON_PEP393_ENABLED 1
+ #if PY_VERSION_HEX >= 0x030C0000
+ #define __Pyx_PyUnicode_READY(op) (0)
+ #else
+ #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\
+ 0 : _PyUnicode_Ready((PyObject *)(op)))
+ #endif
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)
+ #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u))
+ #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
+ #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+ #if PY_VERSION_HEX >= 0x030C0000
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u))
+ #else
+ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+ #else
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+ #endif
+ #endif
+#else
+ #define CYTHON_PEP393_ENABLED 0
+ #define PyUnicode_1BYTE_KIND 1
+ #define PyUnicode_2BYTE_KIND 2
+ #define PyUnicode_4BYTE_KIND 4
+ #define __Pyx_PyUnicode_READY(op) (0)
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+ #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE))
+ #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
+ #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+ #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)
+#else
+ #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+ #if !defined(PyUnicode_DecodeUnicodeEscape)
+ #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors)
+ #endif
+ #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+ #undef PyUnicode_Contains
+ #define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
+ #endif
+ #if !defined(PyByteArray_Check)
+ #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)
+ #endif
+ #if !defined(PyObject_Format)
+ #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
+ #endif
+#endif
+#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)
+#else
+ #define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+ #define PyObject_ASCII(o) PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyBaseString_Type PyUnicode_Type
+ #define PyStringObject PyUnicodeObject
+ #define PyString_Type PyUnicode_Type
+ #define PyString_Check PyUnicode_Check
+ #define PyString_CheckExact PyUnicode_CheckExact
+#ifndef PyObject_Unicode
+ #define PyObject_Unicode PyObject_Str
+#endif
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+ #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+ #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+ #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ #define __Pyx_PySequence_ListKeepNew(obj)\
+ (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+ #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj)
+#endif
+#ifndef PySet_CheckExact
+ #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type)
+#endif
+#if PY_VERSION_HEX >= 0x030900A4
+ #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+ #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+ #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+ #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+ #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq)
+#else
+ #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq)
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyIntObject PyLongObject
+ #define PyInt_Type PyLong_Type
+ #define PyInt_Check(op) PyLong_Check(op)
+ #define PyInt_CheckExact(op) PyLong_CheckExact(op)
+ #define __Pyx_Py3Int_Check(op) PyLong_Check(op)
+ #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op)
+ #define PyInt_FromString PyLong_FromString
+ #define PyInt_FromUnicode PyLong_FromUnicode
+ #define PyInt_FromLong PyLong_FromLong
+ #define PyInt_FromSize_t PyLong_FromSize_t
+ #define PyInt_FromSsize_t PyLong_FromSsize_t
+ #define PyInt_AsLong PyLong_AsLong
+ #define PyInt_AS_LONG PyLong_AS_LONG
+ #define PyInt_AsSsize_t PyLong_AsSsize_t
+ #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
+ #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+ #define PyNumber_Int PyNumber_Long
+#else
+ #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op))
+ #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op))
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyBoolObject PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+ #ifndef PyUnicode_InternFromString
+ #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+ #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+ typedef long Py_hash_t;
+ #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+ #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t
+#else
+ #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+ #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t
+#endif
+#if CYTHON_USE_ASYNC_SLOTS
+ #if PY_VERSION_HEX >= 0x030500B1
+ #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+ #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+ #else
+ #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+ #endif
+#else
+ #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef __Pyx_PyAsyncMethodsStruct
+ typedef struct {
+ unaryfunc am_await;
+ unaryfunc am_aiter;
+ unaryfunc am_anext;
+ } __Pyx_PyAsyncMethodsStruct;
+#endif
+
+#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
+ #if !defined(_USE_MATH_DEFINES)
+ #define _USE_MATH_DEFINES
+ #endif
+#endif
+#include
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+ float value;
+ memset(&value, 0xFF, sizeof(value));
+ return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+#define __PYX_MARK_ERR_POS(f_index, lineno) \
+ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
+
+#ifdef CYTHON_EXTERN_C
+ #undef __PYX_EXTERN_C
+ #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+ #ifdef _MSC_VER
+ #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+ #else
+ #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+ #endif
+#else
+ #ifdef __cplusplus
+ #define __PYX_EXTERN_C extern "C"
+ #else
+ #define __PYX_EXTERN_C extern
+ #endif
+#endif
+
+#define __PYX_HAVE__monotonic_align__core
+#define __PYX_HAVE_API__monotonic_align__core
+/* Early includes */
+#include "pythread.h"
+#include
+#include
+#ifdef _OPENMP
+#include
+#endif /* _OPENMP */
+
+#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+ const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\
+ (sizeof(type) < sizeof(Py_ssize_t)) ||\
+ (sizeof(type) > sizeof(Py_ssize_t) &&\
+ likely(v < (type)PY_SSIZE_T_MAX ||\
+ v == (type)PY_SSIZE_T_MAX) &&\
+ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+ v == (type)PY_SSIZE_T_MIN))) ||\
+ (sizeof(type) == sizeof(Py_ssize_t) &&\
+ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+ v == (type)PY_SSIZE_T_MAX))) )
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+ return (size_t) i < (size_t) limit;
+}
+#if defined (__cplusplus) && __cplusplus >= 201103L
+ #include
+ #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+ #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+ #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+ #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+ #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+ #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+ #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+ #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString
+ #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+ #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString
+ #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u)
+{
+ const wchar_t *u_end = u;
+ while (*u_end++) ;
+ return (size_t)(u_end - u - 1);
+}
+#else
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
+{
+ const Py_UNICODE *u_end = u;
+ while (*u_end++) ;
+ return (size_t)(u_end - u - 1);
+}
+#endif
+#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o)
+#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+#define __Pyx_PySequence_Tuple(obj)\
+ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+ #if PY_VERSION_HEX >= 0x030C00A7
+ #ifndef _PyLong_SIGN_MASK
+ #define _PyLong_SIGN_MASK 3
+ #endif
+ #ifndef _PyLong_NON_SIZE_BITS
+ #define _PyLong_NON_SIZE_BITS 3
+ #endif
+ #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+ #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0)
+ #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x))
+ #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1)
+ #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0)
+ #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0])
+ #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+ #define __Pyx_PyLong_SignedDigitCount(x)\
+ ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+ #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+ #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x)
+ #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x)
+ #else
+ #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+ #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+ #endif
+ typedef Py_ssize_t __Pyx_compact_pylong;
+ typedef size_t __Pyx_compact_upylong;
+ #else // Py < 3.12
+ #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0)
+ #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0)
+ #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0)
+ #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0)
+ #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+ #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x))
+ #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x)
+ #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+ #define __Pyx_PyLong_CompactValue(x)\
+ ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+ typedef sdigit __Pyx_compact_pylong;
+ typedef digit __Pyx_compact_upylong;
+ #endif
+ #if PY_VERSION_HEX >= 0x030C00A5
+ #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit)
+ #else
+ #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit)
+ #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+ PyObject* sys;
+ PyObject* default_encoding = NULL;
+ PyObject* ascii_chars_u = NULL;
+ PyObject* ascii_chars_b = NULL;
+ const char* default_encoding_c;
+ sys = PyImport_ImportModule("sys");
+ if (!sys) goto bad;
+ default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+ Py_DECREF(sys);
+ if (!default_encoding) goto bad;
+ default_encoding_c = PyBytes_AsString(default_encoding);
+ if (!default_encoding_c) goto bad;
+ if (strcmp(default_encoding_c, "ascii") == 0) {
+ __Pyx_sys_getdefaultencoding_not_ascii = 0;
+ } else {
+ char ascii_chars[128];
+ int c;
+ for (c = 0; c < 128; c++) {
+ ascii_chars[c] = (char) c;
+ }
+ __Pyx_sys_getdefaultencoding_not_ascii = 1;
+ ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+ if (!ascii_chars_u) goto bad;
+ ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+ if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+ PyErr_Format(
+ PyExc_ValueError,
+ "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+ default_encoding_c);
+ goto bad;
+ }
+ Py_DECREF(ascii_chars_u);
+ Py_DECREF(ascii_chars_b);
+ }
+ Py_DECREF(default_encoding);
+ return 0;
+bad:
+ Py_XDECREF(default_encoding);
+ Py_XDECREF(ascii_chars_u);
+ Py_XDECREF(ascii_chars_b);
+ return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+ PyObject* sys;
+ PyObject* default_encoding = NULL;
+ char* default_encoding_c;
+ sys = PyImport_ImportModule("sys");
+ if (!sys) goto bad;
+ default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+ Py_DECREF(sys);
+ if (!default_encoding) goto bad;
+ default_encoding_c = PyBytes_AsString(default_encoding);
+ if (!default_encoding_c) goto bad;
+ __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
+ if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+ strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+ Py_DECREF(default_encoding);
+ return 0;
+bad:
+ Py_XDECREF(default_encoding);
+ return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+ #define likely(x) __builtin_expect(!!(x), 1)
+ #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+ #define likely(x) (x)
+ #define unlikely(x) (x)
+#endif /* __GNUC__ */
+static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+
+#if !CYTHON_USE_MODULE_STATE
+static PyObject *__pyx_m = NULL;
+#endif
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm = __FILE__;
+static const char *__pyx_filename;
+
+/* #### Code section: filename_table ### */
+
+static const char *__pyx_f[] = {
+ "core.pyx",
+ "",
+};
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+ #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+/* NoFastGil.proto */
+#define __Pyx_PyGILState_Ensure PyGILState_Ensure
+#define __Pyx_PyGILState_Release PyGILState_Release
+#define __Pyx_FastGIL_Remember()
+#define __Pyx_FastGIL_Forget()
+#define __Pyx_FastGilFuncInit()
+
+/* BufferFormatStructs.proto */
+struct __Pyx_StructField_;
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+typedef struct {
+ const char* name;
+ struct __Pyx_StructField_* fields;
+ size_t size;
+ size_t arraysize[8];
+ int ndim;
+ char typegroup;
+ char is_unsigned;
+ int flags;
+} __Pyx_TypeInfo;
+typedef struct __Pyx_StructField_ {
+ __Pyx_TypeInfo* type;
+ const char* name;
+ size_t offset;
+} __Pyx_StructField;
+typedef struct {
+ __Pyx_StructField* field;
+ size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+typedef struct {
+ __Pyx_StructField root;
+ __Pyx_BufFmt_StackElem* head;
+ size_t fmt_offset;
+ size_t new_count, enc_count;
+ size_t struct_alignment;
+ int is_complex;
+ char enc_type;
+ char new_packmode;
+ char enc_packmode;
+ char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+/* Atomics.proto */
+#include
+#ifndef CYTHON_ATOMICS
+ #define CYTHON_ATOMICS 1
+#endif
+#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS
+#define __pyx_atomic_int_type int
+#define __pyx_nonatomic_int_type int
+#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
+ (__STDC_VERSION__ >= 201112L) &&\
+ !defined(__STDC_NO_ATOMICS__))
+ #include
+#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
+ (__cplusplus >= 201103L) ||\
+ (defined(_MSC_VER) && _MSC_VER >= 1700)))
+ #include
+#endif
+#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
+ (__STDC_VERSION__ >= 201112L) &&\
+ !defined(__STDC_NO_ATOMICS__) &&\
+ ATOMIC_INT_LOCK_FREE == 2)
+ #undef __pyx_atomic_int_type
+ #define __pyx_atomic_int_type atomic_int
+ #define __pyx_atomic_incr_aligned(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed)
+ #define __pyx_atomic_decr_aligned(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel)
+ #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
+ #pragma message ("Using standard C atomics")
+ #elif defined(__PYX_DEBUG_ATOMICS)
+ #warning "Using standard C atomics"
+ #endif
+#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
+ (__cplusplus >= 201103L) ||\
+\
+ (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\
+ ATOMIC_INT_LOCK_FREE == 2)
+ #undef __pyx_atomic_int_type
+ #define __pyx_atomic_int_type std::atomic_int
+ #define __pyx_atomic_incr_aligned(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed)
+ #define __pyx_atomic_decr_aligned(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel)
+ #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
+ #pragma message ("Using standard C++ atomics")
+ #elif defined(__PYX_DEBUG_ATOMICS)
+ #warning "Using standard C++ atomics"
+ #endif
+#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\
+ (__GNUC_MINOR__ > 1 ||\
+ (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2))))
+ #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1)
+ #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1)
+ #ifdef __PYX_DEBUG_ATOMICS
+ #warning "Using GNU atomics"
+ #endif
+#elif CYTHON_ATOMICS && defined(_MSC_VER)
+ #include
+ #undef __pyx_atomic_int_type
+ #define __pyx_atomic_int_type long
+ #define __pyx_nonatomic_int_type long
+ #pragma intrinsic (_InterlockedExchangeAdd)
+ #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1)
+ #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1)
+ #ifdef __PYX_DEBUG_ATOMICS
+ #pragma message ("Using MSVC atomics")
+ #endif
+#else
+ #undef CYTHON_ATOMICS
+ #define CYTHON_ATOMICS 0
+ #ifdef __PYX_DEBUG_ATOMICS
+ #warning "Not using atomics"
+ #endif
+#endif
+#if CYTHON_ATOMICS
+ #define __pyx_add_acquisition_count(memview)\
+ __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview))
+ #define __pyx_sub_acquisition_count(memview)\
+ __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview))
+#else
+ #define __pyx_add_acquisition_count(memview)\
+ __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+ #define __pyx_sub_acquisition_count(memview)\
+ __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+#endif
+
+/* MemviewSliceStruct.proto */
+struct __pyx_memoryview_obj;
+typedef struct {
+ struct __pyx_memoryview_obj *memview;
+ char *data;
+ Py_ssize_t shape[8];
+ Py_ssize_t strides[8];
+ Py_ssize_t suboffsets[8];
+} __Pyx_memviewslice;
+#define __Pyx_MemoryView_Len(m) (m.shape[0])
+
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
+
+/*--- Type declarations ---*/
+struct __pyx_array_obj;
+struct __pyx_MemviewEnum_obj;
+struct __pyx_memoryview_obj;
+struct __pyx_memoryviewslice_obj;
+struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each;
+
+/* "monotonic_align/core.pyx":7
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<<
+ * cdef int x
+ * cdef int y
+ */
+struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each {
+ int __pyx_n;
+ float max_neg_val;
+};
+
+/* "View.MemoryView":114
+ * @cython.collection_type("sequence")
+ * @cname("__pyx_array")
+ * cdef class array: # <<<<<<<<<<<<<<
+ *
+ * cdef:
+ */
+struct __pyx_array_obj {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_array *__pyx_vtab;
+ char *data;
+ Py_ssize_t len;
+ char *format;
+ int ndim;
+ Py_ssize_t *_shape;
+ Py_ssize_t *_strides;
+ Py_ssize_t itemsize;
+ PyObject *mode;
+ PyObject *_format;
+ void (*callback_free_data)(void *);
+ int free_data;
+ int dtype_is_object;
+};
+
+
+/* "View.MemoryView":302
+ *
+ * @cname('__pyx_MemviewEnum')
+ * cdef class Enum(object): # <<<<<<<<<<<<<<
+ * cdef object name
+ * def __init__(self, name):
+ */
+struct __pyx_MemviewEnum_obj {
+ PyObject_HEAD
+ PyObject *name;
+};
+
+
+/* "View.MemoryView":337
+ *
+ * @cname('__pyx_memoryview')
+ * cdef class memoryview: # <<<<<<<<<<<<<<
+ *
+ * cdef object obj
+ */
+struct __pyx_memoryview_obj {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_memoryview *__pyx_vtab;
+ PyObject *obj;
+ PyObject *_size;
+ PyObject *_array_interface;
+ PyThread_type_lock lock;
+ __pyx_atomic_int_type acquisition_count;
+ Py_buffer view;
+ int flags;
+ int dtype_is_object;
+ __Pyx_TypeInfo *typeinfo;
+};
+
+
+/* "View.MemoryView":952
+ * @cython.collection_type("sequence")
+ * @cname('__pyx_memoryviewslice')
+ * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<<
+ * "Internal class for passing memoryview slices to Python"
+ *
+ */
+struct __pyx_memoryviewslice_obj {
+ struct __pyx_memoryview_obj __pyx_base;
+ __Pyx_memviewslice from_slice;
+ PyObject *from_object;
+ PyObject *(*to_object_func)(char *);
+ int (*to_dtype_func)(char *, PyObject *);
+};
+
+
+
+/* "View.MemoryView":114
+ * @cython.collection_type("sequence")
+ * @cname("__pyx_array")
+ * cdef class array: # <<<<<<<<<<<<<<
+ *
+ * cdef:
+ */
+
+struct __pyx_vtabstruct_array {
+ PyObject *(*get_memview)(struct __pyx_array_obj *);
+};
+static struct __pyx_vtabstruct_array *__pyx_vtabptr_array;
+
+
+/* "View.MemoryView":337
+ *
+ * @cname('__pyx_memoryview')
+ * cdef class memoryview: # <<<<<<<<<<<<<<
+ *
+ * cdef object obj
+ */
+
+struct __pyx_vtabstruct_memoryview {
+ char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *);
+ PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *);
+ PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
+ PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *);
+ PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
+ PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *);
+ PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *);
+ PyObject *(*_get_base)(struct __pyx_memoryview_obj *);
+};
+static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview;
+
+
+/* "View.MemoryView":952
+ * @cython.collection_type("sequence")
+ * @cname('__pyx_memoryviewslice')
+ * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<<
+ * "Internal class for passing memoryview slices to Python"
+ *
+ */
+
+struct __pyx_vtabstruct__memoryviewslice {
+ struct __pyx_vtabstruct_memoryview __pyx_base;
+};
+static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice;
+/* #### Code section: utility_code_proto ### */
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+ #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+ typedef struct {
+ void (*INCREF)(void*, PyObject*, Py_ssize_t);
+ void (*DECREF)(void*, PyObject*, Py_ssize_t);
+ void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+ void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+ void* (*SetupContext)(const char*, Py_ssize_t, const char*);
+ void (*FinishContext)(void**);
+ } __Pyx_RefNannyAPIStruct;
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+ #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+ if (acquire_gil) {\
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+ PyGILState_Release(__pyx_gilstate_save);\
+ } else {\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+ }
+ #define __Pyx_RefNannyFinishContextNogil() {\
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+ __Pyx_RefNannyFinishContext();\
+ PyGILState_Release(__pyx_gilstate_save);\
+ }
+#else
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+ #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
+#endif
+ #define __Pyx_RefNannyFinishContextNogil() {\
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+ __Pyx_RefNannyFinishContext();\
+ PyGILState_Release(__pyx_gilstate_save);\
+ }
+ #define __Pyx_RefNannyFinishContext()\
+ __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+ #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+ #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+ #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+ #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+ #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+ #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+ #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+ #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
+#else
+ #define __Pyx_RefNannyDeclarations
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)
+ #define __Pyx_RefNannyFinishContextNogil()
+ #define __Pyx_RefNannyFinishContext()
+ #define __Pyx_INCREF(r) Py_INCREF(r)
+ #define __Pyx_DECREF(r) Py_DECREF(r)
+ #define __Pyx_GOTREF(r)
+ #define __Pyx_GIVEREF(r)
+ #define __Pyx_XINCREF(r) Py_XINCREF(r)
+ #define __Pyx_XDECREF(r) Py_XDECREF(r)
+ #define __Pyx_XGOTREF(r)
+ #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+ PyObject *tmp = (PyObject *) r;\
+ r = v; Py_XDECREF(tmp);\
+ } while (0)
+#define __Pyx_XDECREF_SET(r, v) do {\
+ PyObject *tmp = (PyObject *) r;\
+ r = v; __Pyx_XDECREF(tmp);\
+ } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+ PyObject *tmp = (PyObject *) r;\
+ r = v; __Pyx_DECREF(tmp);\
+ } while (0)
+#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
+#endif
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+ #define __Pyx_Arg_FASTCALL(args, i) args[i]
+ #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+ #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+ static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+ #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+#else
+ #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+ #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+ #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+ #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+ #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+ Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+ PyObject **argnames[],
+ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+ const char* function_name);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+ ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+ __Pyx__ArgTypeTest(obj, type, name, exact))
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+ (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+ #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6
+ #ifndef Py_BUILD_CORE
+ #define Py_BUILD_CORE 1
+ #endif
+ #include "internal/pycore_frame.h"
+#endif
+ #define __Pxy_PyFrame_Initialize_Offsets()
+ #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus)
+#else
+ static size_t __pyx_pyframe_localsplus_offset = 0;
+ #include "frameobject.h"
+ #define __Pxy_PyFrame_Initialize_Offsets()\
+ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+ #define __Pyx_PyFrame_GetLocalsplus(frame)\
+ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
+
+/* GCCDiagnostics.proto */
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#define __Pyx_HAS_GCC_DIAGNOSTIC
+#endif
+
+/* BuildPyUnicode.proto */
+static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength,
+ int prepend_sign, char padding_char);
+
+/* CIntToPyUnicode.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char);
+
+/* CIntToPyUnicode.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char);
+
+/* JoinPyUnicode.proto */
+static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength,
+ Py_UCS4 max_char);
+
+/* StrEquals.proto */
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
+#else
+#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
+#endif
+
+/* PyObjectFormatSimple.proto */
+#if CYTHON_COMPILING_IN_PYPY
+ #define __Pyx_PyObject_FormatSimple(s, f) (\
+ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+ PyObject_Format(s, f))
+#elif PY_MAJOR_VERSION < 3
+ #define __Pyx_PyObject_FormatSimple(s, f) (\
+ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+ likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\
+ PyObject_Format(s, f))
+#elif CYTHON_USE_TYPE_SLOTS
+ #define __Pyx_PyObject_FormatSimple(s, f) (\
+ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+ likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\
+ likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\
+ PyObject_Format(s, f))
+#else
+ #define __Pyx_PyObject_FormatSimple(s, f) (\
+ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
+ PyObject_Format(s, f))
+#endif
+
+CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/
+/* GetAttr.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
+
+/* GetItemInt.proto */
+#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
+ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
+ __Pyx_GetItemInt_Generic(o, to_py_func(i))))
+#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+ int wraparound, int boundscheck);
+#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+ int wraparound, int boundscheck);
+static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
+ int is_list, int wraparound, int boundscheck);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* ObjectGetItem.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key);
+#else
+#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key)
+#endif
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
+/* DivInt[Py_ssize_t].proto */
+static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t);
+
+/* UnaryNegOverflows.proto */
+#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\
+ (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
+
+/* GetAttr3.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+ (version_var) = __PYX_GET_DICT_VERSION(dict);\
+ (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+ static PY_UINT64_T __pyx_dict_version = 0;\
+ static PyObject *__pyx_dict_cached_value = NULL;\
+ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+ (VAR) = __pyx_dict_cached_value;\
+ } else {\
+ (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+ }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict) (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP);
+#endif
+
+/* GetModuleGlobalName.proto */
+#if CYTHON_USE_DICT_VERSIONS
+#define __Pyx_GetModuleGlobalName(var, name) do {\
+ static PY_UINT64_T __pyx_dict_version = 0;\
+ static PyObject *__pyx_dict_cached_value = NULL;\
+ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
+ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
+ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+} while(0)
+#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\
+ PY_UINT64_T __pyx_dict_version;\
+ PyObject *__pyx_dict_cached_value;\
+ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+} while(0)
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
+#else
+#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name)
+#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name)
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
+#endif
+
+/* AssertionsEnabled.proto */
+#define __Pyx_init_assertions_enabled()
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+ #define __pyx_assertions_enabled() (1)
+#elif PY_VERSION_HEX < 0x03080000 || CYTHON_COMPILING_IN_PYPY || defined(Py_LIMITED_API)
+ #define __pyx_assertions_enabled() (!Py_OptimizeFlag)
+#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030900A6
+ static int __pyx_assertions_enabled_flag;
+ #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag)
+ #undef __Pyx_init_assertions_enabled
+ static void __Pyx_init_assertions_enabled(void) {
+ __pyx_assertions_enabled_flag = ! _PyInterpreterState_GetConfig(__Pyx_PyThreadState_Current->interp)->optimization_level;
+ }
+#else
+ #define __pyx_assertions_enabled() (!Py_OptimizeFlag)
+#endif
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* GetTopmostException.proto */
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* SwapException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* ImportDottedModule.proto */
+static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple);
+#if PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple);
+#endif
+
+/* ssize_strlen.proto */
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
+
+/* FastTypeChecks.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
+#else
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
+#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
+#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
+#endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+
+CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+/* ListCompAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+ PyListObject* L = (PyListObject*) list;
+ Py_ssize_t len = Py_SIZE(list);
+ if (likely(L->allocated > len)) {
+ Py_INCREF(x);
+ PyList_SET_ITEM(list, len, x);
+ __Pyx_SET_SIZE(list, len + 1);
+ return 0;
+ }
+ return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* PySequenceMultiply.proto */
+#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul)
+static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul);
+
+/* SetItemInt.proto */
+#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+ __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
+ (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
+ __Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
+static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
+ int is_list, int wraparound, int boundscheck);
+
+/* RaiseUnboundLocalError.proto */
+static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
+
+/* DivInt[long].proto */
+static CYTHON_INLINE long __Pyx_div_long(long, long);
+
+/* PySequenceContains.proto */
+static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) {
+ int result = PySequence_Contains(seq, item);
+ return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
+}
+
+/* ImportFrom.proto */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
+
+/* HasAttr.proto */
+static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
+
+/* ErrOccurredWithGIL.proto */
+static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void);
+
+/* PyObject_GenericGetAttrNoDict.proto */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
+#endif
+
+/* PyObject_GenericGetAttr.proto */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
+#endif
+
+/* IncludeStructmemberH.proto */
+#include
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
+/* SetVTable.proto */
+static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable);
+
+/* GetVTable.proto */
+static void* __Pyx_GetVtable(PyTypeObject *type);
+
+/* MergeVTables.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_MergeVtables(PyTypeObject *type);
+#endif
+
+/* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+ CYTHON_UNUSED_VAR(typ);
+ if (!self)
+ return __Pyx_NewRef(func);
+ return PyMethod_New(func, self);
+}
+#else
+ #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD 0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02
+#define __Pyx_CYFUNCTION_CCLASS 0x04
+#define __Pyx_CYFUNCTION_COROUTINE 0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+ (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1
+ #define __Pyx_CyFunction_GetClassObj(f)\
+ (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+ #define __Pyx_CyFunction_GetClassObj(f)\
+ ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+ __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if PY_VERSION_HEX < 0x030900B1
+ PyCFunctionObject func;
+#else
+ PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+ __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0
+ PyObject *func_weakreflist;
+#endif
+ PyObject *func_dict;
+ PyObject *func_name;
+ PyObject *func_qualname;
+ PyObject *func_doc;
+ PyObject *func_globals;
+ PyObject *func_code;
+ PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1
+ PyObject *func_classobj;
+#endif
+ void *defaults;
+ int defaults_pyobjects;
+ size_t defaults_size; // used by FusedFunction for copying defaults
+ int flags;
+ PyObject *defaults_tuple;
+ PyObject *defaults_kwdict;
+ PyObject *(*defaults_getter)(PyObject *);
+ PyObject *func_annotations;
+ PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_IsCyOrPyCFunction(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+ int flags, PyObject* qualname,
+ PyObject *closure,
+ PyObject *module, PyObject *globals,
+ PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+ size_t size,
+ int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+ PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+ PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+ PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+ int flags, PyObject* qualname,
+ PyObject *closure,
+ PyObject *module, PyObject *globals,
+ PyObject* code);
+
+/* CLineInTraceback.proto */
+#ifdef CYTHON_CLINE_IN_TRACEBACK
+#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#else
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#endif
+
+/* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+typedef struct {
+ PyCodeObject* code_object;
+ int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+ int count;
+ int max_count;
+ __Pyx_CodeObjectCacheEntry* entries;
+};
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+ int py_line, const char *filename);
+
+#if PY_MAJOR_VERSION < 3
+ static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+ static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+ #define __Pyx_GetBuffer PyObject_GetBuffer
+ #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+
+/* BufferStructDeclare.proto */
+typedef struct {
+ Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+typedef struct {
+ size_t refcount;
+ Py_buffer pybuffer;
+} __Pyx_Buffer;
+typedef struct {
+ __Pyx_Buffer *rcbuffer;
+ char *data;
+ __Pyx_Buf_DimInfo diminfo[8];
+} __Pyx_LocalBuf_ND;
+
+/* MemviewSliceIsContig.proto */
+static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim);
+
+/* OverlappingSlices.proto */
+static int __pyx_slices_overlap(__Pyx_memviewslice *slice1,
+ __Pyx_memviewslice *slice2,
+ int ndim, size_t itemsize);
+
+/* IsLittleEndian.proto */
+static CYTHON_INLINE int __Pyx_Is_Little_Endian(void);
+
+/* BufferFormatCheck.proto */
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+ __Pyx_BufFmt_StackElem* stack,
+ __Pyx_TypeInfo* type);
+
+/* TypeInfoCompare.proto */
+static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b);
+
+/* MemviewSliceValidateAndInit.proto */
+static int __Pyx_ValidateAndInit_memviewslice(
+ int *axes_specs,
+ int c_or_f_flag,
+ int buf_flags,
+ int ndim,
+ __Pyx_TypeInfo *dtype,
+ __Pyx_BufFmt_StackElem stack[],
+ __Pyx_memviewslice *memviewslice,
+ PyObject *original_obj);
+
+/* ObjectToMemviewSlice.proto */
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *, int writable_flag);
+
+/* ObjectToMemviewSlice.proto */
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *, int writable_flag);
+
+/* ObjectToMemviewSlice.proto */
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag);
+
+/* MemviewSliceCopyTemplate.proto */
+static __Pyx_memviewslice
+__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
+ const char *mode, int ndim,
+ size_t sizeof_dtype, int contig_flag,
+ int dtype_is_object);
+
+/* MemviewSliceInit.proto */
+#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d
+#define __Pyx_MEMVIEW_DIRECT 1
+#define __Pyx_MEMVIEW_PTR 2
+#define __Pyx_MEMVIEW_FULL 4
+#define __Pyx_MEMVIEW_CONTIG 8
+#define __Pyx_MEMVIEW_STRIDED 16
+#define __Pyx_MEMVIEW_FOLLOW 32
+#define __Pyx_IS_C_CONTIG 1
+#define __Pyx_IS_F_CONTIG 2
+static int __Pyx_init_memviewslice(
+ struct __pyx_memoryview_obj *memview,
+ int ndim,
+ __Pyx_memviewslice *memviewslice,
+ int memview_is_new_reference);
+static CYTHON_INLINE int __pyx_add_acquisition_count_locked(
+ __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock);
+static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(
+ __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock);
+#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count)
+#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__)
+#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__)
+static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int);
+static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *);
+
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+/* #### Code section: module_declarations ### */
+static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/
+static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/
+static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/
+static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/
+static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/
+static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/
+static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
+static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
+static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/
+static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
+static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
+static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/
+
+/* Module declarations from "cython.view" */
+
+/* Module declarations from "cython.dataclasses" */
+
+/* Module declarations from "cython" */
+
+/* Module declarations from "monotonic_align.core" */
+static PyObject *__pyx_collections_abc_Sequence = 0;
+static PyObject *generic = 0;
+static PyObject *strided = 0;
+static PyObject *indirect = 0;
+static PyObject *contiguous = 0;
+static PyObject *indirect_contiguous = 0;
+static int __pyx_memoryview_thread_locks_used;
+static PyThread_type_lock __pyx_memoryview_thread_locks[8];
+static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/
+static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/
+static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/
+static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/
+static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/
+static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/
+static PyObject *_unellipsify(PyObject *, int); /*proto*/
+static int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/
+static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/
+static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/
+static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/
+static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/
+static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/
+static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
+static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
+static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/
+static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
+static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/
+static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/
+static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/
+static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/
+static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/
+static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/
+static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/
+static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/
+static int __pyx_memoryview_err_dim(PyObject *, PyObject *, int); /*proto*/
+static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/
+static int __pyx_memoryview_err_no_memory(void); /*proto*/
+static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/
+static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/
+static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/
+static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
+static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
+static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/
+static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
+static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
+/* #### Code section: typeinfo ### */
+static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, __PYX_IS_UNSIGNED(int) ? 'U' : 'I', __PYX_IS_UNSIGNED(int), 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 };
+/* #### Code section: before_global_var ### */
+#define __Pyx_MODULE_NAME "monotonic_align.core"
+extern int __pyx_module_is_main_monotonic_align__core;
+int __pyx_module_is_main_monotonic_align__core = 0;
+
+/* Implementation of "monotonic_align.core" */
+/* #### Code section: global_var ### */
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin___import__;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_MemoryError;
+static PyObject *__pyx_builtin_enumerate;
+static PyObject *__pyx_builtin_TypeError;
+static PyObject *__pyx_builtin_AssertionError;
+static PyObject *__pyx_builtin_Ellipsis;
+static PyObject *__pyx_builtin_id;
+static PyObject *__pyx_builtin_IndexError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k_[] = ": ";
+static const char __pyx_k_O[] = "O";
+static const char __pyx_k_c[] = "c";
+static const char __pyx_k__2[] = ".";
+static const char __pyx_k__3[] = "*";
+static const char __pyx_k__6[] = "'";
+static const char __pyx_k__7[] = ")";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_id[] = "id";
+static const char __pyx_k__23[] = "?";
+static const char __pyx_k_abc[] = "abc";
+static const char __pyx_k_and[] = " and ";
+static const char __pyx_k_got[] = " (got ";
+static const char __pyx_k_new[] = "__new__";
+static const char __pyx_k_obj[] = "obj";
+static const char __pyx_k_sys[] = "sys";
+static const char __pyx_k_base[] = "base";
+static const char __pyx_k_dict[] = "__dict__";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_mode[] = "mode";
+static const char __pyx_k_name[] = "name";
+static const char __pyx_k_ndim[] = "ndim";
+static const char __pyx_k_pack[] = "pack";
+static const char __pyx_k_size[] = "size";
+static const char __pyx_k_spec[] = "__spec__";
+static const char __pyx_k_step[] = "step";
+static const char __pyx_k_stop[] = "stop";
+static const char __pyx_k_t_xs[] = "t_xs";
+static const char __pyx_k_t_ys[] = "t_ys";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_ASCII[] = "ASCII";
+static const char __pyx_k_class[] = "__class__";
+static const char __pyx_k_count[] = "count";
+static const char __pyx_k_error[] = "error";
+static const char __pyx_k_flags[] = "flags";
+static const char __pyx_k_index[] = "index";
+static const char __pyx_k_paths[] = "paths";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_shape[] = "shape";
+static const char __pyx_k_start[] = "start";
+static const char __pyx_k_enable[] = "enable";
+static const char __pyx_k_encode[] = "encode";
+static const char __pyx_k_format[] = "format";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_name_2[] = "__name__";
+static const char __pyx_k_pickle[] = "pickle";
+static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_struct[] = "struct";
+static const char __pyx_k_unpack[] = "unpack";
+static const char __pyx_k_update[] = "update";
+static const char __pyx_k_values[] = "values";
+static const char __pyx_k_disable[] = "disable";
+static const char __pyx_k_fortran[] = "fortran";
+static const char __pyx_k_memview[] = "memview";
+static const char __pyx_k_Ellipsis[] = "Ellipsis";
+static const char __pyx_k_Sequence[] = "Sequence";
+static const char __pyx_k_core_pyx[] = "core.pyx";
+static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_itemsize[] = "itemsize";
+static const char __pyx_k_pyx_type[] = "__pyx_type";
+static const char __pyx_k_register[] = "register";
+static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_enumerate[] = "enumerate";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
+static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_IndexError[] = "IndexError";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_pyx_result[] = "__pyx_result";
+static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
+static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_PickleError[] = "PickleError";
+static const char __pyx_k_collections[] = "collections";
+static const char __pyx_k_initializing[] = "_initializing";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_pyx_checksum[] = "__pyx_checksum";
+static const char __pyx_k_stringsource[] = "";
+static const char __pyx_k_version_info[] = "version_info";
+static const char __pyx_k_class_getitem[] = "__class_getitem__";
+static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_AssertionError[] = "AssertionError";
+static const char __pyx_k_maximum_path_c[] = "maximum_path_c";
+static const char __pyx_k_View_MemoryView[] = "View.MemoryView";
+static const char __pyx_k_allocate_buffer[] = "allocate_buffer";
+static const char __pyx_k_collections_abc[] = "collections.abc";
+static const char __pyx_k_dtype_is_object[] = "dtype_is_object";
+static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
+static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
+static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_strided_and_direct[] = "";
+static const char __pyx_k_monotonic_align_core[] = "monotonic_align.core";
+static const char __pyx_k_strided_and_indirect[] = "";
+static const char __pyx_k_Invalid_shape_in_axis[] = "Invalid shape in axis ";
+static const char __pyx_k_contiguous_and_direct[] = "";
+static const char __pyx_k_Cannot_index_with_type[] = "Cannot index with type '";
+static const char __pyx_k_MemoryView_of_r_object[] = "";
+static const char __pyx_k_MemoryView_of_r_at_0x_x[] = "";
+static const char __pyx_k_contiguous_and_indirect[] = "";
+static const char __pyx_k_Dimension_d_is_not_direct[] = "Dimension %d is not direct";
+static const char __pyx_k_Index_out_of_bounds_axis_d[] = "Index out of bounds (axis %d)";
+static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero (axis %d)";
+static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
+static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
+static const char __pyx_k_strided_and_direct_or_indirect[] = "";
+static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced";
+static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides";
+static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory.";
+static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview";
+static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview";
+static const char __pyx_k_Cannot_transpose_memoryview_with[] = "Cannot transpose memoryview with indirect dimensions";
+static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array";
+static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))";
+static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported";
+static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got ";
+static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis ";
+static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object";
+static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension ";
+static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
+static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides.";
+/* #### Code section: decls ### */
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */
+static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */
+static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */
+static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */
+static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs); /* proto */
+static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+ PyObject *__pyx_d;
+ PyObject *__pyx_b;
+ PyObject *__pyx_cython_runtime;
+ PyObject *__pyx_empty_tuple;
+ PyObject *__pyx_empty_bytes;
+ PyObject *__pyx_empty_unicode;
+ #ifdef __Pyx_CyFunction_USED
+ PyTypeObject *__pyx_CyFunctionType;
+ #endif
+ #ifdef __Pyx_FusedFunction_USED
+ PyTypeObject *__pyx_FusedFunctionType;
+ #endif
+ #ifdef __Pyx_Generator_USED
+ PyTypeObject *__pyx_GeneratorType;
+ #endif
+ #ifdef __Pyx_IterableCoroutine_USED
+ PyTypeObject *__pyx_IterableCoroutineType;
+ #endif
+ #ifdef __Pyx_Coroutine_USED
+ PyTypeObject *__pyx_CoroutineAwaitType;
+ #endif
+ #ifdef __Pyx_Coroutine_USED
+ PyTypeObject *__pyx_CoroutineType;
+ #endif
+ #if CYTHON_USE_MODULE_STATE
+ #endif
+ #if CYTHON_USE_MODULE_STATE
+ #endif
+ #if CYTHON_USE_MODULE_STATE
+ #endif
+ #if CYTHON_USE_MODULE_STATE
+ PyObject *__pyx_type___pyx_array;
+ PyObject *__pyx_type___pyx_MemviewEnum;
+ PyObject *__pyx_type___pyx_memoryview;
+ PyObject *__pyx_type___pyx_memoryviewslice;
+ #endif
+ PyTypeObject *__pyx_array_type;
+ PyTypeObject *__pyx_MemviewEnum_type;
+ PyTypeObject *__pyx_memoryview_type;
+ PyTypeObject *__pyx_memoryviewslice_type;
+ PyObject *__pyx_kp_u_;
+ PyObject *__pyx_n_s_ASCII;
+ PyObject *__pyx_kp_s_All_dimensions_preceding_dimensi;
+ PyObject *__pyx_n_s_AssertionError;
+ PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri;
+ PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is;
+ PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor;
+ PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi;
+ PyObject *__pyx_kp_u_Cannot_index_with_type;
+ PyObject *__pyx_kp_s_Cannot_transpose_memoryview_with;
+ PyObject *__pyx_kp_s_Dimension_d_is_not_direct;
+ PyObject *__pyx_n_s_Ellipsis;
+ PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr;
+ PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0;
+ PyObject *__pyx_n_s_IndexError;
+ PyObject *__pyx_kp_s_Index_out_of_bounds_axis_d;
+ PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte;
+ PyObject *__pyx_kp_u_Invalid_mode_expected_c_or_fortr;
+ PyObject *__pyx_kp_u_Invalid_shape_in_axis;
+ PyObject *__pyx_n_s_MemoryError;
+ PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x;
+ PyObject *__pyx_kp_s_MemoryView_of_r_object;
+ PyObject *__pyx_n_b_O;
+ PyObject *__pyx_kp_u_Out_of_bounds_on_buffer_access_a;
+ PyObject *__pyx_n_s_PickleError;
+ PyObject *__pyx_n_s_Sequence;
+ PyObject *__pyx_kp_s_Step_may_not_be_zero_axis_d;
+ PyObject *__pyx_n_s_TypeError;
+ PyObject *__pyx_kp_s_Unable_to_convert_item_to_object;
+ PyObject *__pyx_n_s_ValueError;
+ PyObject *__pyx_n_s_View_MemoryView;
+ PyObject *__pyx_kp_u__2;
+ PyObject *__pyx_n_s__23;
+ PyObject *__pyx_n_s__3;
+ PyObject *__pyx_kp_u__6;
+ PyObject *__pyx_kp_u__7;
+ PyObject *__pyx_n_s_abc;
+ PyObject *__pyx_n_s_allocate_buffer;
+ PyObject *__pyx_kp_u_and;
+ PyObject *__pyx_n_s_asyncio_coroutines;
+ PyObject *__pyx_n_s_base;
+ PyObject *__pyx_n_s_c;
+ PyObject *__pyx_n_u_c;
+ PyObject *__pyx_n_s_class;
+ PyObject *__pyx_n_s_class_getitem;
+ PyObject *__pyx_n_s_cline_in_traceback;
+ PyObject *__pyx_n_s_collections;
+ PyObject *__pyx_kp_s_collections_abc;
+ PyObject *__pyx_kp_s_contiguous_and_direct;
+ PyObject *__pyx_kp_s_contiguous_and_indirect;
+ PyObject *__pyx_kp_s_core_pyx;
+ PyObject *__pyx_n_s_count;
+ PyObject *__pyx_n_s_dict;
+ PyObject *__pyx_kp_u_disable;
+ PyObject *__pyx_n_s_dtype_is_object;
+ PyObject *__pyx_kp_u_enable;
+ PyObject *__pyx_n_s_encode;
+ PyObject *__pyx_n_s_enumerate;
+ PyObject *__pyx_n_s_error;
+ PyObject *__pyx_n_s_flags;
+ PyObject *__pyx_n_s_format;
+ PyObject *__pyx_n_s_fortran;
+ PyObject *__pyx_n_u_fortran;
+ PyObject *__pyx_kp_u_gc;
+ PyObject *__pyx_n_s_getstate;
+ PyObject *__pyx_kp_u_got;
+ PyObject *__pyx_kp_u_got_differing_extents_in_dimensi;
+ PyObject *__pyx_n_s_id;
+ PyObject *__pyx_n_s_import;
+ PyObject *__pyx_n_s_index;
+ PyObject *__pyx_n_s_initializing;
+ PyObject *__pyx_n_s_is_coroutine;
+ PyObject *__pyx_kp_u_isenabled;
+ PyObject *__pyx_n_s_itemsize;
+ PyObject *__pyx_kp_s_itemsize_0_for_cython_array;
+ PyObject *__pyx_n_s_main;
+ PyObject *__pyx_n_s_maximum_path_c;
+ PyObject *__pyx_n_s_memview;
+ PyObject *__pyx_n_s_mode;
+ PyObject *__pyx_n_s_monotonic_align_core;
+ PyObject *__pyx_n_s_name;
+ PyObject *__pyx_n_s_name_2;
+ PyObject *__pyx_n_s_ndim;
+ PyObject *__pyx_n_s_new;
+ PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+ PyObject *__pyx_n_s_obj;
+ PyObject *__pyx_n_s_pack;
+ PyObject *__pyx_n_s_paths;
+ PyObject *__pyx_n_s_pickle;
+ PyObject *__pyx_n_s_pyx_PickleError;
+ PyObject *__pyx_n_s_pyx_checksum;
+ PyObject *__pyx_n_s_pyx_result;
+ PyObject *__pyx_n_s_pyx_state;
+ PyObject *__pyx_n_s_pyx_type;
+ PyObject *__pyx_n_s_pyx_unpickle_Enum;
+ PyObject *__pyx_n_s_pyx_vtable;
+ PyObject *__pyx_n_s_range;
+ PyObject *__pyx_n_s_reduce;
+ PyObject *__pyx_n_s_reduce_cython;
+ PyObject *__pyx_n_s_reduce_ex;
+ PyObject *__pyx_n_s_register;
+ PyObject *__pyx_n_s_setstate;
+ PyObject *__pyx_n_s_setstate_cython;
+ PyObject *__pyx_n_s_shape;
+ PyObject *__pyx_n_s_size;
+ PyObject *__pyx_n_s_spec;
+ PyObject *__pyx_n_s_start;
+ PyObject *__pyx_n_s_step;
+ PyObject *__pyx_n_s_stop;
+ PyObject *__pyx_kp_s_strided_and_direct;
+ PyObject *__pyx_kp_s_strided_and_direct_or_indirect;
+ PyObject *__pyx_kp_s_strided_and_indirect;
+ PyObject *__pyx_kp_s_stringsource;
+ PyObject *__pyx_n_s_struct;
+ PyObject *__pyx_n_s_sys;
+ PyObject *__pyx_n_s_t_xs;
+ PyObject *__pyx_n_s_t_ys;
+ PyObject *__pyx_n_s_test;
+ PyObject *__pyx_kp_s_unable_to_allocate_array_data;
+ PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str;
+ PyObject *__pyx_n_s_unpack;
+ PyObject *__pyx_n_s_update;
+ PyObject *__pyx_n_s_values;
+ PyObject *__pyx_n_s_version_info;
+ PyObject *__pyx_int_0;
+ PyObject *__pyx_int_1;
+ PyObject *__pyx_int_3;
+ PyObject *__pyx_int_112105877;
+ PyObject *__pyx_int_136983863;
+ PyObject *__pyx_int_184977713;
+ PyObject *__pyx_int_neg_1;
+ float __pyx_k__9;
+ PyObject *__pyx_slice__5;
+ PyObject *__pyx_tuple__4;
+ PyObject *__pyx_tuple__8;
+ PyObject *__pyx_tuple__10;
+ PyObject *__pyx_tuple__11;
+ PyObject *__pyx_tuple__12;
+ PyObject *__pyx_tuple__13;
+ PyObject *__pyx_tuple__14;
+ PyObject *__pyx_tuple__15;
+ PyObject *__pyx_tuple__16;
+ PyObject *__pyx_tuple__17;
+ PyObject *__pyx_tuple__18;
+ PyObject *__pyx_tuple__19;
+ PyObject *__pyx_tuple__21;
+ PyObject *__pyx_codeobj__20;
+ PyObject *__pyx_codeobj__22;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+ extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+ {};
+#else
+ {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+ __pyx_mstate *clear_module_state = __pyx_mstate(m);
+ if (!clear_module_state) return 0;
+ Py_CLEAR(clear_module_state->__pyx_d);
+ Py_CLEAR(clear_module_state->__pyx_b);
+ Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+ Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+ Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+ Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+ #ifdef __Pyx_CyFunction_USED
+ Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+ #endif
+ #ifdef __Pyx_FusedFunction_USED
+ Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+ #endif
+ Py_CLEAR(clear_module_state->__pyx_array_type);
+ Py_CLEAR(clear_module_state->__pyx_type___pyx_array);
+ Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type);
+ Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum);
+ Py_CLEAR(clear_module_state->__pyx_memoryview_type);
+ Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview);
+ Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type);
+ Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_);
+ Py_CLEAR(clear_module_state->__pyx_n_s_ASCII);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi);
+ Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_index_with_type);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Dimension_d_is_not_direct);
+ Py_CLEAR(clear_module_state->__pyx_n_s_Ellipsis);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0);
+ Py_CLEAR(clear_module_state->__pyx_n_s_IndexError);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_shape_in_axis);
+ Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_object);
+ Py_CLEAR(clear_module_state->__pyx_n_b_O);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ Py_CLEAR(clear_module_state->__pyx_n_s_PickleError);
+ Py_CLEAR(clear_module_state->__pyx_n_s_Sequence);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d);
+ Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_Unable_to_convert_item_to_object);
+ Py_CLEAR(clear_module_state->__pyx_n_s_ValueError);
+ Py_CLEAR(clear_module_state->__pyx_n_s_View_MemoryView);
+ Py_CLEAR(clear_module_state->__pyx_kp_u__2);
+ Py_CLEAR(clear_module_state->__pyx_n_s__23);
+ Py_CLEAR(clear_module_state->__pyx_n_s__3);
+ Py_CLEAR(clear_module_state->__pyx_kp_u__6);
+ Py_CLEAR(clear_module_state->__pyx_kp_u__7);
+ Py_CLEAR(clear_module_state->__pyx_n_s_abc);
+ Py_CLEAR(clear_module_state->__pyx_n_s_allocate_buffer);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_and);
+ Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+ Py_CLEAR(clear_module_state->__pyx_n_s_base);
+ Py_CLEAR(clear_module_state->__pyx_n_s_c);
+ Py_CLEAR(clear_module_state->__pyx_n_u_c);
+ Py_CLEAR(clear_module_state->__pyx_n_s_class);
+ Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem);
+ Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+ Py_CLEAR(clear_module_state->__pyx_n_s_collections);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_collections_abc);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_direct);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_indirect);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_core_pyx);
+ Py_CLEAR(clear_module_state->__pyx_n_s_count);
+ Py_CLEAR(clear_module_state->__pyx_n_s_dict);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+ Py_CLEAR(clear_module_state->__pyx_n_s_dtype_is_object);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+ Py_CLEAR(clear_module_state->__pyx_n_s_encode);
+ Py_CLEAR(clear_module_state->__pyx_n_s_enumerate);
+ Py_CLEAR(clear_module_state->__pyx_n_s_error);
+ Py_CLEAR(clear_module_state->__pyx_n_s_flags);
+ Py_CLEAR(clear_module_state->__pyx_n_s_format);
+ Py_CLEAR(clear_module_state->__pyx_n_s_fortran);
+ Py_CLEAR(clear_module_state->__pyx_n_u_fortran);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+ Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_got);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi);
+ Py_CLEAR(clear_module_state->__pyx_n_s_id);
+ Py_CLEAR(clear_module_state->__pyx_n_s_import);
+ Py_CLEAR(clear_module_state->__pyx_n_s_index);
+ Py_CLEAR(clear_module_state->__pyx_n_s_initializing);
+ Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+ Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+ Py_CLEAR(clear_module_state->__pyx_n_s_itemsize);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_itemsize_0_for_cython_array);
+ Py_CLEAR(clear_module_state->__pyx_n_s_main);
+ Py_CLEAR(clear_module_state->__pyx_n_s_maximum_path_c);
+ Py_CLEAR(clear_module_state->__pyx_n_s_memview);
+ Py_CLEAR(clear_module_state->__pyx_n_s_mode);
+ Py_CLEAR(clear_module_state->__pyx_n_s_monotonic_align_core);
+ Py_CLEAR(clear_module_state->__pyx_n_s_name);
+ Py_CLEAR(clear_module_state->__pyx_n_s_name_2);
+ Py_CLEAR(clear_module_state->__pyx_n_s_ndim);
+ Py_CLEAR(clear_module_state->__pyx_n_s_new);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+ Py_CLEAR(clear_module_state->__pyx_n_s_obj);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pack);
+ Py_CLEAR(clear_module_state->__pyx_n_s_paths);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pickle);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Enum);
+ Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable);
+ Py_CLEAR(clear_module_state->__pyx_n_s_range);
+ Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+ Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+ Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+ Py_CLEAR(clear_module_state->__pyx_n_s_register);
+ Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+ Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+ Py_CLEAR(clear_module_state->__pyx_n_s_shape);
+ Py_CLEAR(clear_module_state->__pyx_n_s_size);
+ Py_CLEAR(clear_module_state->__pyx_n_s_spec);
+ Py_CLEAR(clear_module_state->__pyx_n_s_start);
+ Py_CLEAR(clear_module_state->__pyx_n_s_step);
+ Py_CLEAR(clear_module_state->__pyx_n_s_stop);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct_or_indirect);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_indirect);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+ Py_CLEAR(clear_module_state->__pyx_n_s_struct);
+ Py_CLEAR(clear_module_state->__pyx_n_s_sys);
+ Py_CLEAR(clear_module_state->__pyx_n_s_t_xs);
+ Py_CLEAR(clear_module_state->__pyx_n_s_t_ys);
+ Py_CLEAR(clear_module_state->__pyx_n_s_test);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_array_data);
+ Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str);
+ Py_CLEAR(clear_module_state->__pyx_n_s_unpack);
+ Py_CLEAR(clear_module_state->__pyx_n_s_update);
+ Py_CLEAR(clear_module_state->__pyx_n_s_values);
+ Py_CLEAR(clear_module_state->__pyx_n_s_version_info);
+ Py_CLEAR(clear_module_state->__pyx_int_0);
+ Py_CLEAR(clear_module_state->__pyx_int_1);
+ Py_CLEAR(clear_module_state->__pyx_int_3);
+ Py_CLEAR(clear_module_state->__pyx_int_112105877);
+ Py_CLEAR(clear_module_state->__pyx_int_136983863);
+ Py_CLEAR(clear_module_state->__pyx_int_184977713);
+ Py_CLEAR(clear_module_state->__pyx_int_neg_1);
+ Py_CLEAR(clear_module_state->__pyx_slice__5);
+ Py_CLEAR(clear_module_state->__pyx_tuple__4);
+ Py_CLEAR(clear_module_state->__pyx_tuple__8);
+ Py_CLEAR(clear_module_state->__pyx_tuple__10);
+ Py_CLEAR(clear_module_state->__pyx_tuple__11);
+ Py_CLEAR(clear_module_state->__pyx_tuple__12);
+ Py_CLEAR(clear_module_state->__pyx_tuple__13);
+ Py_CLEAR(clear_module_state->__pyx_tuple__14);
+ Py_CLEAR(clear_module_state->__pyx_tuple__15);
+ Py_CLEAR(clear_module_state->__pyx_tuple__16);
+ Py_CLEAR(clear_module_state->__pyx_tuple__17);
+ Py_CLEAR(clear_module_state->__pyx_tuple__18);
+ Py_CLEAR(clear_module_state->__pyx_tuple__19);
+ Py_CLEAR(clear_module_state->__pyx_tuple__21);
+ Py_CLEAR(clear_module_state->__pyx_codeobj__20);
+ Py_CLEAR(clear_module_state->__pyx_codeobj__22);
+ return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+ __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+ if (!traverse_module_state) return 0;
+ Py_VISIT(traverse_module_state->__pyx_d);
+ Py_VISIT(traverse_module_state->__pyx_b);
+ Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+ Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+ Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+ Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+ #ifdef __Pyx_CyFunction_USED
+ Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+ #endif
+ #ifdef __Pyx_FusedFunction_USED
+ Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+ #endif
+ Py_VISIT(traverse_module_state->__pyx_array_type);
+ Py_VISIT(traverse_module_state->__pyx_type___pyx_array);
+ Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type);
+ Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum);
+ Py_VISIT(traverse_module_state->__pyx_memoryview_type);
+ Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview);
+ Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type);
+ Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_);
+ Py_VISIT(traverse_module_state->__pyx_n_s_ASCII);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi);
+ Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_index_with_type);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Dimension_d_is_not_direct);
+ Py_VISIT(traverse_module_state->__pyx_n_s_Ellipsis);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0);
+ Py_VISIT(traverse_module_state->__pyx_n_s_IndexError);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_shape_in_axis);
+ Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_object);
+ Py_VISIT(traverse_module_state->__pyx_n_b_O);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ Py_VISIT(traverse_module_state->__pyx_n_s_PickleError);
+ Py_VISIT(traverse_module_state->__pyx_n_s_Sequence);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d);
+ Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_Unable_to_convert_item_to_object);
+ Py_VISIT(traverse_module_state->__pyx_n_s_ValueError);
+ Py_VISIT(traverse_module_state->__pyx_n_s_View_MemoryView);
+ Py_VISIT(traverse_module_state->__pyx_kp_u__2);
+ Py_VISIT(traverse_module_state->__pyx_n_s__23);
+ Py_VISIT(traverse_module_state->__pyx_n_s__3);
+ Py_VISIT(traverse_module_state->__pyx_kp_u__6);
+ Py_VISIT(traverse_module_state->__pyx_kp_u__7);
+ Py_VISIT(traverse_module_state->__pyx_n_s_abc);
+ Py_VISIT(traverse_module_state->__pyx_n_s_allocate_buffer);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_and);
+ Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+ Py_VISIT(traverse_module_state->__pyx_n_s_base);
+ Py_VISIT(traverse_module_state->__pyx_n_s_c);
+ Py_VISIT(traverse_module_state->__pyx_n_u_c);
+ Py_VISIT(traverse_module_state->__pyx_n_s_class);
+ Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem);
+ Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+ Py_VISIT(traverse_module_state->__pyx_n_s_collections);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_collections_abc);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_direct);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_indirect);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_core_pyx);
+ Py_VISIT(traverse_module_state->__pyx_n_s_count);
+ Py_VISIT(traverse_module_state->__pyx_n_s_dict);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+ Py_VISIT(traverse_module_state->__pyx_n_s_dtype_is_object);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+ Py_VISIT(traverse_module_state->__pyx_n_s_encode);
+ Py_VISIT(traverse_module_state->__pyx_n_s_enumerate);
+ Py_VISIT(traverse_module_state->__pyx_n_s_error);
+ Py_VISIT(traverse_module_state->__pyx_n_s_flags);
+ Py_VISIT(traverse_module_state->__pyx_n_s_format);
+ Py_VISIT(traverse_module_state->__pyx_n_s_fortran);
+ Py_VISIT(traverse_module_state->__pyx_n_u_fortran);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+ Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_got);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi);
+ Py_VISIT(traverse_module_state->__pyx_n_s_id);
+ Py_VISIT(traverse_module_state->__pyx_n_s_import);
+ Py_VISIT(traverse_module_state->__pyx_n_s_index);
+ Py_VISIT(traverse_module_state->__pyx_n_s_initializing);
+ Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+ Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+ Py_VISIT(traverse_module_state->__pyx_n_s_itemsize);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_itemsize_0_for_cython_array);
+ Py_VISIT(traverse_module_state->__pyx_n_s_main);
+ Py_VISIT(traverse_module_state->__pyx_n_s_maximum_path_c);
+ Py_VISIT(traverse_module_state->__pyx_n_s_memview);
+ Py_VISIT(traverse_module_state->__pyx_n_s_mode);
+ Py_VISIT(traverse_module_state->__pyx_n_s_monotonic_align_core);
+ Py_VISIT(traverse_module_state->__pyx_n_s_name);
+ Py_VISIT(traverse_module_state->__pyx_n_s_name_2);
+ Py_VISIT(traverse_module_state->__pyx_n_s_ndim);
+ Py_VISIT(traverse_module_state->__pyx_n_s_new);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+ Py_VISIT(traverse_module_state->__pyx_n_s_obj);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pack);
+ Py_VISIT(traverse_module_state->__pyx_n_s_paths);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pickle);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Enum);
+ Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable);
+ Py_VISIT(traverse_module_state->__pyx_n_s_range);
+ Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+ Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+ Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+ Py_VISIT(traverse_module_state->__pyx_n_s_register);
+ Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+ Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+ Py_VISIT(traverse_module_state->__pyx_n_s_shape);
+ Py_VISIT(traverse_module_state->__pyx_n_s_size);
+ Py_VISIT(traverse_module_state->__pyx_n_s_spec);
+ Py_VISIT(traverse_module_state->__pyx_n_s_start);
+ Py_VISIT(traverse_module_state->__pyx_n_s_step);
+ Py_VISIT(traverse_module_state->__pyx_n_s_stop);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct_or_indirect);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_indirect);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+ Py_VISIT(traverse_module_state->__pyx_n_s_struct);
+ Py_VISIT(traverse_module_state->__pyx_n_s_sys);
+ Py_VISIT(traverse_module_state->__pyx_n_s_t_xs);
+ Py_VISIT(traverse_module_state->__pyx_n_s_t_ys);
+ Py_VISIT(traverse_module_state->__pyx_n_s_test);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_array_data);
+ Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str);
+ Py_VISIT(traverse_module_state->__pyx_n_s_unpack);
+ Py_VISIT(traverse_module_state->__pyx_n_s_update);
+ Py_VISIT(traverse_module_state->__pyx_n_s_values);
+ Py_VISIT(traverse_module_state->__pyx_n_s_version_info);
+ Py_VISIT(traverse_module_state->__pyx_int_0);
+ Py_VISIT(traverse_module_state->__pyx_int_1);
+ Py_VISIT(traverse_module_state->__pyx_int_3);
+ Py_VISIT(traverse_module_state->__pyx_int_112105877);
+ Py_VISIT(traverse_module_state->__pyx_int_136983863);
+ Py_VISIT(traverse_module_state->__pyx_int_184977713);
+ Py_VISIT(traverse_module_state->__pyx_int_neg_1);
+ Py_VISIT(traverse_module_state->__pyx_slice__5);
+ Py_VISIT(traverse_module_state->__pyx_tuple__4);
+ Py_VISIT(traverse_module_state->__pyx_tuple__8);
+ Py_VISIT(traverse_module_state->__pyx_tuple__10);
+ Py_VISIT(traverse_module_state->__pyx_tuple__11);
+ Py_VISIT(traverse_module_state->__pyx_tuple__12);
+ Py_VISIT(traverse_module_state->__pyx_tuple__13);
+ Py_VISIT(traverse_module_state->__pyx_tuple__14);
+ Py_VISIT(traverse_module_state->__pyx_tuple__15);
+ Py_VISIT(traverse_module_state->__pyx_tuple__16);
+ Py_VISIT(traverse_module_state->__pyx_tuple__17);
+ Py_VISIT(traverse_module_state->__pyx_tuple__18);
+ Py_VISIT(traverse_module_state->__pyx_tuple__19);
+ Py_VISIT(traverse_module_state->__pyx_tuple__21);
+ Py_VISIT(traverse_module_state->__pyx_codeobj__20);
+ Py_VISIT(traverse_module_state->__pyx_codeobj__22);
+ return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type___pyx_array __pyx_mstate_global->__pyx_type___pyx_array
+#define __pyx_type___pyx_MemviewEnum __pyx_mstate_global->__pyx_type___pyx_MemviewEnum
+#define __pyx_type___pyx_memoryview __pyx_mstate_global->__pyx_type___pyx_memoryview
+#define __pyx_type___pyx_memoryviewslice __pyx_mstate_global->__pyx_type___pyx_memoryviewslice
+#endif
+#define __pyx_array_type __pyx_mstate_global->__pyx_array_type
+#define __pyx_MemviewEnum_type __pyx_mstate_global->__pyx_MemviewEnum_type
+#define __pyx_memoryview_type __pyx_mstate_global->__pyx_memoryview_type
+#define __pyx_memoryviewslice_type __pyx_mstate_global->__pyx_memoryviewslice_type
+#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_
+#define __pyx_n_s_ASCII __pyx_mstate_global->__pyx_n_s_ASCII
+#define __pyx_kp_s_All_dimensions_preceding_dimensi __pyx_mstate_global->__pyx_kp_s_All_dimensions_preceding_dimensi
+#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError
+#define __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_mstate_global->__pyx_kp_s_Buffer_view_does_not_expose_stri
+#define __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_mstate_global->__pyx_kp_s_Can_only_create_a_buffer_that_is
+#define __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_mstate_global->__pyx_kp_s_Cannot_assign_to_read_only_memor
+#define __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_mstate_global->__pyx_kp_s_Cannot_create_writable_memory_vi
+#define __pyx_kp_u_Cannot_index_with_type __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type
+#define __pyx_kp_s_Cannot_transpose_memoryview_with __pyx_mstate_global->__pyx_kp_s_Cannot_transpose_memoryview_with
+#define __pyx_kp_s_Dimension_d_is_not_direct __pyx_mstate_global->__pyx_kp_s_Dimension_d_is_not_direct
+#define __pyx_n_s_Ellipsis __pyx_mstate_global->__pyx_n_s_Ellipsis
+#define __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_mstate_global->__pyx_kp_s_Empty_shape_tuple_for_cython_arr
+#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0
+#define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError
+#define __pyx_kp_s_Index_out_of_bounds_axis_d __pyx_mstate_global->__pyx_kp_s_Index_out_of_bounds_axis_d
+#define __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_mstate_global->__pyx_kp_s_Indirect_dimensions_not_supporte
+#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr
+#define __pyx_kp_u_Invalid_shape_in_axis __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_at_0x_x
+#define __pyx_kp_s_MemoryView_of_r_object __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_object
+#define __pyx_n_b_O __pyx_mstate_global->__pyx_n_b_O
+#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a
+#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError
+#define __pyx_n_s_Sequence __pyx_mstate_global->__pyx_n_s_Sequence
+#define __pyx_kp_s_Step_may_not_be_zero_axis_d __pyx_mstate_global->__pyx_kp_s_Step_may_not_be_zero_axis_d
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_kp_s_Unable_to_convert_item_to_object __pyx_mstate_global->__pyx_kp_s_Unable_to_convert_item_to_object
+#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError
+#define __pyx_n_s_View_MemoryView __pyx_mstate_global->__pyx_n_s_View_MemoryView
+#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2
+#define __pyx_n_s__23 __pyx_mstate_global->__pyx_n_s__23
+#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3
+#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6
+#define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7
+#define __pyx_n_s_abc __pyx_mstate_global->__pyx_n_s_abc
+#define __pyx_n_s_allocate_buffer __pyx_mstate_global->__pyx_n_s_allocate_buffer
+#define __pyx_kp_u_and __pyx_mstate_global->__pyx_kp_u_and
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_base __pyx_mstate_global->__pyx_n_s_base
+#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c
+#define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c
+#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class
+#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections
+#define __pyx_kp_s_collections_abc __pyx_mstate_global->__pyx_kp_s_collections_abc
+#define __pyx_kp_s_contiguous_and_direct __pyx_mstate_global->__pyx_kp_s_contiguous_and_direct
+#define __pyx_kp_s_contiguous_and_indirect __pyx_mstate_global->__pyx_kp_s_contiguous_and_indirect
+#define __pyx_kp_s_core_pyx __pyx_mstate_global->__pyx_kp_s_core_pyx
+#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count
+#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_n_s_dtype_is_object __pyx_mstate_global->__pyx_n_s_dtype_is_object
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode
+#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate
+#define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error
+#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags
+#define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format
+#define __pyx_n_s_fortran __pyx_mstate_global->__pyx_n_s_fortran
+#define __pyx_n_u_fortran __pyx_mstate_global->__pyx_n_u_fortran
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got
+#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi
+#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id
+#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
+#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index
+#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_itemsize __pyx_mstate_global->__pyx_n_s_itemsize
+#define __pyx_kp_s_itemsize_0_for_cython_array __pyx_mstate_global->__pyx_kp_s_itemsize_0_for_cython_array
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_maximum_path_c __pyx_mstate_global->__pyx_n_s_maximum_path_c
+#define __pyx_n_s_memview __pyx_mstate_global->__pyx_n_s_memview
+#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode
+#define __pyx_n_s_monotonic_align_core __pyx_mstate_global->__pyx_n_s_monotonic_align_core
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2
+#define __pyx_n_s_ndim __pyx_mstate_global->__pyx_n_s_ndim
+#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj
+#define __pyx_n_s_pack __pyx_mstate_global->__pyx_n_s_pack
+#define __pyx_n_s_paths __pyx_mstate_global->__pyx_n_s_paths
+#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle
+#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError
+#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum
+#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type
+#define __pyx_n_s_pyx_unpickle_Enum __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Enum
+#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable
+#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_register __pyx_mstate_global->__pyx_n_s_register
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_shape __pyx_mstate_global->__pyx_n_s_shape
+#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size
+#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec
+#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start
+#define __pyx_n_s_step __pyx_mstate_global->__pyx_n_s_step
+#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop
+#define __pyx_kp_s_strided_and_direct __pyx_mstate_global->__pyx_kp_s_strided_and_direct
+#define __pyx_kp_s_strided_and_direct_or_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_direct_or_indirect
+#define __pyx_kp_s_strided_and_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_indirect
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_struct __pyx_mstate_global->__pyx_n_s_struct
+#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys
+#define __pyx_n_s_t_xs __pyx_mstate_global->__pyx_n_s_t_xs
+#define __pyx_n_s_t_ys __pyx_mstate_global->__pyx_n_s_t_ys
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_kp_s_unable_to_allocate_array_data __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_array_data
+#define __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_shape_and_str
+#define __pyx_n_s_unpack __pyx_mstate_global->__pyx_n_s_unpack
+#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update
+#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values
+#define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info
+#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
+#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1
+#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3
+#define __pyx_int_112105877 __pyx_mstate_global->__pyx_int_112105877
+#define __pyx_int_136983863 __pyx_mstate_global->__pyx_int_136983863
+#define __pyx_int_184977713 __pyx_mstate_global->__pyx_int_184977713
+#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1
+#define __pyx_k__9 __pyx_mstate_global->__pyx_k__9
+#define __pyx_slice__5 __pyx_mstate_global->__pyx_slice__5
+#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4
+#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8
+#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10
+#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11
+#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12
+#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13
+#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14
+#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15
+#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16
+#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17
+#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18
+#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19
+#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21
+#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20
+#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
+/* #### Code section: module_code ### */
+
+/* "View.MemoryView":131
+ * cdef bint dtype_is_object
+ *
+ * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
+ * mode="c", bint allocate_buffer=True):
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_shape = 0;
+ Py_ssize_t __pyx_v_itemsize;
+ PyObject *__pyx_v_format = 0;
+ PyObject *__pyx_v_mode = 0;
+ int __pyx_v_allocate_buffer;
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+ {
+ PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0};
+ PyObject* values[5] = {0,0,0,0,0};
+ values[3] = ((PyObject *)__pyx_n_s_c);
+ if (__pyx_kwds) {
+ Py_ssize_t kw_args;
+ switch (__pyx_nargs) {
+ case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+ switch (__pyx_nargs) {
+ case 0:
+ if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shape)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+ else goto __pyx_L5_argtuple_error;
+ CYTHON_FALLTHROUGH;
+ case 1:
+ if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itemsize)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+ else {
+ __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 131, __pyx_L3_error)
+ }
+ CYTHON_FALLTHROUGH;
+ case 2:
+ if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_format)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+ else {
+ __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 131, __pyx_L3_error)
+ }
+ CYTHON_FALLTHROUGH;
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode);
+ if (value) { values[3] = value; kw_args--; }
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+ }
+ CYTHON_FALLTHROUGH;
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allocate_buffer);
+ if (value) { values[4] = value; kw_args--; }
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ const Py_ssize_t kwd_pos_args = __pyx_nargs;
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 131, __pyx_L3_error)
+ }
+ } else {
+ switch (__pyx_nargs) {
+ case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
+ values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
+ values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_shape = ((PyObject*)values[0]);
+ __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+ __pyx_v_format = values[2];
+ __pyx_v_mode = values[3];
+ if (values[4]) {
+ __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 132, __pyx_L3_error)
+ } else {
+
+ /* "View.MemoryView":132
+ *
+ * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,
+ * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<<
+ *
+ * cdef int idx
+ */
+ __pyx_v_allocate_buffer = ((int)1);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 131, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 131, __pyx_L1_error)
+ if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) {
+ PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 131, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer);
+
+ /* "View.MemoryView":131
+ * cdef bint dtype_is_object
+ *
+ * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
+ * mode="c", bint allocate_buffer=True):
+ *
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) {
+ int __pyx_v_idx;
+ Py_ssize_t __pyx_v_dim;
+ char __pyx_v_order;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ Py_ssize_t __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_t_7;
+ char *__pyx_t_8;
+ Py_ssize_t __pyx_t_9;
+ Py_UCS4 __pyx_t_10;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__cinit__", 0);
+ __Pyx_INCREF(__pyx_v_format);
+
+ /* "View.MemoryView":137
+ * cdef Py_ssize_t dim
+ *
+ * self.ndim = len(shape) # <<<<<<<<<<<<<<
+ * self.itemsize = itemsize
+ *
+ */
+ if (unlikely(__pyx_v_shape == Py_None)) {
+ PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+ __PYX_ERR(1, 137, __pyx_L1_error)
+ }
+ __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 137, __pyx_L1_error)
+ __pyx_v_self->ndim = ((int)__pyx_t_1);
+
+ /* "View.MemoryView":138
+ *
+ * self.ndim = len(shape)
+ * self.itemsize = itemsize # <<<<<<<<<<<<<<
+ *
+ * if not self.ndim:
+ */
+ __pyx_v_self->itemsize = __pyx_v_itemsize;
+
+ /* "View.MemoryView":140
+ * self.itemsize = itemsize
+ *
+ * if not self.ndim: # <<<<<<<<<<<<<<
+ * raise ValueError, "Empty shape tuple for cython.array"
+ *
+ */
+ __pyx_t_2 = (!(__pyx_v_self->ndim != 0));
+ if (unlikely(__pyx_t_2)) {
+
+ /* "View.MemoryView":141
+ *
+ * if not self.ndim:
+ * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<<
+ *
+ * if itemsize <= 0:
+ */
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Empty_shape_tuple_for_cython_arr, 0, 0);
+ __PYX_ERR(1, 141, __pyx_L1_error)
+
+ /* "View.MemoryView":140
+ * self.itemsize = itemsize
+ *
+ * if not self.ndim: # <<<<<<<<<<<<<<
+ * raise ValueError, "Empty shape tuple for cython.array"
+ *
+ */
+ }
+
+ /* "View.MemoryView":143
+ * raise ValueError, "Empty shape tuple for cython.array"
+ *
+ * if itemsize <= 0: # <<<<<<<<<<<<<<
+ * raise ValueError, "itemsize <= 0 for cython.array"
+ *
+ */
+ __pyx_t_2 = (__pyx_v_itemsize <= 0);
+ if (unlikely(__pyx_t_2)) {
+
+ /* "View.MemoryView":144
+ *
+ * if itemsize <= 0:
+ * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<<
+ *
+ * if not isinstance(format, bytes):
+ */
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_itemsize_0_for_cython_array, 0, 0);
+ __PYX_ERR(1, 144, __pyx_L1_error)
+
+ /* "View.MemoryView":143
+ * raise ValueError, "Empty shape tuple for cython.array"
+ *
+ * if itemsize <= 0: # <<<<<<<<<<<<<<
+ * raise ValueError, "itemsize <= 0 for cython.array"
+ *
+ */
+ }
+
+ /* "View.MemoryView":146
+ * raise ValueError, "itemsize <= 0 for cython.array"
+ *
+ * if not isinstance(format, bytes): # <<<<<<<<<<<<<<
+ * format = format.encode('ASCII')
+ * self._format = format # keep a reference to the byte string
+ */
+ __pyx_t_2 = PyBytes_Check(__pyx_v_format);
+ __pyx_t_3 = (!__pyx_t_2);
+ if (__pyx_t_3) {
+
+ /* "View.MemoryView":147
+ *
+ * if not isinstance(format, bytes):
+ * format = format.encode('ASCII') # <<<<<<<<<<<<<<
+ * self._format = format # keep a reference to the byte string
+ * self.format = self._format
+ */
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = NULL;
+ __pyx_t_7 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ __pyx_t_7 = 1;
+ }
+ }
+ {
+ PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_n_s_ASCII};
+ __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4);
+ __pyx_t_4 = 0;
+
+ /* "View.MemoryView":146
+ * raise ValueError, "itemsize <= 0 for cython.array"
+ *
+ * if not isinstance(format, bytes): # <<<<<<<<<<<<<<
+ * format = format.encode('ASCII')
+ * self._format = format # keep a reference to the byte string
+ */
+ }
+
+ /* "View.MemoryView":148
+ * if not isinstance(format, bytes):
+ * format = format.encode('ASCII')
+ * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<<
+ * self.format = self._format
+ *
+ */
+ if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_format))) __PYX_ERR(1, 148, __pyx_L1_error)
+ __pyx_t_4 = __pyx_v_format;
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_4);
+ __Pyx_GOTREF(__pyx_v_self->_format);
+ __Pyx_DECREF(__pyx_v_self->_format);
+ __pyx_v_self->_format = ((PyObject*)__pyx_t_4);
+ __pyx_t_4 = 0;
+
+ /* "View.MemoryView":149
+ * format = format.encode('ASCII')
+ * self._format = format # keep a reference to the byte string
+ * self.format = self._format # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(__pyx_v_self->_format == Py_None)) {
+ PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+ __PYX_ERR(1, 149, __pyx_L1_error)
+ }
+ __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error)
+ __pyx_v_self->format = __pyx_t_8;
+
+ /* "View.MemoryView":152
+ *
+ *
+ * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<<
+ * self._strides = self._shape + self.ndim
+ *
+ */
+ __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2)));
+
+ /* "View.MemoryView":153
+ *
+ * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)
+ * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<<
+ *
+ * if not self._shape:
+ */
+ __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim);
+
+ /* "View.MemoryView":155
+ * self._strides = self._shape + self.ndim
+ *
+ * if not self._shape: # <<<<<<<<<<<<<<
+ * raise MemoryError, "unable to allocate shape and strides."
+ *
+ */
+ __pyx_t_3 = (!(__pyx_v_self->_shape != 0));
+ if (unlikely(__pyx_t_3)) {
+
+ /* "View.MemoryView":156
+ *
+ * if not self._shape:
+ * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_shape_and_str, 0, 0);
+ __PYX_ERR(1, 156, __pyx_L1_error)
+
+ /* "View.MemoryView":155
+ * self._strides = self._shape + self.ndim
+ *
+ * if not self._shape: # <<<<<<<<<<<<<<
+ * raise MemoryError, "unable to allocate shape and strides."
+ *
+ */
+ }
+
+ /* "View.MemoryView":159
+ *
+ *
+ * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<<
+ * if dim <= 0:
+ * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
+ */
+ __pyx_t_7 = 0;
+ __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); __pyx_t_1 = 0;
+ for (;;) {
+ if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(1, 159, __pyx_L1_error)
+ #else
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ #endif
+ __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 159, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_dim = __pyx_t_9;
+ __pyx_v_idx = __pyx_t_7;
+ __pyx_t_7 = (__pyx_t_7 + 1);
+
+ /* "View.MemoryView":160
+ *
+ * for idx, dim in enumerate(shape):
+ * if dim <= 0: # <<<<<<<<<<<<<<
+ * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
+ * self._shape[idx] = dim
+ */
+ __pyx_t_3 = (__pyx_v_dim <= 0);
+ if (unlikely(__pyx_t_3)) {
+
+ /* "View.MemoryView":161
+ * for idx, dim in enumerate(shape):
+ * if dim <= 0:
+ * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<<
+ * self._shape[idx] = dim
+ *
+ */
+ __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 161, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_9 = 0;
+ __pyx_t_10 = 127;
+ __Pyx_INCREF(__pyx_kp_u_Invalid_shape_in_axis);
+ __pyx_t_9 += 22;
+ __Pyx_GIVEREF(__pyx_kp_u_Invalid_shape_in_axis);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Invalid_shape_in_axis);
+ __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __Pyx_INCREF(__pyx_kp_u_);
+ __pyx_t_9 += 2;
+ __Pyx_GIVEREF(__pyx_kp_u_);
+ PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_);
+ __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __Pyx_INCREF(__pyx_kp_u__2);
+ __pyx_t_9 += 1;
+ __Pyx_GIVEREF(__pyx_kp_u__2);
+ PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u__2);
+ __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __PYX_ERR(1, 161, __pyx_L1_error)
+
+ /* "View.MemoryView":160
+ *
+ * for idx, dim in enumerate(shape):
+ * if dim <= 0: # <<<<<<<<<<<<<<
+ * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
+ * self._shape[idx] = dim
+ */
+ }
+
+ /* "View.MemoryView":162
+ * if dim <= 0:
+ * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
+ * self._shape[idx] = dim # <<<<<<<<<<<<<<
+ *
+ * cdef char order
+ */
+ (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim;
+
+ /* "View.MemoryView":159
+ *
+ *
+ * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<<
+ * if dim <= 0:
+ * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
+ */
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+ /* "View.MemoryView":165
+ *
+ * cdef char order
+ * if mode == 'c': # <<<<<<<<<<<<<<
+ * order = b'C'
+ * self.mode = u'c'
+ */
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 165, __pyx_L1_error)
+ if (__pyx_t_3) {
+
+ /* "View.MemoryView":166
+ * cdef char order
+ * if mode == 'c':
+ * order = b'C' # <<<<<<<<<<<<<<
+ * self.mode = u'c'
+ * elif mode == 'fortran':
+ */
+ __pyx_v_order = 'C';
+
+ /* "View.MemoryView":167
+ * if mode == 'c':
+ * order = b'C'
+ * self.mode = u'c' # <<<<<<<<<<<<<<
+ * elif mode == 'fortran':
+ * order = b'F'
+ */
+ __Pyx_INCREF(__pyx_n_u_c);
+ __Pyx_GIVEREF(__pyx_n_u_c);
+ __Pyx_GOTREF(__pyx_v_self->mode);
+ __Pyx_DECREF(__pyx_v_self->mode);
+ __pyx_v_self->mode = __pyx_n_u_c;
+
+ /* "View.MemoryView":165
+ *
+ * cdef char order
+ * if mode == 'c': # <<<<<<<<<<<<<<
+ * order = b'C'
+ * self.mode = u'c'
+ */
+ goto __pyx_L11;
+ }
+
+ /* "View.MemoryView":168
+ * order = b'C'
+ * self.mode = u'c'
+ * elif mode == 'fortran': # <<<<<<<<<<<<<<
+ * order = b'F'
+ * self.mode = u'fortran'
+ */
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 168, __pyx_L1_error)
+ if (likely(__pyx_t_3)) {
+
+ /* "View.MemoryView":169
+ * self.mode = u'c'
+ * elif mode == 'fortran':
+ * order = b'F' # <<<<<<<<<<<<<<
+ * self.mode = u'fortran'
+ * else:
+ */
+ __pyx_v_order = 'F';
+
+ /* "View.MemoryView":170
+ * elif mode == 'fortran':
+ * order = b'F'
+ * self.mode = u'fortran' # <<<<<<<<<<<<<<
+ * else:
+ * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}"
+ */
+ __Pyx_INCREF(__pyx_n_u_fortran);
+ __Pyx_GIVEREF(__pyx_n_u_fortran);
+ __Pyx_GOTREF(__pyx_v_self->mode);
+ __Pyx_DECREF(__pyx_v_self->mode);
+ __pyx_v_self->mode = __pyx_n_u_fortran;
+
+ /* "View.MemoryView":168
+ * order = b'C'
+ * self.mode = u'c'
+ * elif mode == 'fortran': # <<<<<<<<<<<<<<
+ * order = b'F'
+ * self.mode = u'fortran'
+ */
+ goto __pyx_L11;
+ }
+
+ /* "View.MemoryView":172
+ * self.mode = u'fortran'
+ * else:
+ * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<<
+ *
+ * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order)
+ */
+ /*else*/ {
+ __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 172, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 172, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __PYX_ERR(1, 172, __pyx_L1_error)
+ }
+ __pyx_L11:;
+
+ /* "View.MemoryView":174
+ * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}"
+ *
+ * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<<
+ *
+ * self.free_data = allocate_buffer
+ */
+ __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order);
+
+ /* "View.MemoryView":176
+ * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order)
+ *
+ * self.free_data = allocate_buffer # <<<<<<<<<<<<<<
+ * self.dtype_is_object = format == b'O'
+ *
+ */
+ __pyx_v_self->free_data = __pyx_v_allocate_buffer;
+
+ /* "View.MemoryView":177
+ *
+ * self.free_data = allocate_buffer
+ * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<<
+ *
+ * if allocate_buffer:
+ */
+ __pyx_t_6 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 177, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 177, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_v_self->dtype_is_object = __pyx_t_3;
+
+ /* "View.MemoryView":179
+ * self.dtype_is_object = format == b'O'
+ *
+ * if allocate_buffer: # <<<<<<<<<<<<<<
+ * _allocate_buffer(self)
+ *
+ */
+ if (__pyx_v_allocate_buffer) {
+
+ /* "View.MemoryView":180
+ *
+ * if allocate_buffer:
+ * _allocate_buffer(self) # <<<<<<<<<<<<<<
+ *
+ * @cname('getbuffer')
+ */
+ __pyx_t_7 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 180, __pyx_L1_error)
+
+ /* "View.MemoryView":179
+ * self.dtype_is_object = format == b'O'
+ *
+ * if allocate_buffer: # <<<<<<<<<<<<<<
+ * _allocate_buffer(self)
+ *
+ */
+ }
+
+ /* "View.MemoryView":131
+ * cdef bint dtype_is_object
+ *
+ * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
+ * mode="c", bint allocate_buffer=True):
+ *
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_format);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":182
+ * _allocate_buffer(self)
+ *
+ * @cname('getbuffer') # <<<<<<<<<<<<<<
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * cdef int bufmode = -1
+ */
+
+/* Python wrapper */
+CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+ __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+ int __pyx_v_bufmode;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ char *__pyx_t_2;
+ Py_ssize_t __pyx_t_3;
+ int __pyx_t_4;
+ Py_ssize_t *__pyx_t_5;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ if (unlikely(__pyx_v_info == NULL)) {
+ PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
+ return -1;
+ }
+ __Pyx_RefNannySetupContext("__getbuffer__", 0);
+ __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+ __Pyx_GIVEREF(__pyx_v_info->obj);
+
+ /* "View.MemoryView":184
+ * @cname('getbuffer')
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * cdef int bufmode = -1 # <<<<<<<<<<<<<<
+ * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
+ * if self.mode == u"c":
+ */
+ __pyx_v_bufmode = -1;
+
+ /* "View.MemoryView":185
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * cdef int bufmode = -1
+ * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<<
+ * if self.mode == u"c":
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ */
+ __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":186
+ * cdef int bufmode = -1
+ * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
+ * if self.mode == u"c": # <<<<<<<<<<<<<<
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * elif self.mode == u"fortran":
+ */
+ __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 186, __pyx_L1_error)
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":187
+ * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
+ * if self.mode == u"c":
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<<
+ * elif self.mode == u"fortran":
+ * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ */
+ __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
+
+ /* "View.MemoryView":186
+ * cdef int bufmode = -1
+ * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
+ * if self.mode == u"c": # <<<<<<<<<<<<<<
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * elif self.mode == u"fortran":
+ */
+ goto __pyx_L4;
+ }
+
+ /* "View.MemoryView":188
+ * if self.mode == u"c":
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * elif self.mode == u"fortran": # <<<<<<<<<<<<<<
+ * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * if not (flags & bufmode):
+ */
+ __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 188, __pyx_L1_error)
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":189
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * elif self.mode == u"fortran":
+ * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<<
+ * if not (flags & bufmode):
+ * raise ValueError, "Can only create a buffer that is contiguous in memory."
+ */
+ __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
+
+ /* "View.MemoryView":188
+ * if self.mode == u"c":
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * elif self.mode == u"fortran": # <<<<<<<<<<<<<<
+ * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * if not (flags & bufmode):
+ */
+ }
+ __pyx_L4:;
+
+ /* "View.MemoryView":190
+ * elif self.mode == u"fortran":
+ * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * if not (flags & bufmode): # <<<<<<<<<<<<<<
+ * raise ValueError, "Can only create a buffer that is contiguous in memory."
+ * info.buf = self.data
+ */
+ __pyx_t_1 = (!((__pyx_v_flags & __pyx_v_bufmode) != 0));
+ if (unlikely(__pyx_t_1)) {
+
+ /* "View.MemoryView":191
+ * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * if not (flags & bufmode):
+ * raise ValueError, "Can only create a buffer that is contiguous in memory." # <<<<<<<<<<<<<<
+ * info.buf = self.data
+ * info.len = self.len
+ */
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Can_only_create_a_buffer_that_is, 0, 0);
+ __PYX_ERR(1, 191, __pyx_L1_error)
+
+ /* "View.MemoryView":190
+ * elif self.mode == u"fortran":
+ * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ * if not (flags & bufmode): # <<<<<<<<<<<<<<
+ * raise ValueError, "Can only create a buffer that is contiguous in memory."
+ * info.buf = self.data
+ */
+ }
+
+ /* "View.MemoryView":185
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * cdef int bufmode = -1
+ * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<<
+ * if self.mode == u"c":
+ * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ */
+ }
+
+ /* "View.MemoryView":192
+ * if not (flags & bufmode):
+ * raise ValueError, "Can only create a buffer that is contiguous in memory."
+ * info.buf = self.data # <<<<<<<<<<<<<<
+ * info.len = self.len
+ *
+ */
+ __pyx_t_2 = __pyx_v_self->data;
+ __pyx_v_info->buf = __pyx_t_2;
+
+ /* "View.MemoryView":193
+ * raise ValueError, "Can only create a buffer that is contiguous in memory."
+ * info.buf = self.data
+ * info.len = self.len # <<<<<<<<<<<<<<
+ *
+ * if flags & PyBUF_STRIDES:
+ */
+ __pyx_t_3 = __pyx_v_self->len;
+ __pyx_v_info->len = __pyx_t_3;
+
+ /* "View.MemoryView":195
+ * info.len = self.len
+ *
+ * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
+ * info.ndim = self.ndim
+ * info.shape = self._shape
+ */
+ __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":196
+ *
+ * if flags & PyBUF_STRIDES:
+ * info.ndim = self.ndim # <<<<<<<<<<<<<<
+ * info.shape = self._shape
+ * info.strides = self._strides
+ */
+ __pyx_t_4 = __pyx_v_self->ndim;
+ __pyx_v_info->ndim = __pyx_t_4;
+
+ /* "View.MemoryView":197
+ * if flags & PyBUF_STRIDES:
+ * info.ndim = self.ndim
+ * info.shape = self._shape # <<<<<<<<<<<<<<
+ * info.strides = self._strides
+ * else:
+ */
+ __pyx_t_5 = __pyx_v_self->_shape;
+ __pyx_v_info->shape = __pyx_t_5;
+
+ /* "View.MemoryView":198
+ * info.ndim = self.ndim
+ * info.shape = self._shape
+ * info.strides = self._strides # <<<<<<<<<<<<<<
+ * else:
+ * info.ndim = 1
+ */
+ __pyx_t_5 = __pyx_v_self->_strides;
+ __pyx_v_info->strides = __pyx_t_5;
+
+ /* "View.MemoryView":195
+ * info.len = self.len
+ *
+ * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
+ * info.ndim = self.ndim
+ * info.shape = self._shape
+ */
+ goto __pyx_L6;
+ }
+
+ /* "View.MemoryView":200
+ * info.strides = self._strides
+ * else:
+ * info.ndim = 1 # <<<<<<<<<<<<<<
+ * info.shape = &self.len if flags & PyBUF_ND else NULL
+ * info.strides = NULL
+ */
+ /*else*/ {
+ __pyx_v_info->ndim = 1;
+
+ /* "View.MemoryView":201
+ * else:
+ * info.ndim = 1
+ * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<<
+ * info.strides = NULL
+ *
+ */
+ if (((__pyx_v_flags & PyBUF_ND) != 0)) {
+ __pyx_t_5 = (&__pyx_v_self->len);
+ } else {
+ __pyx_t_5 = NULL;
+ }
+ __pyx_v_info->shape = __pyx_t_5;
+
+ /* "View.MemoryView":202
+ * info.ndim = 1
+ * info.shape = &self.len if flags & PyBUF_ND else NULL
+ * info.strides = NULL # <<<<<<<<<<<<<<
+ *
+ * info.suboffsets = NULL
+ */
+ __pyx_v_info->strides = NULL;
+ }
+ __pyx_L6:;
+
+ /* "View.MemoryView":204
+ * info.strides = NULL
+ *
+ * info.suboffsets = NULL # <<<<<<<<<<<<<<
+ * info.itemsize = self.itemsize
+ * info.readonly = 0
+ */
+ __pyx_v_info->suboffsets = NULL;
+
+ /* "View.MemoryView":205
+ *
+ * info.suboffsets = NULL
+ * info.itemsize = self.itemsize # <<<<<<<<<<<<<<
+ * info.readonly = 0
+ * info.format = self.format if flags & PyBUF_FORMAT else NULL
+ */
+ __pyx_t_3 = __pyx_v_self->itemsize;
+ __pyx_v_info->itemsize = __pyx_t_3;
+
+ /* "View.MemoryView":206
+ * info.suboffsets = NULL
+ * info.itemsize = self.itemsize
+ * info.readonly = 0 # <<<<<<<<<<<<<<
+ * info.format = self.format if flags & PyBUF_FORMAT else NULL
+ * info.obj = self
+ */
+ __pyx_v_info->readonly = 0;
+
+ /* "View.MemoryView":207
+ * info.itemsize = self.itemsize
+ * info.readonly = 0
+ * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<<
+ * info.obj = self
+ *
+ */
+ if (((__pyx_v_flags & PyBUF_FORMAT) != 0)) {
+ __pyx_t_2 = __pyx_v_self->format;
+ } else {
+ __pyx_t_2 = NULL;
+ }
+ __pyx_v_info->format = __pyx_t_2;
+
+ /* "View.MemoryView":208
+ * info.readonly = 0
+ * info.format = self.format if flags & PyBUF_FORMAT else NULL
+ * info.obj = self # <<<<<<<<<<<<<<
+ *
+ * def __dealloc__(array self):
+ */
+ __Pyx_INCREF((PyObject *)__pyx_v_self);
+ __Pyx_GIVEREF((PyObject *)__pyx_v_self);
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj);
+ __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+
+ /* "View.MemoryView":182
+ * _allocate_buffer(self)
+ *
+ * @cname('getbuffer') # <<<<<<<<<<<<<<
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * cdef int bufmode = -1
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ if (__pyx_v_info->obj != NULL) {
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+ }
+ goto __pyx_L2;
+ __pyx_L0:;
+ if (__pyx_v_info->obj == Py_None) {
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+ }
+ __pyx_L2:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":210
+ * info.obj = self
+ *
+ * def __dealloc__(array self): # <<<<<<<<<<<<<<
+ * if self.callback_free_data != NULL:
+ * self.callback_free_data(self.data)
+ */
+
+/* Python wrapper */
+static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_array___dealloc__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+ __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+ /* "View.MemoryView":211
+ *
+ * def __dealloc__(array self):
+ * if self.callback_free_data != NULL: # <<<<<<<<<<<<<<
+ * self.callback_free_data(self.data)
+ * elif self.free_data and self.data is not NULL:
+ */
+ __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":212
+ * def __dealloc__(array self):
+ * if self.callback_free_data != NULL:
+ * self.callback_free_data(self.data) # <<<<<<<<<<<<<<
+ * elif self.free_data and self.data is not NULL:
+ * if self.dtype_is_object:
+ */
+ __pyx_v_self->callback_free_data(__pyx_v_self->data);
+
+ /* "View.MemoryView":211
+ *
+ * def __dealloc__(array self):
+ * if self.callback_free_data != NULL: # <<<<<<<<<<<<<<
+ * self.callback_free_data(self.data)
+ * elif self.free_data and self.data is not NULL:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":213
+ * if self.callback_free_data != NULL:
+ * self.callback_free_data(self.data)
+ * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<<
+ * if self.dtype_is_object:
+ * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
+ */
+ if (__pyx_v_self->free_data) {
+ } else {
+ __pyx_t_1 = __pyx_v_self->free_data;
+ goto __pyx_L4_bool_binop_done;
+ }
+ __pyx_t_2 = (__pyx_v_self->data != NULL);
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L4_bool_binop_done:;
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":214
+ * self.callback_free_data(self.data)
+ * elif self.free_data and self.data is not NULL:
+ * if self.dtype_is_object: # <<<<<<<<<<<<<<
+ * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
+ * free(self.data)
+ */
+ if (__pyx_v_self->dtype_is_object) {
+
+ /* "View.MemoryView":215
+ * elif self.free_data and self.data is not NULL:
+ * if self.dtype_is_object:
+ * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<<
+ * free(self.data)
+ * PyObject_Free(self._shape)
+ */
+ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0);
+
+ /* "View.MemoryView":214
+ * self.callback_free_data(self.data)
+ * elif self.free_data and self.data is not NULL:
+ * if self.dtype_is_object: # <<<<<<<<<<<<<<
+ * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
+ * free(self.data)
+ */
+ }
+
+ /* "View.MemoryView":216
+ * if self.dtype_is_object:
+ * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
+ * free(self.data) # <<<<<<<<<<<<<<
+ * PyObject_Free(self._shape)
+ *
+ */
+ free(__pyx_v_self->data);
+
+ /* "View.MemoryView":213
+ * if self.callback_free_data != NULL:
+ * self.callback_free_data(self.data)
+ * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<<
+ * if self.dtype_is_object:
+ * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
+ */
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":217
+ * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
+ * free(self.data)
+ * PyObject_Free(self._shape) # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ PyObject_Free(__pyx_v_self->_shape);
+
+ /* "View.MemoryView":210
+ * info.obj = self
+ *
+ * def __dealloc__(array self): # <<<<<<<<<<<<<<
+ * if self.callback_free_data != NULL:
+ * self.callback_free_data(self.data)
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":219
+ * PyObject_Free(self._shape)
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def memview(self):
+ * return self.get_memview()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":221
+ * @property
+ * def memview(self):
+ * return self.get_memview() # <<<<<<<<<<<<<<
+ *
+ * @cname('get_memview')
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 221, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":219
+ * PyObject_Free(self._shape)
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def memview(self):
+ * return self.get_memview()
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":224
+ *
+ * @cname('get_memview')
+ * cdef get_memview(self): # <<<<<<<<<<<<<<
+ * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
+ * return memoryview(self, flags, self.dtype_is_object)
+ */
+
+static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) {
+ int __pyx_v_flags;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("get_memview", 0);
+
+ /* "View.MemoryView":225
+ * @cname('get_memview')
+ * cdef get_memview(self):
+ * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<<
+ * return memoryview(self, flags, self.dtype_is_object)
+ *
+ */
+ __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE);
+
+ /* "View.MemoryView":226
+ * cdef get_memview(self):
+ * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
+ * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<<
+ *
+ * def __len__(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 226, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF((PyObject *)__pyx_v_self);
+ __Pyx_GIVEREF((PyObject *)__pyx_v_self);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+ __pyx_t_1 = 0;
+ __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":224
+ *
+ * @cname('get_memview')
+ * cdef get_memview(self): # <<<<<<<<<<<<<<
+ * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
+ * return memoryview(self, flags, self.dtype_is_object)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":228
+ * return memoryview(self, flags, self.dtype_is_object)
+ *
+ * def __len__(self): # <<<<<<<<<<<<<<
+ * return self._shape[0]
+ *
+ */
+
+/* Python wrapper */
+static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/
+static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ Py_ssize_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
+ __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) {
+ Py_ssize_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__len__", 0);
+
+ /* "View.MemoryView":229
+ *
+ * def __len__(self):
+ * return self._shape[0] # <<<<<<<<<<<<<<
+ *
+ * def __getattr__(self, attr):
+ */
+ __pyx_r = (__pyx_v_self->_shape[0]);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":228
+ * return memoryview(self, flags, self.dtype_is_object)
+ *
+ * def __len__(self): # <<<<<<<<<<<<<<
+ * return self._shape[0]
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":231
+ * return self._shape[0]
+ *
+ * def __getattr__(self, attr): # <<<<<<<<<<<<<<
+ * return getattr(self.memview, attr)
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/
+static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0);
+ __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__getattr__", 0);
+
+ /* "View.MemoryView":232
+ *
+ * def __getattr__(self, attr):
+ * return getattr(self.memview, attr) # <<<<<<<<<<<<<<
+ *
+ * def __getitem__(self, item):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 232, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":231
+ * return self._shape[0]
+ *
+ * def __getattr__(self, attr): # <<<<<<<<<<<<<<
+ * return getattr(self.memview, attr)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":234
+ * return getattr(self.memview, attr)
+ *
+ * def __getitem__(self, item): # <<<<<<<<<<<<<<
+ * return self.memview[item]
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/
+static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+ __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__getitem__", 0);
+
+ /* "View.MemoryView":235
+ *
+ * def __getitem__(self, item):
+ * return self.memview[item] # <<<<<<<<<<<<<<
+ *
+ * def __setitem__(self, item, value):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":234
+ * return getattr(self.memview, attr)
+ *
+ * def __getitem__(self, item): # <<<<<<<<<<<<<<
+ * return self.memview[item]
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":237
+ * return self.memview[item]
+ *
+ * def __setitem__(self, item, value): # <<<<<<<<<<<<<<
+ * self.memview[item] = value
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/
+static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
+ __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__setitem__", 0);
+
+ /* "View.MemoryView":238
+ *
+ * def __setitem__(self, item, value):
+ * self.memview[item] = value # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0))) __PYX_ERR(1, 238, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "View.MemoryView":237
+ * return self.memview[item]
+ *
+ * def __setitem__(self, item, value): # <<<<<<<<<<<<<<
+ * self.memview[item] = value
+ *
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
+ __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+ /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+ __PYX_ERR(1, 2, __pyx_L1_error)
+
+ /* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+ {
+ PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+ PyObject* values[1] = {0};
+ if (__pyx_kwds) {
+ Py_ssize_t kw_args;
+ switch (__pyx_nargs) {
+ case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+ switch (__pyx_nargs) {
+ case 0:
+ if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ const Py_ssize_t kwd_pos_args = __pyx_nargs;
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+ }
+ } else if (unlikely(__pyx_nargs != 1)) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ }
+ __pyx_v___pyx_state = values[0];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+ /* "(tree fragment)":4
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
+ */
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+ __PYX_ERR(1, 4, __pyx_L1_error)
+
+ /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":248
+ *
+ * @cname("__pyx_array_allocate_buffer")
+ * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<<
+ *
+ *
+ */
+
+static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) {
+ Py_ssize_t __pyx_v_i;
+ PyObject **__pyx_v_p;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ Py_ssize_t __pyx_t_2;
+ Py_ssize_t __pyx_t_3;
+ Py_ssize_t __pyx_t_4;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("_allocate_buffer", 0);
+
+ /* "View.MemoryView":254
+ * cdef PyObject **p
+ *
+ * self.free_data = True # <<<<<<<<<<<<<<
+ * self.data = malloc(self.len)
+ * if not self.data:
+ */
+ __pyx_v_self->free_data = 1;
+
+ /* "View.MemoryView":255
+ *
+ * self.free_data = True
+ * self.data = malloc(self.len) # <<<<<<<<<<<<<<
+ * if not self.data:
+ * raise MemoryError, "unable to allocate array data."
+ */
+ __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len));
+
+ /* "View.MemoryView":256
+ * self.free_data = True
+ * self.data = malloc(self.len)
+ * if not self.data: # <<<<<<<<<<<<<<
+ * raise MemoryError, "unable to allocate array data."
+ *
+ */
+ __pyx_t_1 = (!(__pyx_v_self->data != 0));
+ if (unlikely(__pyx_t_1)) {
+
+ /* "View.MemoryView":257
+ * self.data = malloc(self.len)
+ * if not self.data:
+ * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<<
+ *
+ * if self.dtype_is_object:
+ */
+ __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_array_data, 0, 0);
+ __PYX_ERR(1, 257, __pyx_L1_error)
+
+ /* "View.MemoryView":256
+ * self.free_data = True
+ * self.data = malloc(self.len)
+ * if not self.data: # <<<<<<<<<<<<<<
+ * raise MemoryError, "unable to allocate array data."
+ *
+ */
+ }
+
+ /* "View.MemoryView":259
+ * raise MemoryError, "unable to allocate array data."
+ *
+ * if self.dtype_is_object: # <<<<<<<<<<<<<<
+ * p = self.data
+ * for i in range(self.len // self.itemsize):
+ */
+ if (__pyx_v_self->dtype_is_object) {
+
+ /* "View.MemoryView":260
+ *
+ * if self.dtype_is_object:
+ * p = self.data # <<<<<<<<<<<<<<
+ * for i in range(self.len // self.itemsize):
+ * p[i] = Py_None
+ */
+ __pyx_v_p = ((PyObject **)__pyx_v_self->data);
+
+ /* "View.MemoryView":261
+ * if self.dtype_is_object:
+ * p = self.data
+ * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<<
+ * p[i] = Py_None
+ * Py_INCREF(Py_None)
+ */
+ if (unlikely(__pyx_v_self->itemsize == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
+ __PYX_ERR(1, 261, __pyx_L1_error)
+ }
+ else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) {
+ PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
+ __PYX_ERR(1, 261, __pyx_L1_error)
+ }
+ __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize);
+ __pyx_t_3 = __pyx_t_2;
+ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+ __pyx_v_i = __pyx_t_4;
+
+ /* "View.MemoryView":262
+ * p = self.data
+ * for i in range(self.len // self.itemsize):
+ * p[i] = Py_None # <<<<<<<<<<<<<<
+ * Py_INCREF(Py_None)
+ * return 0
+ */
+ (__pyx_v_p[__pyx_v_i]) = Py_None;
+
+ /* "View.MemoryView":263
+ * for i in range(self.len // self.itemsize):
+ * p[i] = Py_None
+ * Py_INCREF(Py_None) # <<<<<<<<<<<<<<
+ * return 0
+ *
+ */
+ Py_INCREF(Py_None);
+ }
+
+ /* "View.MemoryView":259
+ * raise MemoryError, "unable to allocate array data."
+ *
+ * if self.dtype_is_object: # <<<<<<<<<<<<<<
+ * p = self.data
+ * for i in range(self.len // self.itemsize):
+ */
+ }
+
+ /* "View.MemoryView":264
+ * p[i] = Py_None
+ * Py_INCREF(Py_None)
+ * return 0 # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":248
+ *
+ * @cname("__pyx_array_allocate_buffer")
+ * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<<
+ *
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":268
+ *
+ * @cname("__pyx_array_new")
+ * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<<
+ * cdef array result
+ * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
+ */
+
+static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_c_mode, char *__pyx_v_buf) {
+ struct __pyx_array_obj *__pyx_v_result = 0;
+ PyObject *__pyx_v_mode = 0;
+ struct __pyx_array_obj *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("array_cwrapper", 0);
+
+ /* "View.MemoryView":270
+ * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf):
+ * cdef array result
+ * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<<
+ *
+ * if buf is NULL:
+ */
+ if (((__pyx_v_c_mode[0]) == 'f')) {
+ __Pyx_INCREF(__pyx_n_s_fortran);
+ __pyx_t_1 = __pyx_n_s_fortran;
+ } else {
+ __Pyx_INCREF(__pyx_n_s_c);
+ __pyx_t_1 = __pyx_n_s_c;
+ }
+ __pyx_v_mode = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":272
+ * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
+ *
+ * if buf is NULL: # <<<<<<<<<<<<<<
+ * result = array.__new__(array, shape, itemsize, format, mode)
+ * else:
+ */
+ __pyx_t_2 = (__pyx_v_buf == NULL);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":273
+ *
+ * if buf is NULL:
+ * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<<
+ * else:
+ * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False)
+ */
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(__pyx_v_shape);
+ __Pyx_GIVEREF(__pyx_v_shape);
+ PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
+ __Pyx_INCREF(__pyx_v_mode);
+ __Pyx_GIVEREF(__pyx_v_mode);
+ PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode);
+ __pyx_t_1 = 0;
+ __pyx_t_3 = 0;
+ __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error)
+ __Pyx_GOTREF((PyObject *)__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "View.MemoryView":272
+ * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
+ *
+ * if buf is NULL: # <<<<<<<<<<<<<<
+ * result = array.__new__(array, shape, itemsize, format, mode)
+ * else:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":275
+ * result = array.__new__(array, shape, itemsize, format, mode)
+ * else:
+ * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<<
+ * result.data = buf
+ *
+ */
+ /*else*/ {
+ __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(__pyx_v_shape);
+ __Pyx_GIVEREF(__pyx_v_shape);
+ PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4);
+ __Pyx_INCREF(__pyx_v_mode);
+ __Pyx_GIVEREF(__pyx_v_mode);
+ PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode);
+ __pyx_t_3 = 0;
+ __pyx_t_4 = 0;
+ __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 275, __pyx_L1_error)
+ __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error)
+ __Pyx_GOTREF((PyObject *)__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "View.MemoryView":276
+ * else:
+ * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False)
+ * result.data = buf # <<<<<<<<<<<<<<
+ *
+ * return result
+ */
+ __pyx_v_result->data = __pyx_v_buf;
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":278
+ * result.data = buf
+ *
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF((PyObject *)__pyx_r);
+ __Pyx_INCREF((PyObject *)__pyx_v_result);
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":268
+ *
+ * @cname("__pyx_array_new")
+ * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<<
+ * cdef array result
+ * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XDECREF(__pyx_v_mode);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":304
+ * cdef class Enum(object):
+ * cdef object name
+ * def __init__(self, name): # <<<<<<<<<<<<<<
+ * self.name = name
+ * def __repr__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_name = 0;
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0};
+ PyObject* values[1] = {0};
+ if (__pyx_kwds) {
+ Py_ssize_t kw_args;
+ switch (__pyx_nargs) {
+ case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+ switch (__pyx_nargs) {
+ case 0:
+ if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L3_error)
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ const Py_ssize_t kwd_pos_args = __pyx_nargs;
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 304, __pyx_L3_error)
+ }
+ } else if (unlikely(__pyx_nargs != 1)) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+ }
+ __pyx_v_name = values[0];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 304, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "View.MemoryView":305
+ * cdef object name
+ * def __init__(self, name):
+ * self.name = name # <<<<<<<<<<<<<<
+ * def __repr__(self):
+ * return self.name
+ */
+ __Pyx_INCREF(__pyx_v_name);
+ __Pyx_GIVEREF(__pyx_v_name);
+ __Pyx_GOTREF(__pyx_v_self->name);
+ __Pyx_DECREF(__pyx_v_self->name);
+ __pyx_v_self->name = __pyx_v_name;
+
+ /* "View.MemoryView":304
+ * cdef class Enum(object):
+ * cdef object name
+ * def __init__(self, name): # <<<<<<<<<<<<<<
+ * self.name = name
+ * def __repr__(self):
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":306
+ * def __init__(self, name):
+ * self.name = name
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return self.name
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "View.MemoryView":307
+ * self.name = name
+ * def __repr__(self):
+ * return self.name # <<<<<<<<<<<<<<
+ *
+ * cdef generic = Enum("")
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_self->name);
+ __pyx_r = __pyx_v_self->name;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":306
+ * def __init__(self, name):
+ * self.name = name
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return self.name
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * cdef tuple state
+ * cdef object _dict
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
+ __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
+ PyObject *__pyx_v_state = 0;
+ PyObject *__pyx_v__dict = 0;
+ int __pyx_v_use_setstate;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+ /* "(tree fragment)":5
+ * cdef object _dict
+ * cdef bint use_setstate
+ * state = (self.name,) # <<<<<<<<<<<<<<
+ * _dict = getattr(self, '__dict__', None)
+ * if _dict is not None:
+ */
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(__pyx_v_self->name);
+ __Pyx_GIVEREF(__pyx_v_self->name);
+ PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name);
+ __pyx_v_state = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "(tree fragment)":6
+ * cdef bint use_setstate
+ * state = (self.name,)
+ * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
+ * if _dict is not None:
+ * state += (_dict,)
+ */
+ __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v__dict = __pyx_t_1;
+ __pyx_t_1 = 0;
+
+ /* "(tree fragment)":7
+ * state = (self.name,)
+ * _dict = getattr(self, '__dict__', None)
+ * if _dict is not None: # <<<<<<<<<<<<<<
+ * state += (_dict,)
+ * use_setstate = True
+ */
+ __pyx_t_2 = (__pyx_v__dict != Py_None);
+ if (__pyx_t_2) {
+
+ /* "(tree fragment)":8
+ * _dict = getattr(self, '__dict__', None)
+ * if _dict is not None:
+ * state += (_dict,) # <<<<<<<<<<<<<<
+ * use_setstate = True
+ * else:
+ */
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(__pyx_v__dict);
+ __Pyx_GIVEREF(__pyx_v__dict);
+ PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
+ __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3));
+ __pyx_t_3 = 0;
+
+ /* "(tree fragment)":9
+ * if _dict is not None:
+ * state += (_dict,)
+ * use_setstate = True # <<<<<<<<<<<<<<
+ * else:
+ * use_setstate = self.name is not None
+ */
+ __pyx_v_use_setstate = 1;
+
+ /* "(tree fragment)":7
+ * state = (self.name,)
+ * _dict = getattr(self, '__dict__', None)
+ * if _dict is not None: # <<<<<<<<<<<<<<
+ * state += (_dict,)
+ * use_setstate = True
+ */
+ goto __pyx_L3;
+ }
+
+ /* "(tree fragment)":11
+ * use_setstate = True
+ * else:
+ * use_setstate = self.name is not None # <<<<<<<<<<<<<<
+ * if use_setstate:
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
+ */
+ /*else*/ {
+ __pyx_t_2 = (__pyx_v_self->name != Py_None);
+ __pyx_v_use_setstate = __pyx_t_2;
+ }
+ __pyx_L3:;
+
+ /* "(tree fragment)":12
+ * else:
+ * use_setstate = self.name is not None
+ * if use_setstate: # <<<<<<<<<<<<<<
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
+ * else:
+ */
+ if (__pyx_v_use_setstate) {
+
+ /* "(tree fragment)":13
+ * use_setstate = self.name is not None
+ * if use_setstate:
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<<
+ * else:
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+ __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+ PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+ __Pyx_INCREF(__pyx_int_136983863);
+ __Pyx_GIVEREF(__pyx_int_136983863);
+ PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863);
+ __Pyx_INCREF(Py_None);
+ __Pyx_GIVEREF(Py_None);
+ PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
+ __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
+ __Pyx_INCREF(__pyx_v_state);
+ __Pyx_GIVEREF(__pyx_v_state);
+ PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = 0;
+ __pyx_r = __pyx_t_4;
+ __pyx_t_4 = 0;
+ goto __pyx_L0;
+
+ /* "(tree fragment)":12
+ * else:
+ * use_setstate = self.name is not None
+ * if use_setstate: # <<<<<<<<<<<<<<
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
+ * else:
+ */
+ }
+
+ /* "(tree fragment)":15
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
+ * else:
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ * __pyx_unpickle_Enum__set_state(self, __pyx_state)
+ */
+ /*else*/ {
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+ __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+ PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+ __Pyx_INCREF(__pyx_int_136983863);
+ __Pyx_GIVEREF(__pyx_int_136983863);
+ PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863);
+ __Pyx_INCREF(__pyx_v_state);
+ __Pyx_GIVEREF(__pyx_v_state);
+ PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
+ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = 0;
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+ }
+
+ /* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * cdef tuple state
+ * cdef object _dict
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_state);
+ __Pyx_XDECREF(__pyx_v__dict);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":16
+ * else:
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * __pyx_unpickle_Enum__set_state(self, __pyx_state)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ PyObject *__pyx_v___pyx_state = 0;
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+ {
+ PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+ PyObject* values[1] = {0};
+ if (__pyx_kwds) {
+ Py_ssize_t kw_args;
+ switch (__pyx_nargs) {
+ case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+ switch (__pyx_nargs) {
+ case 0:
+ if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error)
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ const Py_ssize_t kwd_pos_args = __pyx_nargs;
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error)
+ }
+ } else if (unlikely(__pyx_nargs != 1)) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ }
+ __pyx_v___pyx_state = values[0];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+ /* "(tree fragment)":17
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
+ * def __setstate_cython__(self, __pyx_state):
+ * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
+ */
+ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error)
+ __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "(tree fragment)":16
+ * else:
+ * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * __pyx_unpickle_Enum__set_state(self, __pyx_state)
+ */
+
+ /* function exit code */
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":349
+ * cdef __Pyx_TypeInfo *typeinfo
+ *
+ * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<<
+ * self.obj = obj
+ * self.flags = flags
+ */
+
+/* Python wrapper */
+static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_obj = 0;
+ int __pyx_v_flags;
+ int __pyx_v_dtype_is_object;
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+ {
+ PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0};
+ PyObject* values[3] = {0,0,0};
+ if (__pyx_kwds) {
+ Py_ssize_t kw_args;
+ switch (__pyx_nargs) {
+ case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+ switch (__pyx_nargs) {
+ case 0:
+ if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
+ else goto __pyx_L5_argtuple_error;
+ CYTHON_FALLTHROUGH;
+ case 1:
+ if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
+ else {
+ __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 349, __pyx_L3_error)
+ }
+ CYTHON_FALLTHROUGH;
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dtype_is_object);
+ if (value) { values[2] = value; kw_args--; }
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ const Py_ssize_t kwd_pos_args = __pyx_nargs;
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 349, __pyx_L3_error)
+ }
+ } else {
+ switch (__pyx_nargs) {
+ case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
+ values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_obj = values[0];
+ __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
+ if (values[2]) {
+ __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
+ } else {
+ __pyx_v_dtype_is_object = ((int)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 349, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ Py_intptr_t __pyx_t_4;
+ size_t __pyx_t_5;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__cinit__", 0);
+
+ /* "View.MemoryView":350
+ *
+ * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
+ * self.obj = obj # <<<<<<<<<<<<<<
+ * self.flags = flags
+ * if type(self) is memoryview or obj is not None:
+ */
+ __Pyx_INCREF(__pyx_v_obj);
+ __Pyx_GIVEREF(__pyx_v_obj);
+ __Pyx_GOTREF(__pyx_v_self->obj);
+ __Pyx_DECREF(__pyx_v_self->obj);
+ __pyx_v_self->obj = __pyx_v_obj;
+
+ /* "View.MemoryView":351
+ * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
+ * self.obj = obj
+ * self.flags = flags # <<<<<<<<<<<<<<
+ * if type(self) is memoryview or obj is not None:
+ * __Pyx_GetBuffer(obj, &self.view, flags)
+ */
+ __pyx_v_self->flags = __pyx_v_flags;
+
+ /* "View.MemoryView":352
+ * self.obj = obj
+ * self.flags = flags
+ * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<<
+ * __Pyx_GetBuffer(obj, &self.view, flags)
+ * if self.view.obj == NULL:
+ */
+ __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type));
+ if (!__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L4_bool_binop_done;
+ }
+ __pyx_t_2 = (__pyx_v_obj != Py_None);
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L4_bool_binop_done:;
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":353
+ * self.flags = flags
+ * if type(self) is memoryview or obj is not None:
+ * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<<
+ * if self.view.obj == NULL:
+ * (<__pyx_buffer *> &self.view).obj = Py_None
+ */
+ __pyx_t_3 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 353, __pyx_L1_error)
+
+ /* "View.MemoryView":354
+ * if type(self) is memoryview or obj is not None:
+ * __Pyx_GetBuffer(obj, &self.view, flags)
+ * if self.view.obj == NULL: # <<<<<<<<<<<<<<
+ * (<__pyx_buffer *> &self.view).obj = Py_None
+ * Py_INCREF(Py_None)
+ */
+ __pyx_t_1 = (((PyObject *)__pyx_v_self->view.obj) == NULL);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":355
+ * __Pyx_GetBuffer(obj, &self.view, flags)
+ * if self.view.obj == NULL:
+ * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<<
+ * Py_INCREF(Py_None)
+ *
+ */
+ ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None;
+
+ /* "View.MemoryView":356
+ * if self.view.obj == NULL:
+ * (<__pyx_buffer *> &self.view).obj = Py_None
+ * Py_INCREF(Py_None) # <<<<<<<<<<<<<<
+ *
+ * if not __PYX_CYTHON_ATOMICS_ENABLED():
+ */
+ Py_INCREF(Py_None);
+
+ /* "View.MemoryView":354
+ * if type(self) is memoryview or obj is not None:
+ * __Pyx_GetBuffer(obj, &self.view, flags)
+ * if self.view.obj == NULL: # <<<<<<<<<<<<<<
+ * (<__pyx_buffer *> &self.view).obj = Py_None
+ * Py_INCREF(Py_None)
+ */
+ }
+
+ /* "View.MemoryView":352
+ * self.obj = obj
+ * self.flags = flags
+ * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<<
+ * __Pyx_GetBuffer(obj, &self.view, flags)
+ * if self.view.obj == NULL:
+ */
+ }
+
+ /* "View.MemoryView":358
+ * Py_INCREF(Py_None)
+ *
+ * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<<
+ * global __pyx_memoryview_thread_locks_used
+ * if __pyx_memoryview_thread_locks_used < 8:
+ */
+ __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED());
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":360
+ * if not __PYX_CYTHON_ATOMICS_ENABLED():
+ * global __pyx_memoryview_thread_locks_used
+ * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<<
+ * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ * __pyx_memoryview_thread_locks_used += 1
+ */
+ __pyx_t_1 = (__pyx_memoryview_thread_locks_used < 8);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":361
+ * global __pyx_memoryview_thread_locks_used
+ * if __pyx_memoryview_thread_locks_used < 8:
+ * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<<
+ * __pyx_memoryview_thread_locks_used += 1
+ * if self.lock is NULL:
+ */
+ __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
+
+ /* "View.MemoryView":362
+ * if __pyx_memoryview_thread_locks_used < 8:
+ * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<<
+ * if self.lock is NULL:
+ * self.lock = PyThread_allocate_lock()
+ */
+ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1);
+
+ /* "View.MemoryView":360
+ * if not __PYX_CYTHON_ATOMICS_ENABLED():
+ * global __pyx_memoryview_thread_locks_used
+ * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<<
+ * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ * __pyx_memoryview_thread_locks_used += 1
+ */
+ }
+
+ /* "View.MemoryView":363
+ * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ * __pyx_memoryview_thread_locks_used += 1
+ * if self.lock is NULL: # <<<<<<<<<<<<<<
+ * self.lock = PyThread_allocate_lock()
+ * if self.lock is NULL:
+ */
+ __pyx_t_1 = (__pyx_v_self->lock == NULL);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":364
+ * __pyx_memoryview_thread_locks_used += 1
+ * if self.lock is NULL:
+ * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<<
+ * if self.lock is NULL:
+ * raise MemoryError
+ */
+ __pyx_v_self->lock = PyThread_allocate_lock();
+
+ /* "View.MemoryView":365
+ * if self.lock is NULL:
+ * self.lock = PyThread_allocate_lock()
+ * if self.lock is NULL: # <<<<<<<<<<<<<<
+ * raise MemoryError
+ *
+ */
+ __pyx_t_1 = (__pyx_v_self->lock == NULL);
+ if (unlikely(__pyx_t_1)) {
+
+ /* "View.MemoryView":366
+ * self.lock = PyThread_allocate_lock()
+ * if self.lock is NULL:
+ * raise MemoryError # <<<<<<<<<<<<<<
+ *
+ * if flags & PyBUF_FORMAT:
+ */
+ PyErr_NoMemory(); __PYX_ERR(1, 366, __pyx_L1_error)
+
+ /* "View.MemoryView":365
+ * if self.lock is NULL:
+ * self.lock = PyThread_allocate_lock()
+ * if self.lock is NULL: # <<<<<<<<<<<<<<
+ * raise MemoryError
+ *
+ */
+ }
+
+ /* "View.MemoryView":363
+ * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ * __pyx_memoryview_thread_locks_used += 1
+ * if self.lock is NULL: # <<<<<<<<<<<<<<
+ * self.lock = PyThread_allocate_lock()
+ * if self.lock is NULL:
+ */
+ }
+
+ /* "View.MemoryView":358
+ * Py_INCREF(Py_None)
+ *
+ * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<<
+ * global __pyx_memoryview_thread_locks_used
+ * if __pyx_memoryview_thread_locks_used < 8:
+ */
+ }
+
+ /* "View.MemoryView":368
+ * raise MemoryError
+ *
+ * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
+ * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
+ * else:
+ */
+ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":369
+ *
+ * if flags & PyBUF_FORMAT:
+ * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<<
+ * else:
+ * self.dtype_is_object = dtype_is_object
+ */
+ __pyx_t_2 = ((__pyx_v_self->view.format[0]) == 'O');
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L12_bool_binop_done;
+ }
+ __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00');
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L12_bool_binop_done:;
+ __pyx_v_self->dtype_is_object = __pyx_t_1;
+
+ /* "View.MemoryView":368
+ * raise MemoryError
+ *
+ * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
+ * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
+ * else:
+ */
+ goto __pyx_L11;
+ }
+
+ /* "View.MemoryView":371
+ * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
+ * else:
+ * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<<
+ *
+ * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0
+ */
+ /*else*/ {
+ __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object;
+ }
+ __pyx_L11:;
+
+ /* "View.MemoryView":373
+ * self.dtype_is_object = dtype_is_object
+ *
+ * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<<
+ * self.typeinfo = NULL
+ *
+ */
+ #ifndef CYTHON_WITHOUT_ASSERTIONS
+ if (unlikely(__pyx_assertions_enabled())) {
+ __pyx_t_4 = ((Py_intptr_t)((void *)(&__pyx_v_self->acquisition_count)));
+ __pyx_t_5 = (sizeof(__pyx_atomic_int_type));
+ if (unlikely(__pyx_t_5 == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
+ __PYX_ERR(1, 373, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((__pyx_t_4 % __pyx_t_5) == 0);
+ if (unlikely(!__pyx_t_1)) {
+ __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
+ __PYX_ERR(1, 373, __pyx_L1_error)
+ }
+ }
+ #else
+ if ((1)); else __PYX_ERR(1, 373, __pyx_L1_error)
+ #endif
+
+ /* "View.MemoryView":374
+ *
+ * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0
+ * self.typeinfo = NULL # <<<<<<<<<<<<<<
+ *
+ * def __dealloc__(memoryview self):
+ */
+ __pyx_v_self->typeinfo = NULL;
+
+ /* "View.MemoryView":349
+ * cdef __Pyx_TypeInfo *typeinfo
+ *
+ * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<<
+ * self.obj = obj
+ * self.flags = flags
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":376
+ * self.typeinfo = NULL
+ *
+ * def __dealloc__(memoryview self): # <<<<<<<<<<<<<<
+ * if self.obj is not None:
+ * __Pyx_ReleaseBuffer(&self.view)
+ */
+
+/* Python wrapper */
+static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+ __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ int __pyx_v_i;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ int __pyx_t_4;
+ PyThread_type_lock __pyx_t_5;
+ PyThread_type_lock __pyx_t_6;
+ __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+ /* "View.MemoryView":377
+ *
+ * def __dealloc__(memoryview self):
+ * if self.obj is not None: # <<<<<<<<<<<<<<
+ * __Pyx_ReleaseBuffer(&self.view)
+ * elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ */
+ __pyx_t_1 = (__pyx_v_self->obj != Py_None);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":378
+ * def __dealloc__(memoryview self):
+ * if self.obj is not None:
+ * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<<
+ * elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ *
+ */
+ __Pyx_ReleaseBuffer((&__pyx_v_self->view));
+
+ /* "View.MemoryView":377
+ *
+ * def __dealloc__(memoryview self):
+ * if self.obj is not None: # <<<<<<<<<<<<<<
+ * __Pyx_ReleaseBuffer(&self.view)
+ * elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":379
+ * if self.obj is not None:
+ * __Pyx_ReleaseBuffer(&self.view)
+ * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<<
+ *
+ * (<__pyx_buffer *> &self.view).obj = NULL
+ */
+ __pyx_t_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":381
+ * elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ *
+ * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<<
+ * Py_DECREF(Py_None)
+ *
+ */
+ ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL;
+
+ /* "View.MemoryView":382
+ *
+ * (<__pyx_buffer *> &self.view).obj = NULL
+ * Py_DECREF(Py_None) # <<<<<<<<<<<<<<
+ *
+ * cdef int i
+ */
+ Py_DECREF(Py_None);
+
+ /* "View.MemoryView":379
+ * if self.obj is not None:
+ * __Pyx_ReleaseBuffer(&self.view)
+ * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<<
+ *
+ * (<__pyx_buffer *> &self.view).obj = NULL
+ */
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":386
+ * cdef int i
+ * global __pyx_memoryview_thread_locks_used
+ * if self.lock != NULL: # <<<<<<<<<<<<<<
+ * for i in range(__pyx_memoryview_thread_locks_used):
+ * if __pyx_memoryview_thread_locks[i] is self.lock:
+ */
+ __pyx_t_1 = (__pyx_v_self->lock != NULL);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":387
+ * global __pyx_memoryview_thread_locks_used
+ * if self.lock != NULL:
+ * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<<
+ * if __pyx_memoryview_thread_locks[i] is self.lock:
+ * __pyx_memoryview_thread_locks_used -= 1
+ */
+ __pyx_t_2 = __pyx_memoryview_thread_locks_used;
+ __pyx_t_3 = __pyx_t_2;
+ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+ __pyx_v_i = __pyx_t_4;
+
+ /* "View.MemoryView":388
+ * if self.lock != NULL:
+ * for i in range(__pyx_memoryview_thread_locks_used):
+ * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<<
+ * __pyx_memoryview_thread_locks_used -= 1
+ * if i != __pyx_memoryview_thread_locks_used:
+ */
+ __pyx_t_1 = ((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":389
+ * for i in range(__pyx_memoryview_thread_locks_used):
+ * if __pyx_memoryview_thread_locks[i] is self.lock:
+ * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<<
+ * if i != __pyx_memoryview_thread_locks_used:
+ * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ */
+ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1);
+
+ /* "View.MemoryView":390
+ * if __pyx_memoryview_thread_locks[i] is self.lock:
+ * __pyx_memoryview_thread_locks_used -= 1
+ * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<<
+ * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ */
+ __pyx_t_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":392
+ * if i != __pyx_memoryview_thread_locks_used:
+ * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<<
+ * break
+ * else:
+ */
+ __pyx_t_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
+ __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]);
+
+ /* "View.MemoryView":391
+ * __pyx_memoryview_thread_locks_used -= 1
+ * if i != __pyx_memoryview_thread_locks_used:
+ * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<<
+ * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ * break
+ */
+ (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_5;
+ (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6;
+
+ /* "View.MemoryView":390
+ * if __pyx_memoryview_thread_locks[i] is self.lock:
+ * __pyx_memoryview_thread_locks_used -= 1
+ * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<<
+ * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ */
+ }
+
+ /* "View.MemoryView":393
+ * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ * break # <<<<<<<<<<<<<<
+ * else:
+ * PyThread_free_lock(self.lock)
+ */
+ goto __pyx_L6_break;
+
+ /* "View.MemoryView":388
+ * if self.lock != NULL:
+ * for i in range(__pyx_memoryview_thread_locks_used):
+ * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<<
+ * __pyx_memoryview_thread_locks_used -= 1
+ * if i != __pyx_memoryview_thread_locks_used:
+ */
+ }
+ }
+ /*else*/ {
+
+ /* "View.MemoryView":395
+ * break
+ * else:
+ * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<<
+ *
+ * cdef char *get_item_pointer(memoryview self, object index) except NULL:
+ */
+ PyThread_free_lock(__pyx_v_self->lock);
+ }
+ __pyx_L6_break:;
+
+ /* "View.MemoryView":386
+ * cdef int i
+ * global __pyx_memoryview_thread_locks_used
+ * if self.lock != NULL: # <<<<<<<<<<<<<<
+ * for i in range(__pyx_memoryview_thread_locks_used):
+ * if __pyx_memoryview_thread_locks[i] is self.lock:
+ */
+ }
+
+ /* "View.MemoryView":376
+ * self.typeinfo = NULL
+ *
+ * def __dealloc__(memoryview self): # <<<<<<<<<<<<<<
+ * if self.obj is not None:
+ * __Pyx_ReleaseBuffer(&self.view)
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":397
+ * PyThread_free_lock(self.lock)
+ *
+ * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t dim
+ * cdef char *itemp = self.view.buf
+ */
+
+static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
+ Py_ssize_t __pyx_v_dim;
+ char *__pyx_v_itemp;
+ PyObject *__pyx_v_idx = NULL;
+ char *__pyx_r;
+ __Pyx_RefNannyDeclarations
+ Py_ssize_t __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t __pyx_t_3;
+ PyObject *(*__pyx_t_4)(PyObject *);
+ PyObject *__pyx_t_5 = NULL;
+ Py_ssize_t __pyx_t_6;
+ char *__pyx_t_7;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("get_item_pointer", 0);
+
+ /* "View.MemoryView":399
+ * cdef char *get_item_pointer(memoryview self, object index) except NULL:
+ * cdef Py_ssize_t dim
+ * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<<
+ *
+ * for dim, idx in enumerate(index):
+ */
+ __pyx_v_itemp = ((char *)__pyx_v_self->view.buf);
+
+ /* "View.MemoryView":401
+ * cdef char *itemp = self.view.buf
+ *
+ * for dim, idx in enumerate(index): # <<<<<<<<<<<<<<
+ * itemp = pybuffer_index(&self.view, itemp, idx, dim)
+ *
+ */
+ __pyx_t_1 = 0;
+ if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) {
+ __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 401, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 401, __pyx_L1_error)
+ }
+ for (;;) {
+ if (likely(!__pyx_t_4)) {
+ if (likely(PyList_CheckExact(__pyx_t_2))) {
+ if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error)
+ #else
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ #endif
+ } else {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error)
+ #else
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ #endif
+ }
+ } else {
+ __pyx_t_5 = __pyx_t_4(__pyx_t_2);
+ if (unlikely(!__pyx_t_5)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(1, 401, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_5);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_v_dim = __pyx_t_1;
+ __pyx_t_1 = (__pyx_t_1 + 1);
+
+ /* "View.MemoryView":402
+ *
+ * for dim, idx in enumerate(index):
+ * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<<
+ *
+ * return itemp
+ */
+ __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 402, __pyx_L1_error)
+ __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 402, __pyx_L1_error)
+ __pyx_v_itemp = __pyx_t_7;
+
+ /* "View.MemoryView":401
+ * cdef char *itemp = self.view.buf
+ *
+ * for dim, idx in enumerate(index): # <<<<<<<<<<<<<<
+ * itemp = pybuffer_index(&self.view, itemp, idx, dim)
+ *
+ */
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "View.MemoryView":404
+ * itemp = pybuffer_index(&self.view, itemp, idx, dim)
+ *
+ * return itemp # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_itemp;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":397
+ * PyThread_free_lock(self.lock)
+ *
+ * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t dim
+ * cdef char *itemp = self.view.buf
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_idx);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":407
+ *
+ *
+ * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<<
+ * if index is Ellipsis:
+ * return self
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/
+static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
+ PyObject *__pyx_v_have_slices = NULL;
+ PyObject *__pyx_v_indices = NULL;
+ char *__pyx_v_itemp;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ char *__pyx_t_5;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__getitem__", 0);
+
+ /* "View.MemoryView":408
+ *
+ * def __getitem__(memoryview self, object index):
+ * if index is Ellipsis: # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":409
+ * def __getitem__(memoryview self, object index):
+ * if index is Ellipsis:
+ * return self # <<<<<<<<<<<<<<
+ *
+ * have_slices, indices = _unellipsify(index, self.view.ndim)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF((PyObject *)__pyx_v_self);
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":408
+ *
+ * def __getitem__(memoryview self, object index):
+ * if index is Ellipsis: # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ }
+
+ /* "View.MemoryView":411
+ * return self
+ *
+ * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<<
+ *
+ * cdef char *itemp
+ */
+ __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 411, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (likely(__pyx_t_2 != Py_None)) {
+ PyObject* sequence = __pyx_t_2;
+ Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(1, 411, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ #else
+ __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ #endif
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ } else {
+ __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 411, __pyx_L1_error)
+ }
+ __pyx_v_have_slices = __pyx_t_3;
+ __pyx_t_3 = 0;
+ __pyx_v_indices = __pyx_t_4;
+ __pyx_t_4 = 0;
+
+ /* "View.MemoryView":414
+ *
+ * cdef char *itemp
+ * if have_slices: # <<<<<<<<<<<<<<
+ * return memview_slice(self, indices)
+ * else:
+ */
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 414, __pyx_L1_error)
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":415
+ * cdef char *itemp
+ * if have_slices:
+ * return memview_slice(self, indices) # <<<<<<<<<<<<<<
+ * else:
+ * itemp = self.get_item_pointer(indices)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":414
+ *
+ * cdef char *itemp
+ * if have_slices: # <<<<<<<<<<<<<<
+ * return memview_slice(self, indices)
+ * else:
+ */
+ }
+
+ /* "View.MemoryView":417
+ * return memview_slice(self, indices)
+ * else:
+ * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<<
+ * return self.convert_item_to_object(itemp)
+ *
+ */
+ /*else*/ {
+ __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((char *)NULL))) __PYX_ERR(1, 417, __pyx_L1_error)
+ __pyx_v_itemp = __pyx_t_5;
+
+ /* "View.MemoryView":418
+ * else:
+ * itemp = self.get_item_pointer(indices)
+ * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<<
+ *
+ * def __setitem__(memoryview self, object index, object value):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+ }
+
+ /* "View.MemoryView":407
+ *
+ *
+ * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<<
+ * if index is Ellipsis:
+ * return self
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_have_slices);
+ __Pyx_XDECREF(__pyx_v_indices);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":420
+ * return self.convert_item_to_object(itemp)
+ *
+ * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<<
+ * if self.view.readonly:
+ * raise TypeError, "Cannot assign to read-only memoryview"
+ */
+
+/* Python wrapper */
+static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/
+static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
+ PyObject *__pyx_v_have_slices = NULL;
+ PyObject *__pyx_v_obj = NULL;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_t_4;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__setitem__", 0);
+ __Pyx_INCREF(__pyx_v_index);
+
+ /* "View.MemoryView":421
+ *
+ * def __setitem__(memoryview self, object index, object value):
+ * if self.view.readonly: # <<<<<<<<<<<<<<
+ * raise TypeError, "Cannot assign to read-only memoryview"
+ *
+ */
+ if (unlikely(__pyx_v_self->view.readonly)) {
+
+ /* "View.MemoryView":422
+ * def __setitem__(memoryview self, object index, object value):
+ * if self.view.readonly:
+ * raise TypeError, "Cannot assign to read-only memoryview" # <<<<<<<<<<<<<<
+ *
+ * have_slices, index = _unellipsify(index, self.view.ndim)
+ */
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Cannot_assign_to_read_only_memor, 0, 0);
+ __PYX_ERR(1, 422, __pyx_L1_error)
+
+ /* "View.MemoryView":421
+ *
+ * def __setitem__(memoryview self, object index, object value):
+ * if self.view.readonly: # <<<<<<<<<<<<<<
+ * raise TypeError, "Cannot assign to read-only memoryview"
+ *
+ */
+ }
+
+ /* "View.MemoryView":424
+ * raise TypeError, "Cannot assign to read-only memoryview"
+ *
+ * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<<
+ *
+ * if have_slices:
+ */
+ __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (likely(__pyx_t_1 != Py_None)) {
+ PyObject* sequence = __pyx_t_1;
+ Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(1, 424, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
+ __Pyx_INCREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ #else
+ __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ #endif
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ } else {
+ __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 424, __pyx_L1_error)
+ }
+ __pyx_v_have_slices = __pyx_t_2;
+ __pyx_t_2 = 0;
+ __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "View.MemoryView":426
+ * have_slices, index = _unellipsify(index, self.view.ndim)
+ *
+ * if have_slices: # <<<<<<<<<<<<<<
+ * obj = self.is_slice(value)
+ * if obj:
+ */
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 426, __pyx_L1_error)
+ if (__pyx_t_4) {
+
+ /* "View.MemoryView":427
+ *
+ * if have_slices:
+ * obj = self.is_slice(value) # <<<<<<<<<<<<<<
+ * if obj:
+ * self.setitem_slice_assignment(self[index], obj)
+ */
+ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_obj = __pyx_t_1;
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":428
+ * if have_slices:
+ * obj = self.is_slice(value)
+ * if obj: # <<<<<<<<<<<<<<
+ * self.setitem_slice_assignment(self[index], obj)
+ * else:
+ */
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 428, __pyx_L1_error)
+ if (__pyx_t_4) {
+
+ /* "View.MemoryView":429
+ * obj = self.is_slice(value)
+ * if obj:
+ * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<<
+ * else:
+ * self.setitem_slice_assign_scalar(self[index], value)
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+ /* "View.MemoryView":428
+ * if have_slices:
+ * obj = self.is_slice(value)
+ * if obj: # <<<<<<<<<<<<<<
+ * self.setitem_slice_assignment(self[index], obj)
+ * else:
+ */
+ goto __pyx_L5;
+ }
+
+ /* "View.MemoryView":431
+ * self.setitem_slice_assignment(self[index], obj)
+ * else:
+ * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<<
+ * else:
+ * self.setitem_indexed(index, value)
+ */
+ /*else*/ {
+ __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 431, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 431, __pyx_L1_error)
+ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 431, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+ __pyx_L5:;
+
+ /* "View.MemoryView":426
+ * have_slices, index = _unellipsify(index, self.view.ndim)
+ *
+ * if have_slices: # <<<<<<<<<<<<<<
+ * obj = self.is_slice(value)
+ * if obj:
+ */
+ goto __pyx_L4;
+ }
+
+ /* "View.MemoryView":433
+ * self.setitem_slice_assign_scalar(self[index], value)
+ * else:
+ * self.setitem_indexed(index, value) # <<<<<<<<<<<<<<
+ *
+ * cdef is_slice(self, obj):
+ */
+ /*else*/ {
+ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 433, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+ __pyx_L4:;
+
+ /* "View.MemoryView":420
+ * return self.convert_item_to_object(itemp)
+ *
+ * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<<
+ * if self.view.readonly:
+ * raise TypeError, "Cannot assign to read-only memoryview"
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_have_slices);
+ __Pyx_XDECREF(__pyx_v_obj);
+ __Pyx_XDECREF(__pyx_v_index);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":435
+ * self.setitem_indexed(index, value)
+ *
+ * cdef is_slice(self, obj): # <<<<<<<<<<<<<<
+ * if not isinstance(obj, memoryview):
+ * try:
+ */
+
+static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ int __pyx_t_9;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("is_slice", 0);
+ __Pyx_INCREF(__pyx_v_obj);
+
+ /* "View.MemoryView":436
+ *
+ * cdef is_slice(self, obj):
+ * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<<
+ * try:
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ */
+ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type);
+ __pyx_t_2 = (!__pyx_t_1);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":437
+ * cdef is_slice(self, obj):
+ * if not isinstance(obj, memoryview):
+ * try: # <<<<<<<<<<<<<<
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ * self.dtype_is_object)
+ */
+ {
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+ __Pyx_XGOTREF(__pyx_t_3);
+ __Pyx_XGOTREF(__pyx_t_4);
+ __Pyx_XGOTREF(__pyx_t_5);
+ /*try:*/ {
+
+ /* "View.MemoryView":438
+ * if not isinstance(obj, memoryview):
+ * try:
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<<
+ * self.dtype_is_object)
+ * except TypeError:
+ */
+ __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error)
+ __Pyx_GOTREF(__pyx_t_6);
+
+ /* "View.MemoryView":439
+ * try:
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ * self.dtype_is_object) # <<<<<<<<<<<<<<
+ * except TypeError:
+ * return None
+ */
+ __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 439, __pyx_L4_error)
+ __Pyx_GOTREF(__pyx_t_7);
+
+ /* "View.MemoryView":438
+ * if not isinstance(obj, memoryview):
+ * try:
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<<
+ * self.dtype_is_object)
+ * except TypeError:
+ */
+ __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 438, __pyx_L4_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_INCREF(__pyx_v_obj);
+ __Pyx_GIVEREF(__pyx_v_obj);
+ PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj);
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
+ __pyx_t_6 = 0;
+ __pyx_t_7 = 0;
+ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7);
+ __pyx_t_7 = 0;
+
+ /* "View.MemoryView":437
+ * cdef is_slice(self, obj):
+ * if not isinstance(obj, memoryview):
+ * try: # <<<<<<<<<<<<<<
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ * self.dtype_is_object)
+ */
+ }
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ goto __pyx_L9_try_end;
+ __pyx_L4_error:;
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+ /* "View.MemoryView":440
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ * self.dtype_is_object)
+ * except TypeError: # <<<<<<<<<<<<<<
+ * return None
+ *
+ */
+ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
+ if (__pyx_t_9) {
+ __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 440, __pyx_L6_except_error)
+ __Pyx_XGOTREF(__pyx_t_7);
+ __Pyx_XGOTREF(__pyx_t_8);
+ __Pyx_XGOTREF(__pyx_t_6);
+
+ /* "View.MemoryView":441
+ * self.dtype_is_object)
+ * except TypeError:
+ * return None # <<<<<<<<<<<<<<
+ *
+ * return obj
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ goto __pyx_L7_except_return;
+ }
+ goto __pyx_L6_except_error;
+
+ /* "View.MemoryView":437
+ * cdef is_slice(self, obj):
+ * if not isinstance(obj, memoryview):
+ * try: # <<<<<<<<<<<<<<
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ * self.dtype_is_object)
+ */
+ __pyx_L6_except_error:;
+ __Pyx_XGIVEREF(__pyx_t_3);
+ __Pyx_XGIVEREF(__pyx_t_4);
+ __Pyx_XGIVEREF(__pyx_t_5);
+ __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+ goto __pyx_L1_error;
+ __pyx_L7_except_return:;
+ __Pyx_XGIVEREF(__pyx_t_3);
+ __Pyx_XGIVEREF(__pyx_t_4);
+ __Pyx_XGIVEREF(__pyx_t_5);
+ __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+ goto __pyx_L0;
+ __pyx_L9_try_end:;
+ }
+
+ /* "View.MemoryView":436
+ *
+ * cdef is_slice(self, obj):
+ * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<<
+ * try:
+ * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ */
+ }
+
+ /* "View.MemoryView":443
+ * return None
+ *
+ * return obj # <<<<<<<<<<<<<<
+ *
+ * cdef setitem_slice_assignment(self, dst, src):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_obj);
+ __pyx_r = __pyx_v_obj;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":435
+ * self.setitem_indexed(index, value)
+ *
+ * cdef is_slice(self, obj): # <<<<<<<<<<<<<<
+ * if not isinstance(obj, memoryview):
+ * try:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_obj);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":445
+ * return obj
+ *
+ * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice dst_slice
+ * cdef __Pyx_memviewslice src_slice
+ */
+
+static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) {
+ __Pyx_memviewslice __pyx_v_dst_slice;
+ __Pyx_memviewslice __pyx_v_src_slice;
+ __Pyx_memviewslice __pyx_v_msrc;
+ __Pyx_memviewslice __pyx_v_mdst;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_memviewslice *__pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_t_3;
+ int __pyx_t_4;
+ int __pyx_t_5;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("setitem_slice_assignment", 0);
+
+ /* "View.MemoryView":448
+ * cdef __Pyx_memviewslice dst_slice
+ * cdef __Pyx_memviewslice src_slice
+ * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0]
+ *
+ */
+ if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error)
+ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error)
+ __pyx_v_msrc = (__pyx_t_1[0]);
+
+ /* "View.MemoryView":449
+ * cdef __Pyx_memviewslice src_slice
+ * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0]
+ * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<<
+ *
+ * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object)
+ */
+ if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 449, __pyx_L1_error)
+ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error)
+ __pyx_v_mdst = (__pyx_t_1[0]);
+
+ /* "View.MemoryView":451
+ * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0]
+ *
+ * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<<
+ *
+ * cdef setitem_slice_assign_scalar(self, memoryview dst, value):
+ */
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 451, __pyx_L1_error)
+
+ /* "View.MemoryView":445
+ * return obj
+ *
+ * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice dst_slice
+ * cdef __Pyx_memviewslice src_slice
+ */
+
+ /* function exit code */
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":453
+ * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object)
+ *
+ * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<<
+ * cdef int array[128]
+ * cdef void *tmp = NULL
+ */
+
+static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) {
+ int __pyx_v_array[0x80];
+ void *__pyx_v_tmp;
+ void *__pyx_v_item;
+ __Pyx_memviewslice *__pyx_v_dst_slice;
+ __Pyx_memviewslice __pyx_v_tmp_slice;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_memviewslice *__pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_t_4;
+ int __pyx_t_5;
+ char const *__pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ PyObject *__pyx_t_10 = NULL;
+ PyObject *__pyx_t_11 = NULL;
+ PyObject *__pyx_t_12 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0);
+
+ /* "View.MemoryView":455
+ * cdef setitem_slice_assign_scalar(self, memoryview dst, value):
+ * cdef int array[128]
+ * cdef void *tmp = NULL # <<<<<<<<<<<<<<
+ * cdef void *item
+ *
+ */
+ __pyx_v_tmp = NULL;
+
+ /* "View.MemoryView":460
+ * cdef __Pyx_memviewslice *dst_slice
+ * cdef __Pyx_memviewslice tmp_slice
+ * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<<
+ *
+ * if self.view.itemsize > sizeof(array):
+ */
+ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 460, __pyx_L1_error)
+ __pyx_v_dst_slice = __pyx_t_1;
+
+ /* "View.MemoryView":462
+ * dst_slice = get_slice_from_memview(dst, &tmp_slice)
+ *
+ * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<<
+ * tmp = PyMem_Malloc(self.view.itemsize)
+ * if tmp == NULL:
+ */
+ __pyx_t_2 = (((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array)));
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":463
+ *
+ * if self.view.itemsize > sizeof(array):
+ * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<<
+ * if tmp == NULL:
+ * raise MemoryError
+ */
+ __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize);
+
+ /* "View.MemoryView":464
+ * if self.view.itemsize > sizeof(array):
+ * tmp = PyMem_Malloc(self.view.itemsize)
+ * if tmp == NULL: # <<<<<<<<<<<<<<
+ * raise MemoryError
+ * item = tmp
+ */
+ __pyx_t_2 = (__pyx_v_tmp == NULL);
+ if (unlikely(__pyx_t_2)) {
+
+ /* "View.MemoryView":465
+ * tmp = PyMem_Malloc(self.view.itemsize)
+ * if tmp == NULL:
+ * raise MemoryError # <<<<<<<<<<<<<<
+ * item = tmp
+ * else:
+ */
+ PyErr_NoMemory(); __PYX_ERR(1, 465, __pyx_L1_error)
+
+ /* "View.MemoryView":464
+ * if self.view.itemsize > sizeof(array):
+ * tmp = PyMem_Malloc(self.view.itemsize)
+ * if tmp == NULL: # <<<<<<<<<<<<<<
+ * raise MemoryError
+ * item = tmp
+ */
+ }
+
+ /* "View.MemoryView":466
+ * if tmp == NULL:
+ * raise MemoryError
+ * item = tmp # <<<<<<<<<<<<<<
+ * else:
+ * item = array
+ */
+ __pyx_v_item = __pyx_v_tmp;
+
+ /* "View.MemoryView":462
+ * dst_slice = get_slice_from_memview(dst, &tmp_slice)
+ *
+ * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<<
+ * tmp = PyMem_Malloc(self.view.itemsize)
+ * if tmp == NULL:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":468
+ * item = tmp
+ * else:
+ * item = array # <<<<<<<<<<<<<<
+ *
+ * try:
+ */
+ /*else*/ {
+ __pyx_v_item = ((void *)__pyx_v_array);
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":470
+ * item = array
+ *
+ * try: # <<<<<<<<<<<<<<
+ * if self.dtype_is_object:
+ * ( item)[0] = value
+ */
+ /*try:*/ {
+
+ /* "View.MemoryView":471
+ *
+ * try:
+ * if self.dtype_is_object: # <<<<<<<<<<<<<<
+ * ( item)[0] = value
+ * else:
+ */
+ if (__pyx_v_self->dtype_is_object) {
+
+ /* "View.MemoryView":472
+ * try:
+ * if self.dtype_is_object:
+ * ( item)[0] = value # <<<<<<<<<<<<<<
+ * else:
+ * self.assign_item_from_object( item, value)
+ */
+ (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value);
+
+ /* "View.MemoryView":471
+ *
+ * try:
+ * if self.dtype_is_object: # <<<<<<<<<<<<<<
+ * ( item)[0] = value
+ * else:
+ */
+ goto __pyx_L8;
+ }
+
+ /* "View.MemoryView":474
+ * ( item)[0] = value
+ * else:
+ * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ /*else*/ {
+ __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 474, __pyx_L6_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ }
+ __pyx_L8:;
+
+ /* "View.MemoryView":478
+ *
+ *
+ * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<<
+ * assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
+ * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
+ */
+ __pyx_t_2 = (__pyx_v_self->view.suboffsets != NULL);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":479
+ *
+ * if self.view.suboffsets != NULL:
+ * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<<
+ * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
+ * item, self.dtype_is_object)
+ */
+ __pyx_t_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 479, __pyx_L6_error)
+
+ /* "View.MemoryView":478
+ *
+ *
+ * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<<
+ * assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
+ * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
+ */
+ }
+
+ /* "View.MemoryView":480
+ * if self.view.suboffsets != NULL:
+ * assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
+ * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<<
+ * item, self.dtype_is_object)
+ * finally:
+ */
+ __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object);
+ }
+
+ /* "View.MemoryView":483
+ * item, self.dtype_is_object)
+ * finally:
+ * PyMem_Free(tmp) # <<<<<<<<<<<<<<
+ *
+ * cdef setitem_indexed(self, index, value):
+ */
+ /*finally:*/ {
+ /*normal exit:*/{
+ PyMem_Free(__pyx_v_tmp);
+ goto __pyx_L7;
+ }
+ __pyx_L6_error:;
+ /*exception exit:*/{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
+ if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+ __Pyx_XGOTREF(__pyx_t_7);
+ __Pyx_XGOTREF(__pyx_t_8);
+ __Pyx_XGOTREF(__pyx_t_9);
+ __Pyx_XGOTREF(__pyx_t_10);
+ __Pyx_XGOTREF(__pyx_t_11);
+ __Pyx_XGOTREF(__pyx_t_12);
+ __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
+ {
+ PyMem_Free(__pyx_v_tmp);
+ }
+ if (PY_MAJOR_VERSION >= 3) {
+ __Pyx_XGIVEREF(__pyx_t_10);
+ __Pyx_XGIVEREF(__pyx_t_11);
+ __Pyx_XGIVEREF(__pyx_t_12);
+ __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+ }
+ __Pyx_XGIVEREF(__pyx_t_7);
+ __Pyx_XGIVEREF(__pyx_t_8);
+ __Pyx_XGIVEREF(__pyx_t_9);
+ __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+ __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+ __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
+ goto __pyx_L1_error;
+ }
+ __pyx_L7:;
+ }
+
+ /* "View.MemoryView":453
+ * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object)
+ *
+ * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<<
+ * cdef int array[128]
+ * cdef void *tmp = NULL
+ */
+
+ /* function exit code */
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":485
+ * PyMem_Free(tmp)
+ *
+ * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<<
+ * cdef char *itemp = self.get_item_pointer(index)
+ * self.assign_item_from_object(itemp, value)
+ */
+
+static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
+ char *__pyx_v_itemp;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ char *__pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("setitem_indexed", 0);
+
+ /* "View.MemoryView":486
+ *
+ * cdef setitem_indexed(self, index, value):
+ * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<<
+ * self.assign_item_from_object(itemp, value)
+ *
+ */
+ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 486, __pyx_L1_error)
+ __pyx_v_itemp = __pyx_t_1;
+
+ /* "View.MemoryView":487
+ * cdef setitem_indexed(self, index, value):
+ * cdef char *itemp = self.get_item_pointer(index)
+ * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<<
+ *
+ * cdef convert_item_to_object(self, char *itemp):
+ */
+ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 487, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "View.MemoryView":485
+ * PyMem_Free(tmp)
+ *
+ * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<<
+ * cdef char *itemp = self.get_item_pointer(index)
+ * self.assign_item_from_object(itemp, value)
+ */
+
+ /* function exit code */
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":489
+ * self.assign_item_from_object(itemp, value)
+ *
+ * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
+ * """Only used if instantiated manually by the user, or if Cython doesn't
+ * know how to convert the type"""
+ */
+
+static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) {
+ PyObject *__pyx_v_struct = NULL;
+ PyObject *__pyx_v_bytesitem = 0;
+ PyObject *__pyx_v_result = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ int __pyx_t_8;
+ Py_ssize_t __pyx_t_9;
+ int __pyx_t_10;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("convert_item_to_object", 0);
+
+ /* "View.MemoryView":492
+ * """Only used if instantiated manually by the user, or if Cython doesn't
+ * know how to convert the type"""
+ * import struct # <<<<<<<<<<<<<<
+ * cdef bytes bytesitem
+ *
+ */
+ __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_struct = __pyx_t_1;
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":495
+ * cdef bytes bytesitem
+ *
+ * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<<
+ * try:
+ * result = struct.unpack(self.view.format, bytesitem)
+ */
+ __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_bytesitem = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":496
+ *
+ * bytesitem = itemp[:self.view.itemsize]
+ * try: # <<<<<<<<<<<<<<
+ * result = struct.unpack(self.view.format, bytesitem)
+ * except struct.error:
+ */
+ {
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+ __Pyx_XGOTREF(__pyx_t_2);
+ __Pyx_XGOTREF(__pyx_t_3);
+ __Pyx_XGOTREF(__pyx_t_4);
+ /*try:*/ {
+
+ /* "View.MemoryView":497
+ * bytesitem = itemp[:self.view.itemsize]
+ * try:
+ * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<<
+ * except struct.error:
+ * raise ValueError, "Unable to convert item to object"
+ */
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 497, __pyx_L3_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L3_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ __pyx_t_8 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ __pyx_t_8 = 1;
+ }
+ }
+ {
+ PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
+ __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 497, __pyx_L3_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ __pyx_v_result = __pyx_t_1;
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":496
+ *
+ * bytesitem = itemp[:self.view.itemsize]
+ * try: # <<<<<<<<<<<<<<
+ * result = struct.unpack(self.view.format, bytesitem)
+ * except struct.error:
+ */
+ }
+
+ /* "View.MemoryView":501
+ * raise ValueError, "Unable to convert item to object"
+ * else:
+ * if len(self.view.format) == 1: # <<<<<<<<<<<<<<
+ * return result[0]
+ * return result
+ */
+ /*else:*/ {
+ __pyx_t_9 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 501, __pyx_L5_except_error)
+ __pyx_t_10 = (__pyx_t_9 == 1);
+ if (__pyx_t_10) {
+
+ /* "View.MemoryView":502
+ * else:
+ * if len(self.view.format) == 1:
+ * return result[0] # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 502, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L6_except_return;
+
+ /* "View.MemoryView":501
+ * raise ValueError, "Unable to convert item to object"
+ * else:
+ * if len(self.view.format) == 1: # <<<<<<<<<<<<<<
+ * return result[0]
+ * return result
+ */
+ }
+
+ /* "View.MemoryView":503
+ * if len(self.view.format) == 1:
+ * return result[0]
+ * return result # <<<<<<<<<<<<<<
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_result);
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L6_except_return;
+ }
+ __pyx_L3_error:;
+ __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+ /* "View.MemoryView":498
+ * try:
+ * result = struct.unpack(self.view.format, bytesitem)
+ * except struct.error: # <<<<<<<<<<<<<<
+ * raise ValueError, "Unable to convert item to object"
+ * else:
+ */
+ __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 498, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_7);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6);
+ __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0;
+ if (__pyx_t_8) {
+ __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 498, __pyx_L5_except_error)
+ __Pyx_XGOTREF(__pyx_t_6);
+ __Pyx_XGOTREF(__pyx_t_5);
+ __Pyx_XGOTREF(__pyx_t_1);
+
+ /* "View.MemoryView":499
+ * result = struct.unpack(self.view.format, bytesitem)
+ * except struct.error:
+ * raise ValueError, "Unable to convert item to object" # <<<<<<<<<<<<<<
+ * else:
+ * if len(self.view.format) == 1:
+ */
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Unable_to_convert_item_to_object, 0, 0);
+ __PYX_ERR(1, 499, __pyx_L5_except_error)
+ }
+ goto __pyx_L5_except_error;
+
+ /* "View.MemoryView":496
+ *
+ * bytesitem = itemp[:self.view.itemsize]
+ * try: # <<<<<<<<<<<<<<
+ * result = struct.unpack(self.view.format, bytesitem)
+ * except struct.error:
+ */
+ __pyx_L5_except_error:;
+ __Pyx_XGIVEREF(__pyx_t_2);
+ __Pyx_XGIVEREF(__pyx_t_3);
+ __Pyx_XGIVEREF(__pyx_t_4);
+ __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+ goto __pyx_L1_error;
+ __pyx_L6_except_return:;
+ __Pyx_XGIVEREF(__pyx_t_2);
+ __Pyx_XGIVEREF(__pyx_t_3);
+ __Pyx_XGIVEREF(__pyx_t_4);
+ __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+ goto __pyx_L0;
+ }
+
+ /* "View.MemoryView":489
+ * self.assign_item_from_object(itemp, value)
+ *
+ * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
+ * """Only used if instantiated manually by the user, or if Cython doesn't
+ * know how to convert the type"""
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_struct);
+ __Pyx_XDECREF(__pyx_v_bytesitem);
+ __Pyx_XDECREF(__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":505
+ * return result
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
+ * """Only used if instantiated manually by the user, or if Cython doesn't
+ * know how to convert the type"""
+ */
+
+static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
+ PyObject *__pyx_v_struct = NULL;
+ char __pyx_v_c;
+ PyObject *__pyx_v_bytesvalue = 0;
+ Py_ssize_t __pyx_v_i;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ Py_ssize_t __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ char *__pyx_t_9;
+ char *__pyx_t_10;
+ char *__pyx_t_11;
+ char *__pyx_t_12;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("assign_item_from_object", 0);
+
+ /* "View.MemoryView":508
+ * """Only used if instantiated manually by the user, or if Cython doesn't
+ * know how to convert the type"""
+ * import struct # <<<<<<<<<<<<<<
+ * cdef char c
+ * cdef bytes bytesvalue
+ */
+ __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_struct = __pyx_t_1;
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":513
+ * cdef Py_ssize_t i
+ *
+ * if isinstance(value, tuple): # <<<<<<<<<<<<<<
+ * bytesvalue = struct.pack(self.view.format, *value)
+ * else:
+ */
+ __pyx_t_2 = PyTuple_Check(__pyx_v_value);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":514
+ *
+ * if isinstance(value, tuple):
+ * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<<
+ * else:
+ * bytesvalue = struct.pack(self.view.format, value)
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 514, __pyx_L1_error)
+ __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "View.MemoryView":513
+ * cdef Py_ssize_t i
+ *
+ * if isinstance(value, tuple): # <<<<<<<<<<<<<<
+ * bytesvalue = struct.pack(self.view.format, *value)
+ * else:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":516
+ * bytesvalue = struct.pack(self.view.format, *value)
+ * else:
+ * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<<
+ *
+ * for i, c in enumerate(bytesvalue):
+ */
+ /*else*/ {
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ {
+ PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_value};
+ __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 516, __pyx_L1_error)
+ __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3);
+ __pyx_t_3 = 0;
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":518
+ * bytesvalue = struct.pack(self.view.format, value)
+ *
+ * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<<
+ * itemp[i] = c
+ *
+ */
+ __pyx_t_7 = 0;
+ if (unlikely(__pyx_v_bytesvalue == Py_None)) {
+ PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable");
+ __PYX_ERR(1, 518, __pyx_L1_error)
+ }
+ __Pyx_INCREF(__pyx_v_bytesvalue);
+ __pyx_t_8 = __pyx_v_bytesvalue;
+ __pyx_t_10 = PyBytes_AS_STRING(__pyx_t_8);
+ __pyx_t_11 = (__pyx_t_10 + PyBytes_GET_SIZE(__pyx_t_8));
+ for (__pyx_t_12 = __pyx_t_10; __pyx_t_12 < __pyx_t_11; __pyx_t_12++) {
+ __pyx_t_9 = __pyx_t_12;
+ __pyx_v_c = (__pyx_t_9[0]);
+
+ /* "View.MemoryView":519
+ *
+ * for i, c in enumerate(bytesvalue):
+ * itemp[i] = c # <<<<<<<<<<<<<<
+ *
+ * @cname('getbuffer')
+ */
+ __pyx_v_i = __pyx_t_7;
+
+ /* "View.MemoryView":518
+ * bytesvalue = struct.pack(self.view.format, value)
+ *
+ * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<<
+ * itemp[i] = c
+ *
+ */
+ __pyx_t_7 = (__pyx_t_7 + 1);
+
+ /* "View.MemoryView":519
+ *
+ * for i, c in enumerate(bytesvalue):
+ * itemp[i] = c # <<<<<<<<<<<<<<
+ *
+ * @cname('getbuffer')
+ */
+ (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c;
+ }
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+ /* "View.MemoryView":505
+ * return result
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
+ * """Only used if instantiated manually by the user, or if Cython doesn't
+ * know how to convert the type"""
+ */
+
+ /* function exit code */
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_struct);
+ __Pyx_XDECREF(__pyx_v_bytesvalue);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":521
+ * itemp[i] = c
+ *
+ * @cname('getbuffer') # <<<<<<<<<<<<<<
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * if flags & PyBUF_WRITABLE and self.view.readonly:
+ */
+
+/* Python wrapper */
+CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ Py_ssize_t *__pyx_t_3;
+ char *__pyx_t_4;
+ void *__pyx_t_5;
+ int __pyx_t_6;
+ Py_ssize_t __pyx_t_7;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ if (unlikely(__pyx_v_info == NULL)) {
+ PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
+ return -1;
+ }
+ __Pyx_RefNannySetupContext("__getbuffer__", 0);
+ __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+ __Pyx_GIVEREF(__pyx_v_info->obj);
+
+ /* "View.MemoryView":523
+ * @cname('getbuffer')
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<<
+ * raise ValueError, "Cannot create writable memory view from read-only memoryview"
+ *
+ */
+ __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0);
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L4_bool_binop_done;
+ }
+ __pyx_t_1 = __pyx_v_self->view.readonly;
+ __pyx_L4_bool_binop_done:;
+ if (unlikely(__pyx_t_1)) {
+
+ /* "View.MemoryView":524
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * if flags & PyBUF_WRITABLE and self.view.readonly:
+ * raise ValueError, "Cannot create writable memory view from read-only memoryview" # <<<<<<<<<<<<<<
+ *
+ * if flags & PyBUF_ND:
+ */
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Cannot_create_writable_memory_vi, 0, 0);
+ __PYX_ERR(1, 524, __pyx_L1_error)
+
+ /* "View.MemoryView":523
+ * @cname('getbuffer')
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<<
+ * raise ValueError, "Cannot create writable memory view from read-only memoryview"
+ *
+ */
+ }
+
+ /* "View.MemoryView":526
+ * raise ValueError, "Cannot create writable memory view from read-only memoryview"
+ *
+ * if flags & PyBUF_ND: # <<<<<<<<<<<<<<
+ * info.shape = self.view.shape
+ * else:
+ */
+ __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":527
+ *
+ * if flags & PyBUF_ND:
+ * info.shape = self.view.shape # <<<<<<<<<<<<<<
+ * else:
+ * info.shape = NULL
+ */
+ __pyx_t_3 = __pyx_v_self->view.shape;
+ __pyx_v_info->shape = __pyx_t_3;
+
+ /* "View.MemoryView":526
+ * raise ValueError, "Cannot create writable memory view from read-only memoryview"
+ *
+ * if flags & PyBUF_ND: # <<<<<<<<<<<<<<
+ * info.shape = self.view.shape
+ * else:
+ */
+ goto __pyx_L6;
+ }
+
+ /* "View.MemoryView":529
+ * info.shape = self.view.shape
+ * else:
+ * info.shape = NULL # <<<<<<<<<<<<<<
+ *
+ * if flags & PyBUF_STRIDES:
+ */
+ /*else*/ {
+ __pyx_v_info->shape = NULL;
+ }
+ __pyx_L6:;
+
+ /* "View.MemoryView":531
+ * info.shape = NULL
+ *
+ * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
+ * info.strides = self.view.strides
+ * else:
+ */
+ __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":532
+ *
+ * if flags & PyBUF_STRIDES:
+ * info.strides = self.view.strides # <<<<<<<<<<<<<<
+ * else:
+ * info.strides = NULL
+ */
+ __pyx_t_3 = __pyx_v_self->view.strides;
+ __pyx_v_info->strides = __pyx_t_3;
+
+ /* "View.MemoryView":531
+ * info.shape = NULL
+ *
+ * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
+ * info.strides = self.view.strides
+ * else:
+ */
+ goto __pyx_L7;
+ }
+
+ /* "View.MemoryView":534
+ * info.strides = self.view.strides
+ * else:
+ * info.strides = NULL # <<<<<<<<<<<<<<
+ *
+ * if flags & PyBUF_INDIRECT:
+ */
+ /*else*/ {
+ __pyx_v_info->strides = NULL;
+ }
+ __pyx_L7:;
+
+ /* "View.MemoryView":536
+ * info.strides = NULL
+ *
+ * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<<
+ * info.suboffsets = self.view.suboffsets
+ * else:
+ */
+ __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":537
+ *
+ * if flags & PyBUF_INDIRECT:
+ * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<<
+ * else:
+ * info.suboffsets = NULL
+ */
+ __pyx_t_3 = __pyx_v_self->view.suboffsets;
+ __pyx_v_info->suboffsets = __pyx_t_3;
+
+ /* "View.MemoryView":536
+ * info.strides = NULL
+ *
+ * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<<
+ * info.suboffsets = self.view.suboffsets
+ * else:
+ */
+ goto __pyx_L8;
+ }
+
+ /* "View.MemoryView":539
+ * info.suboffsets = self.view.suboffsets
+ * else:
+ * info.suboffsets = NULL # <<<<<<<<<<<<<<
+ *
+ * if flags & PyBUF_FORMAT:
+ */
+ /*else*/ {
+ __pyx_v_info->suboffsets = NULL;
+ }
+ __pyx_L8:;
+
+ /* "View.MemoryView":541
+ * info.suboffsets = NULL
+ *
+ * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
+ * info.format = self.view.format
+ * else:
+ */
+ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":542
+ *
+ * if flags & PyBUF_FORMAT:
+ * info.format = self.view.format # <<<<<<<<<<<<<<
+ * else:
+ * info.format = NULL
+ */
+ __pyx_t_4 = __pyx_v_self->view.format;
+ __pyx_v_info->format = __pyx_t_4;
+
+ /* "View.MemoryView":541
+ * info.suboffsets = NULL
+ *
+ * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
+ * info.format = self.view.format
+ * else:
+ */
+ goto __pyx_L9;
+ }
+
+ /* "View.MemoryView":544
+ * info.format = self.view.format
+ * else:
+ * info.format = NULL # <<<<<<<<<<<<<<
+ *
+ * info.buf = self.view.buf
+ */
+ /*else*/ {
+ __pyx_v_info->format = NULL;
+ }
+ __pyx_L9:;
+
+ /* "View.MemoryView":546
+ * info.format = NULL
+ *
+ * info.buf = self.view.buf # <<<<<<<<<<<<<<
+ * info.ndim = self.view.ndim
+ * info.itemsize = self.view.itemsize
+ */
+ __pyx_t_5 = __pyx_v_self->view.buf;
+ __pyx_v_info->buf = __pyx_t_5;
+
+ /* "View.MemoryView":547
+ *
+ * info.buf = self.view.buf
+ * info.ndim = self.view.ndim # <<<<<<<<<<<<<<
+ * info.itemsize = self.view.itemsize
+ * info.len = self.view.len
+ */
+ __pyx_t_6 = __pyx_v_self->view.ndim;
+ __pyx_v_info->ndim = __pyx_t_6;
+
+ /* "View.MemoryView":548
+ * info.buf = self.view.buf
+ * info.ndim = self.view.ndim
+ * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<<
+ * info.len = self.view.len
+ * info.readonly = self.view.readonly
+ */
+ __pyx_t_7 = __pyx_v_self->view.itemsize;
+ __pyx_v_info->itemsize = __pyx_t_7;
+
+ /* "View.MemoryView":549
+ * info.ndim = self.view.ndim
+ * info.itemsize = self.view.itemsize
+ * info.len = self.view.len # <<<<<<<<<<<<<<
+ * info.readonly = self.view.readonly
+ * info.obj = self
+ */
+ __pyx_t_7 = __pyx_v_self->view.len;
+ __pyx_v_info->len = __pyx_t_7;
+
+ /* "View.MemoryView":550
+ * info.itemsize = self.view.itemsize
+ * info.len = self.view.len
+ * info.readonly = self.view.readonly # <<<<<<<<<<<<<<
+ * info.obj = self
+ *
+ */
+ __pyx_t_1 = __pyx_v_self->view.readonly;
+ __pyx_v_info->readonly = __pyx_t_1;
+
+ /* "View.MemoryView":551
+ * info.len = self.view.len
+ * info.readonly = self.view.readonly
+ * info.obj = self # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_INCREF((PyObject *)__pyx_v_self);
+ __Pyx_GIVEREF((PyObject *)__pyx_v_self);
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj);
+ __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+
+ /* "View.MemoryView":521
+ * itemp[i] = c
+ *
+ * @cname('getbuffer') # <<<<<<<<<<<<<<
+ * def __getbuffer__(self, Py_buffer *info, int flags):
+ * if flags & PyBUF_WRITABLE and self.view.readonly:
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ if (__pyx_v_info->obj != NULL) {
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+ }
+ goto __pyx_L2;
+ __pyx_L0:;
+ if (__pyx_v_info->obj == Py_None) {
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+ }
+ __pyx_L2:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":554
+ *
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def T(self):
+ * cdef _memoryviewslice result = memoryview_copy(self)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_t_2;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":556
+ * @property
+ * def T(self):
+ * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<<
+ * transpose_memslice(&result.from_slice)
+ * return result
+ */
+ __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":557
+ * def T(self):
+ * cdef _memoryviewslice result = memoryview_copy(self)
+ * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 557, __pyx_L1_error)
+
+ /* "View.MemoryView":558
+ * cdef _memoryviewslice result = memoryview_copy(self)
+ * transpose_memslice(&result.from_slice)
+ * return result # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF((PyObject *)__pyx_v_result);
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":554
+ *
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def T(self):
+ * cdef _memoryviewslice result = memoryview_copy(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":560
+ * return result
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def base(self):
+ * return self._get_base()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":562
+ * @property
+ * def base(self):
+ * return self._get_base() # <<<<<<<<<<<<<<
+ *
+ * cdef _get_base(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":560
+ * return result
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def base(self):
+ * return self._get_base()
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":564
+ * return self._get_base()
+ *
+ * cdef _get_base(self): # <<<<<<<<<<<<<<
+ * return self.obj
+ *
+ */
+
+static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_get_base", 0);
+
+ /* "View.MemoryView":565
+ *
+ * cdef _get_base(self):
+ * return self.obj # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_self->obj);
+ __pyx_r = __pyx_v_self->obj;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":564
+ * return self._get_base()
+ *
+ * cdef _get_base(self): # <<<<<<<<<<<<<<
+ * return self.obj
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":567
+ * return self.obj
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def shape(self):
+ * return tuple([length for length in self.view.shape[:self.view.ndim]])
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ Py_ssize_t __pyx_7genexpr__pyx_v_length;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ Py_ssize_t *__pyx_t_2;
+ Py_ssize_t *__pyx_t_3;
+ Py_ssize_t *__pyx_t_4;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":569
+ * @property
+ * def shape(self):
+ * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ { /* enter inner scope */
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
+ for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
+ __pyx_t_2 = __pyx_t_4;
+ __pyx_7genexpr__pyx_v_length = (__pyx_t_2[0]);
+ __pyx_t_5 = PyInt_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 569, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ } /* exit inner scope */
+ __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_r = __pyx_t_5;
+ __pyx_t_5 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":567
+ * return self.obj
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def shape(self):
+ * return tuple([length for length in self.view.shape[:self.view.ndim]])
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":571
+ * return tuple([length for length in self.view.shape[:self.view.ndim]])
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def strides(self):
+ * if self.view.strides == NULL:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ Py_ssize_t __pyx_8genexpr1__pyx_v_stride;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t *__pyx_t_3;
+ Py_ssize_t *__pyx_t_4;
+ Py_ssize_t *__pyx_t_5;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":573
+ * @property
+ * def strides(self):
+ * if self.view.strides == NULL: # <<<<<<<<<<<<<<
+ *
+ * raise ValueError, "Buffer view does not expose strides"
+ */
+ __pyx_t_1 = (__pyx_v_self->view.strides == NULL);
+ if (unlikely(__pyx_t_1)) {
+
+ /* "View.MemoryView":575
+ * if self.view.strides == NULL:
+ *
+ * raise ValueError, "Buffer view does not expose strides" # <<<<<<<<<<<<<<
+ *
+ * return tuple([stride for stride in self.view.strides[:self.view.ndim]])
+ */
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Buffer_view_does_not_expose_stri, 0, 0);
+ __PYX_ERR(1, 575, __pyx_L1_error)
+
+ /* "View.MemoryView":573
+ * @property
+ * def strides(self):
+ * if self.view.strides == NULL: # <<<<<<<<<<<<<<
+ *
+ * raise ValueError, "Buffer view does not expose strides"
+ */
+ }
+
+ /* "View.MemoryView":577
+ * raise ValueError, "Buffer view does not expose strides"
+ *
+ * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ { /* enter inner scope */
+ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim);
+ for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
+ __pyx_t_3 = __pyx_t_5;
+ __pyx_8genexpr1__pyx_v_stride = (__pyx_t_3[0]);
+ __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 577, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ } /* exit inner scope */
+ __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_6;
+ __pyx_t_6 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":571
+ * return tuple([length for length in self.view.shape[:self.view.ndim]])
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def strides(self):
+ * if self.view.strides == NULL:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":579
+ * return tuple([stride for stride in self.view.strides[:self.view.ndim]])
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def suboffsets(self):
+ * if self.view.suboffsets == NULL:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ Py_ssize_t __pyx_8genexpr2__pyx_v_suboffset;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t *__pyx_t_3;
+ Py_ssize_t *__pyx_t_4;
+ Py_ssize_t *__pyx_t_5;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":581
+ * @property
+ * def suboffsets(self):
+ * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<<
+ * return (-1,) * self.view.ndim
+ *
+ */
+ __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":582
+ * def suboffsets(self):
+ * if self.view.suboffsets == NULL:
+ * return (-1,) * self.view.ndim # <<<<<<<<<<<<<<
+ *
+ * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_tuple__4, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 582, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":581
+ * @property
+ * def suboffsets(self):
+ * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<<
+ * return (-1,) * self.view.ndim
+ *
+ */
+ }
+
+ /* "View.MemoryView":584
+ * return (-1,) * self.view.ndim
+ *
+ * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ { /* enter inner scope */
+ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim);
+ for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
+ __pyx_t_3 = __pyx_t_5;
+ __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]);
+ __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 584, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ } /* exit inner scope */
+ __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_6;
+ __pyx_t_6 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":579
+ * return tuple([stride for stride in self.view.strides[:self.view.ndim]])
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def suboffsets(self):
+ * if self.view.suboffsets == NULL:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":586
+ * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def ndim(self):
+ * return self.view.ndim
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":588
+ * @property
+ * def ndim(self):
+ * return self.view.ndim # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":586
+ * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def ndim(self):
+ * return self.view.ndim
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":590
+ * return self.view.ndim
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def itemsize(self):
+ * return self.view.itemsize
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":592
+ * @property
+ * def itemsize(self):
+ * return self.view.itemsize # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":590
+ * return self.view.ndim
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def itemsize(self):
+ * return self.view.itemsize
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":594
+ * return self.view.itemsize
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def nbytes(self):
+ * return self.size * self.view.itemsize
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":596
+ * @property
+ * def nbytes(self):
+ * return self.size * self.view.itemsize # <<<<<<<<<<<<<<
+ *
+ * @property
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":594
+ * return self.view.itemsize
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def nbytes(self):
+ * return self.size * self.view.itemsize
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":598
+ * return self.size * self.view.itemsize
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def size(self):
+ * if self._size is None:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_v_result = NULL;
+ PyObject *__pyx_v_length = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ Py_ssize_t *__pyx_t_2;
+ Py_ssize_t *__pyx_t_3;
+ Py_ssize_t *__pyx_t_4;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "View.MemoryView":600
+ * @property
+ * def size(self):
+ * if self._size is None: # <<<<<<<<<<<<<<
+ * result = 1
+ *
+ */
+ __pyx_t_1 = (__pyx_v_self->_size == Py_None);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":601
+ * def size(self):
+ * if self._size is None:
+ * result = 1 # <<<<<<<<<<<<<<
+ *
+ * for length in self.view.shape[:self.view.ndim]:
+ */
+ __Pyx_INCREF(__pyx_int_1);
+ __pyx_v_result = __pyx_int_1;
+
+ /* "View.MemoryView":603
+ * result = 1
+ *
+ * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<<
+ * result *= length
+ *
+ */
+ __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
+ for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
+ __pyx_t_2 = __pyx_t_4;
+ __pyx_t_5 = PyInt_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 603, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5);
+ __pyx_t_5 = 0;
+
+ /* "View.MemoryView":604
+ *
+ * for length in self.view.shape[:self.view.ndim]:
+ * result *= length # <<<<<<<<<<<<<<
+ *
+ * self._size = result
+ */
+ __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5);
+ __pyx_t_5 = 0;
+ }
+
+ /* "View.MemoryView":606
+ * result *= length
+ *
+ * self._size = result # <<<<<<<<<<<<<<
+ *
+ * return self._size
+ */
+ __Pyx_INCREF(__pyx_v_result);
+ __Pyx_GIVEREF(__pyx_v_result);
+ __Pyx_GOTREF(__pyx_v_self->_size);
+ __Pyx_DECREF(__pyx_v_self->_size);
+ __pyx_v_self->_size = __pyx_v_result;
+
+ /* "View.MemoryView":600
+ * @property
+ * def size(self):
+ * if self._size is None: # <<<<<<<<<<<<<<
+ * result = 1
+ *
+ */
+ }
+
+ /* "View.MemoryView":608
+ * self._size = result
+ *
+ * return self._size # <<<<<<<<<<<<<<
+ *
+ * def __len__(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_self->_size);
+ __pyx_r = __pyx_v_self->_size;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":598
+ * return self.size * self.view.itemsize
+ *
+ * @property # <<<<<<<<<<<<<<
+ * def size(self):
+ * if self._size is None:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_result);
+ __Pyx_XDECREF(__pyx_v_length);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":610
+ * return self._size
+ *
+ * def __len__(self): # <<<<<<<<<<<<<<
+ * if self.view.ndim >= 1:
+ * return self.view.shape[0]
+ */
+
+/* Python wrapper */
+static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/
+static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ Py_ssize_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ Py_ssize_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ __Pyx_RefNannySetupContext("__len__", 0);
+
+ /* "View.MemoryView":611
+ *
+ * def __len__(self):
+ * if self.view.ndim >= 1: # <<<<<<<<<<<<<<
+ * return self.view.shape[0]
+ *
+ */
+ __pyx_t_1 = (__pyx_v_self->view.ndim >= 1);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":612
+ * def __len__(self):
+ * if self.view.ndim >= 1:
+ * return self.view.shape[0] # <<<<<<<<<<<<<<
+ *
+ * return 0
+ */
+ __pyx_r = (__pyx_v_self->view.shape[0]);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":611
+ *
+ * def __len__(self):
+ * if self.view.ndim >= 1: # <<<<<<<<<<<<<<
+ * return self.view.shape[0]
+ *
+ */
+ }
+
+ /* "View.MemoryView":614
+ * return self.view.shape[0]
+ *
+ * return 0 # <<<<<<<<<<<<<<
+ *
+ * def __repr__(self):
+ */
+ __pyx_r = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":610
+ * return self._size
+ *
+ * def __len__(self): # <<<<<<<<<<<<<<
+ * if self.view.ndim >= 1:
+ * return self.view.shape[0]
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":616
+ * return 0
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "" % (self.base.__class__.__name__,
+ * id(self))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "View.MemoryView":617
+ *
+ * def __repr__(self):
+ * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<<
+ * id(self))
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "View.MemoryView":618
+ * def __repr__(self):
+ * return "" % (self.base.__class__.__name__,
+ * id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __str__(self):
+ */
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "View.MemoryView":617
+ *
+ * def __repr__(self):
+ * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<<
+ * id(self))
+ *
+ */
+ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+ __pyx_t_1 = 0;
+ __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":616
+ * return 0
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "" % (self.base.__class__.__name__,
+ * id(self))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":620
+ * id(self))
+ *
+ * def __str__(self): # <<<<<<<<<<<<<<
+ * return "" % (self.base.__class__.__name__,)
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__str__", 0);
+
+ /* "View.MemoryView":621
+ *
+ * def __str__(self):
+ * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 621, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 621, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+ __pyx_t_1 = 0;
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":620
+ * id(self))
+ *
+ * def __str__(self): # <<<<<<<<<<<<<<
+ * return "" % (self.base.__class__.__name__,)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":624
+ *
+ *
+ * def is_c_contig(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice *mslice
+ * cdef __Pyx_memviewslice tmp
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("is_c_contig", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_c_contig", 0))) return NULL;
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
+ __Pyx_memviewslice *__pyx_v_mslice;
+ __Pyx_memviewslice __pyx_v_tmp;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_memviewslice *__pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("is_c_contig", 0);
+
+ /* "View.MemoryView":627
+ * cdef __Pyx_memviewslice *mslice
+ * cdef __Pyx_memviewslice tmp
+ * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<<
+ * return slice_is_contig(mslice[0], 'C', self.view.ndim)
+ *
+ */
+ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 627, __pyx_L1_error)
+ __pyx_v_mslice = __pyx_t_1;
+
+ /* "View.MemoryView":628
+ * cdef __Pyx_memviewslice tmp
+ * mslice = get_slice_from_memview(self, &tmp)
+ * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<<
+ *
+ * def is_f_contig(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 628, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":624
+ *
+ *
+ * def is_c_contig(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice *mslice
+ * cdef __Pyx_memviewslice tmp
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":630
+ * return slice_is_contig(mslice[0], 'C', self.view.ndim)
+ *
+ * def is_f_contig(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice *mslice
+ * cdef __Pyx_memviewslice tmp
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("is_f_contig", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_f_contig", 0))) return NULL;
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
+ __Pyx_memviewslice *__pyx_v_mslice;
+ __Pyx_memviewslice __pyx_v_tmp;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_memviewslice *__pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("is_f_contig", 0);
+
+ /* "View.MemoryView":633
+ * cdef __Pyx_memviewslice *mslice
+ * cdef __Pyx_memviewslice tmp
+ * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<<
+ * return slice_is_contig(mslice[0], 'F', self.view.ndim)
+ *
+ */
+ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 633, __pyx_L1_error)
+ __pyx_v_mslice = __pyx_t_1;
+
+ /* "View.MemoryView":634
+ * cdef __Pyx_memviewslice tmp
+ * mslice = get_slice_from_memview(self, &tmp)
+ * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<<
+ *
+ * def copy(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 634, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":630
+ * return slice_is_contig(mslice[0], 'C', self.view.ndim)
+ *
+ * def is_f_contig(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice *mslice
+ * cdef __Pyx_memviewslice tmp
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":636
+ * return slice_is_contig(mslice[0], 'F', self.view.ndim)
+ *
+ * def copy(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice mslice
+ * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("copy (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy", 0))) return NULL;
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) {
+ __Pyx_memviewslice __pyx_v_mslice;
+ int __pyx_v_flags;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_memviewslice __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("copy", 0);
+
+ /* "View.MemoryView":638
+ * def copy(self):
+ * cdef __Pyx_memviewslice mslice
+ * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<<
+ *
+ * slice_copy(self, &mslice)
+ */
+ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS));
+
+ /* "View.MemoryView":640
+ * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
+ *
+ * slice_copy(self, &mslice) # <<<<<<<<<<<<<<
+ * mslice = slice_copy_contig(&mslice, "c", self.view.ndim,
+ * self.view.itemsize,
+ */
+ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice));
+
+ /* "View.MemoryView":641
+ *
+ * slice_copy(self, &mslice)
+ * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<<
+ * self.view.itemsize,
+ * flags|PyBUF_C_CONTIGUOUS,
+ */
+ __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 641, __pyx_L1_error)
+ __pyx_v_mslice = __pyx_t_1;
+
+ /* "View.MemoryView":646
+ * self.dtype_is_object)
+ *
+ * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<<
+ *
+ * def copy_fortran(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 646, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":636
+ * return slice_is_contig(mslice[0], 'F', self.view.ndim)
+ *
+ * def copy(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice mslice
+ * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":648
+ * return memoryview_copy_from_slice(self, &mslice)
+ *
+ * def copy_fortran(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice src, dst
+ * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("copy_fortran", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy_fortran", 0))) return NULL;
+ __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) {
+ __Pyx_memviewslice __pyx_v_src;
+ __Pyx_memviewslice __pyx_v_dst;
+ int __pyx_v_flags;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_memviewslice __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("copy_fortran", 0);
+
+ /* "View.MemoryView":650
+ * def copy_fortran(self):
+ * cdef __Pyx_memviewslice src, dst
+ * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<<
+ *
+ * slice_copy(self, &src)
+ */
+ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS));
+
+ /* "View.MemoryView":652
+ * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
+ *
+ * slice_copy(self, &src) # <<<<<<<<<<<<<<
+ * dst = slice_copy_contig(&src, "fortran", self.view.ndim,
+ * self.view.itemsize,
+ */
+ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src));
+
+ /* "View.MemoryView":653
+ *
+ * slice_copy(self, &src)
+ * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<<
+ * self.view.itemsize,
+ * flags|PyBUF_F_CONTIGUOUS,
+ */
+ __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 653, __pyx_L1_error)
+ __pyx_v_dst = __pyx_t_1;
+
+ /* "View.MemoryView":658
+ * self.dtype_is_object)
+ *
+ * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":648
+ * return memoryview_copy_from_slice(self, &mslice)
+ *
+ * def copy_fortran(self): # <<<<<<<<<<<<<<
+ * cdef __Pyx_memviewslice src, dst
+ * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
+ __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+ /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+ __PYX_ERR(1, 2, __pyx_L1_error)
+
+ /* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+ {
+ PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+ PyObject* values[1] = {0};
+ if (__pyx_kwds) {
+ Py_ssize_t kw_args;
+ switch (__pyx_nargs) {
+ case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+ switch (__pyx_nargs) {
+ case 0:
+ if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ const Py_ssize_t kwd_pos_args = __pyx_nargs;
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+ }
+ } else if (unlikely(__pyx_nargs != 1)) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ }
+ __pyx_v___pyx_state = values[0];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v___pyx_state);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+ /* "(tree fragment)":4
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
+ */
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+ __PYX_ERR(1, 4, __pyx_L1_error)
+
+ /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":662
+ *
+ * @cname('__pyx_memoryview_new')
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<<
+ * cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ * result.typeinfo = typeinfo
+ */
+
+static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) {
+ struct __pyx_memoryview_obj *__pyx_v_result = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("memoryview_cwrapper", 0);
+
+ /* "View.MemoryView":663
+ * @cname('__pyx_memoryview_new')
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
+ * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<<
+ * result.typeinfo = typeinfo
+ * return result
+ */
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 663, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_v_o);
+ __Pyx_GIVEREF(__pyx_v_o);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+ __pyx_t_1 = 0;
+ __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "View.MemoryView":664
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
+ * cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ * result.typeinfo = typeinfo # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_v_result->typeinfo = __pyx_v_typeinfo;
+
+ /* "View.MemoryView":665
+ * cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ * result.typeinfo = typeinfo
+ * return result # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_memoryview_check')
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF((PyObject *)__pyx_v_result);
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":662
+ *
+ * @cname('__pyx_memoryview_new')
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<<
+ * cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ * result.typeinfo = typeinfo
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":668
+ *
+ * @cname('__pyx_memoryview_check')
+ * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<<
+ * return isinstance(o, memoryview)
+ *
+ */
+
+static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ __Pyx_RefNannySetupContext("memoryview_check", 0);
+
+ /* "View.MemoryView":669
+ * @cname('__pyx_memoryview_check')
+ * cdef inline bint memoryview_check(object o) noexcept:
+ * return isinstance(o, memoryview) # <<<<<<<<<<<<<<
+ *
+ * cdef tuple _unellipsify(object index, int ndim):
+ */
+ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type);
+ __pyx_r = __pyx_t_1;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":668
+ *
+ * @cname('__pyx_memoryview_check')
+ * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<<
+ * return isinstance(o, memoryview)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":671
+ * return isinstance(o, memoryview)
+ *
+ * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<<
+ * """
+ * Replace all ellipses with full slices and fill incomplete indices with
+ */
+
+static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
+ Py_ssize_t __pyx_v_idx;
+ PyObject *__pyx_v_tup = NULL;
+ PyObject *__pyx_v_result = NULL;
+ int __pyx_v_have_slices;
+ int __pyx_v_seen_ellipsis;
+ PyObject *__pyx_v_item = NULL;
+ Py_ssize_t __pyx_v_nslices;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ Py_ssize_t __pyx_t_4;
+ Py_ssize_t __pyx_t_5;
+ Py_UCS4 __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("_unellipsify", 0);
+
+ /* "View.MemoryView":677
+ * """
+ * cdef Py_ssize_t idx
+ * tup = index if isinstance(index, tuple) else (index,) # <<<<<<<<<<<<<<
+ *
+ * result = [slice(None)] * ndim
+ */
+ __pyx_t_2 = PyTuple_Check(__pyx_v_index);
+ if (__pyx_t_2) {
+ __Pyx_INCREF(((PyObject*)__pyx_v_index));
+ __pyx_t_1 = __pyx_v_index;
+ } else {
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 677, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_v_index);
+ __Pyx_GIVEREF(__pyx_v_index);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index);
+ __pyx_t_1 = __pyx_t_3;
+ __pyx_t_3 = 0;
+ }
+ __pyx_v_tup = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":679
+ * tup = index if isinstance(index, tuple) else (index,)
+ *
+ * result = [slice(None)] * ndim # <<<<<<<<<<<<<<
+ * have_slices = False
+ * seen_ellipsis = False
+ */
+ __pyx_t_1 = PyList_New(1 * ((__pyx_v_ndim<0) ? 0:__pyx_v_ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ { Py_ssize_t __pyx_temp;
+ for (__pyx_temp=0; __pyx_temp < __pyx_v_ndim; __pyx_temp++) {
+ __Pyx_INCREF(__pyx_slice__5);
+ __Pyx_GIVEREF(__pyx_slice__5);
+ PyList_SET_ITEM(__pyx_t_1, __pyx_temp, __pyx_slice__5);
+ }
+ }
+ __pyx_v_result = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "View.MemoryView":680
+ *
+ * result = [slice(None)] * ndim
+ * have_slices = False # <<<<<<<<<<<<<<
+ * seen_ellipsis = False
+ * idx = 0
+ */
+ __pyx_v_have_slices = 0;
+
+ /* "View.MemoryView":681
+ * result = [slice(None)] * ndim
+ * have_slices = False
+ * seen_ellipsis = False # <<<<<<<<<<<<<<
+ * idx = 0
+ * for item in tup:
+ */
+ __pyx_v_seen_ellipsis = 0;
+
+ /* "View.MemoryView":682
+ * have_slices = False
+ * seen_ellipsis = False
+ * idx = 0 # <<<<<<<<<<<<<<
+ * for item in tup:
+ * if item is Ellipsis:
+ */
+ __pyx_v_idx = 0;
+
+ /* "View.MemoryView":683
+ * seen_ellipsis = False
+ * idx = 0
+ * for item in tup: # <<<<<<<<<<<<<<
+ * if item is Ellipsis:
+ * if not seen_ellipsis:
+ */
+ if (unlikely(__pyx_v_tup == Py_None)) {
+ PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+ __PYX_ERR(1, 683, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
+ for (;;) {
+ if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 683, __pyx_L1_error)
+ #else
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 683, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ #endif
+ __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "View.MemoryView":684
+ * idx = 0
+ * for item in tup:
+ * if item is Ellipsis: # <<<<<<<<<<<<<<
+ * if not seen_ellipsis:
+ * idx += ndim - len(tup)
+ */
+ __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":685
+ * for item in tup:
+ * if item is Ellipsis:
+ * if not seen_ellipsis: # <<<<<<<<<<<<<<
+ * idx += ndim - len(tup)
+ * seen_ellipsis = True
+ */
+ __pyx_t_2 = (!__pyx_v_seen_ellipsis);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":686
+ * if item is Ellipsis:
+ * if not seen_ellipsis:
+ * idx += ndim - len(tup) # <<<<<<<<<<<<<<
+ * seen_ellipsis = True
+ * have_slices = True
+ */
+ if (unlikely(__pyx_v_tup == Py_None)) {
+ PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+ __PYX_ERR(1, 686, __pyx_L1_error)
+ }
+ __pyx_t_5 = PyTuple_GET_SIZE(__pyx_v_tup); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 686, __pyx_L1_error)
+ __pyx_v_idx = (__pyx_v_idx + (__pyx_v_ndim - __pyx_t_5));
+
+ /* "View.MemoryView":687
+ * if not seen_ellipsis:
+ * idx += ndim - len(tup)
+ * seen_ellipsis = True # <<<<<<<<<<<<<<
+ * have_slices = True
+ * else:
+ */
+ __pyx_v_seen_ellipsis = 1;
+
+ /* "View.MemoryView":685
+ * for item in tup:
+ * if item is Ellipsis:
+ * if not seen_ellipsis: # <<<<<<<<<<<<<<
+ * idx += ndim - len(tup)
+ * seen_ellipsis = True
+ */
+ }
+
+ /* "View.MemoryView":688
+ * idx += ndim - len(tup)
+ * seen_ellipsis = True
+ * have_slices = True # <<<<<<<<<<<<<<
+ * else:
+ * if isinstance(item, slice):
+ */
+ __pyx_v_have_slices = 1;
+
+ /* "View.MemoryView":684
+ * idx = 0
+ * for item in tup:
+ * if item is Ellipsis: # <<<<<<<<<<<<<<
+ * if not seen_ellipsis:
+ * idx += ndim - len(tup)
+ */
+ goto __pyx_L5;
+ }
+
+ /* "View.MemoryView":690
+ * have_slices = True
+ * else:
+ * if isinstance(item, slice): # <<<<<<<<<<<<<<
+ * have_slices = True
+ * elif not PyIndex_Check(item):
+ */
+ /*else*/ {
+ __pyx_t_2 = PySlice_Check(__pyx_v_item);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":691
+ * else:
+ * if isinstance(item, slice):
+ * have_slices = True # <<<<<<<<<<<<<<
+ * elif not PyIndex_Check(item):
+ * raise TypeError, f"Cannot index with type '{type(item)}'"
+ */
+ __pyx_v_have_slices = 1;
+
+ /* "View.MemoryView":690
+ * have_slices = True
+ * else:
+ * if isinstance(item, slice): # <<<<<<<<<<<<<<
+ * have_slices = True
+ * elif not PyIndex_Check(item):
+ */
+ goto __pyx_L7;
+ }
+
+ /* "View.MemoryView":692
+ * if isinstance(item, slice):
+ * have_slices = True
+ * elif not PyIndex_Check(item): # <<<<<<<<<<<<<<
+ * raise TypeError, f"Cannot index with type '{type(item)}'"
+ * result[idx] = item
+ */
+ __pyx_t_2 = (!(PyIndex_Check(__pyx_v_item) != 0));
+ if (unlikely(__pyx_t_2)) {
+
+ /* "View.MemoryView":693
+ * have_slices = True
+ * elif not PyIndex_Check(item):
+ * raise TypeError, f"Cannot index with type '{type(item)}'" # <<<<<<<<<<<<<<
+ * result[idx] = item
+ * idx += 1
+ */
+ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 693, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = 0;
+ __pyx_t_6 = 127;
+ __Pyx_INCREF(__pyx_kp_u_Cannot_index_with_type);
+ __pyx_t_5 += 24;
+ __Pyx_GIVEREF(__pyx_kp_u_Cannot_index_with_type);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Cannot_index_with_type);
+ __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6;
+ __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7);
+ __pyx_t_7 = 0;
+ __Pyx_INCREF(__pyx_kp_u__6);
+ __pyx_t_5 += 1;
+ __Pyx_GIVEREF(__pyx_kp_u__6);
+ PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__6);
+ __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_t_7, 0, 0);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __PYX_ERR(1, 693, __pyx_L1_error)
+
+ /* "View.MemoryView":692
+ * if isinstance(item, slice):
+ * have_slices = True
+ * elif not PyIndex_Check(item): # <<<<<<<<<<<<<<
+ * raise TypeError, f"Cannot index with type '{type(item)}'"
+ * result[idx] = item
+ */
+ }
+ __pyx_L7:;
+
+ /* "View.MemoryView":694
+ * elif not PyIndex_Check(item):
+ * raise TypeError, f"Cannot index with type '{type(item)}'"
+ * result[idx] = item # <<<<<<<<<<<<<<
+ * idx += 1
+ *
+ */
+ if (unlikely((__Pyx_SetItemInt(__pyx_v_result, __pyx_v_idx, __pyx_v_item, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(1, 694, __pyx_L1_error)
+ }
+ __pyx_L5:;
+
+ /* "View.MemoryView":695
+ * raise TypeError, f"Cannot index with type '{type(item)}'"
+ * result[idx] = item
+ * idx += 1 # <<<<<<<<<<<<<<
+ *
+ * nslices = ndim - idx
+ */
+ __pyx_v_idx = (__pyx_v_idx + 1);
+
+ /* "View.MemoryView":683
+ * seen_ellipsis = False
+ * idx = 0
+ * for item in tup: # <<<<<<<<<<<<<<
+ * if item is Ellipsis:
+ * if not seen_ellipsis:
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "View.MemoryView":697
+ * idx += 1
+ *
+ * nslices = ndim - idx # <<<<<<<<<<<<<<
+ * return have_slices or nslices, tuple(result)
+ *
+ */
+ __pyx_v_nslices = (__pyx_v_ndim - __pyx_v_idx);
+
+ /* "View.MemoryView":698
+ *
+ * nslices = ndim - idx
+ * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<<
+ *
+ * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ if (!__pyx_v_have_slices) {
+ } else {
+ __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_1 = __pyx_t_7;
+ __pyx_t_7 = 0;
+ goto __pyx_L9_bool_binop_done;
+ }
+ __pyx_t_7 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_1 = __pyx_t_7;
+ __pyx_t_7 = 0;
+ __pyx_L9_bool_binop_done:;
+ __pyx_t_7 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7);
+ __pyx_t_1 = 0;
+ __pyx_t_7 = 0;
+ __pyx_r = ((PyObject*)__pyx_t_3);
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":671
+ * return isinstance(o, memoryview)
+ *
+ * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<<
+ * """
+ * Replace all ellipses with full slices and fill incomplete indices with
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_tup);
+ __Pyx_XDECREF(__pyx_v_result);
+ __Pyx_XDECREF(__pyx_v_item);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":700
+ * return have_slices or nslices, tuple(result)
+ *
+ * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<<
+ * for suboffset in suboffsets[:ndim]:
+ * if suboffset >= 0:
+ */
+
+static int assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) {
+ Py_ssize_t __pyx_v_suboffset;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ Py_ssize_t *__pyx_t_1;
+ Py_ssize_t *__pyx_t_2;
+ Py_ssize_t *__pyx_t_3;
+ int __pyx_t_4;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("assert_direct_dimensions", 0);
+
+ /* "View.MemoryView":701
+ *
+ * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1:
+ * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<<
+ * if suboffset >= 0:
+ * raise ValueError, "Indirect dimensions not supported"
+ */
+ __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim);
+ for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) {
+ __pyx_t_1 = __pyx_t_3;
+ __pyx_v_suboffset = (__pyx_t_1[0]);
+
+ /* "View.MemoryView":702
+ * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1:
+ * for suboffset in suboffsets[:ndim]:
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * raise ValueError, "Indirect dimensions not supported"
+ * return 0 # return type just used as an error flag
+ */
+ __pyx_t_4 = (__pyx_v_suboffset >= 0);
+ if (unlikely(__pyx_t_4)) {
+
+ /* "View.MemoryView":703
+ * for suboffset in suboffsets[:ndim]:
+ * if suboffset >= 0:
+ * raise ValueError, "Indirect dimensions not supported" # <<<<<<<<<<<<<<
+ * return 0 # return type just used as an error flag
+ *
+ */
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Indirect_dimensions_not_supporte, 0, 0);
+ __PYX_ERR(1, 703, __pyx_L1_error)
+
+ /* "View.MemoryView":702
+ * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1:
+ * for suboffset in suboffsets[:ndim]:
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * raise ValueError, "Indirect dimensions not supported"
+ * return 0 # return type just used as an error flag
+ */
+ }
+ }
+
+ /* "View.MemoryView":704
+ * if suboffset >= 0:
+ * raise ValueError, "Indirect dimensions not supported"
+ * return 0 # return type just used as an error flag # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":700
+ * return have_slices or nslices, tuple(result)
+ *
+ * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<<
+ * for suboffset in suboffsets[:ndim]:
+ * if suboffset >= 0:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":711
+ *
+ * @cname('__pyx_memview_slice')
+ * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<<
+ * cdef int new_ndim = 0, suboffset_dim = -1, dim
+ * cdef bint negative_step
+ */
+
+static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) {
+ int __pyx_v_new_ndim;
+ int __pyx_v_suboffset_dim;
+ int __pyx_v_dim;
+ __Pyx_memviewslice __pyx_v_src;
+ __Pyx_memviewslice __pyx_v_dst;
+ __Pyx_memviewslice *__pyx_v_p_src;
+ struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0;
+ __Pyx_memviewslice *__pyx_v_p_dst;
+ int *__pyx_v_p_suboffset_dim;
+ Py_ssize_t __pyx_v_start;
+ Py_ssize_t __pyx_v_stop;
+ Py_ssize_t __pyx_v_step;
+ Py_ssize_t __pyx_v_cindex;
+ int __pyx_v_have_start;
+ int __pyx_v_have_stop;
+ int __pyx_v_have_step;
+ PyObject *__pyx_v_index = NULL;
+ struct __pyx_memoryview_obj *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ struct __pyx_memoryview_obj *__pyx_t_3;
+ char *__pyx_t_4;
+ int __pyx_t_5;
+ Py_ssize_t __pyx_t_6;
+ PyObject *(*__pyx_t_7)(PyObject *);
+ PyObject *__pyx_t_8 = NULL;
+ Py_ssize_t __pyx_t_9;
+ int __pyx_t_10;
+ Py_ssize_t __pyx_t_11;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("memview_slice", 0);
+
+ /* "View.MemoryView":712
+ * @cname('__pyx_memview_slice')
+ * cdef memoryview memview_slice(memoryview memview, object indices):
+ * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<<
+ * cdef bint negative_step
+ * cdef __Pyx_memviewslice src, dst
+ */
+ __pyx_v_new_ndim = 0;
+ __pyx_v_suboffset_dim = -1;
+
+ /* "View.MemoryView":719
+ *
+ *
+ * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<<
+ *
+ * cdef _memoryviewslice memviewsliceobj
+ */
+ (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst))));
+
+ /* "View.MemoryView":723
+ * cdef _memoryviewslice memviewsliceobj
+ *
+ * assert memview.view.ndim > 0 # <<<<<<<<<<<<<<
+ *
+ * if isinstance(memview, _memoryviewslice):
+ */
+ #ifndef CYTHON_WITHOUT_ASSERTIONS
+ if (unlikely(__pyx_assertions_enabled())) {
+ __pyx_t_1 = (__pyx_v_memview->view.ndim > 0);
+ if (unlikely(!__pyx_t_1)) {
+ __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
+ __PYX_ERR(1, 723, __pyx_L1_error)
+ }
+ }
+ #else
+ if ((1)); else __PYX_ERR(1, 723, __pyx_L1_error)
+ #endif
+
+ /* "View.MemoryView":725
+ * assert memview.view.ndim > 0
+ *
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * memviewsliceobj = memview
+ * p_src = &memviewsliceobj.from_slice
+ */
+ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":726
+ *
+ * if isinstance(memview, _memoryviewslice):
+ * memviewsliceobj = memview # <<<<<<<<<<<<<<
+ * p_src = &memviewsliceobj.from_slice
+ * else:
+ */
+ if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 726, __pyx_L1_error)
+ __pyx_t_2 = ((PyObject *)__pyx_v_memview);
+ __Pyx_INCREF(__pyx_t_2);
+ __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "View.MemoryView":727
+ * if isinstance(memview, _memoryviewslice):
+ * memviewsliceobj = memview
+ * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<<
+ * else:
+ * slice_copy(memview, &src)
+ */
+ __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice);
+
+ /* "View.MemoryView":725
+ * assert memview.view.ndim > 0
+ *
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * memviewsliceobj = memview
+ * p_src = &memviewsliceobj.from_slice
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":729
+ * p_src = &memviewsliceobj.from_slice
+ * else:
+ * slice_copy(memview, &src) # <<<<<<<<<<<<<<
+ * p_src = &src
+ *
+ */
+ /*else*/ {
+ __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src));
+
+ /* "View.MemoryView":730
+ * else:
+ * slice_copy(memview, &src)
+ * p_src = &src # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_v_p_src = (&__pyx_v_src);
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":736
+ *
+ *
+ * dst.memview = p_src.memview # <<<<<<<<<<<<<<
+ * dst.data = p_src.data
+ *
+ */
+ __pyx_t_3 = __pyx_v_p_src->memview;
+ __pyx_v_dst.memview = __pyx_t_3;
+
+ /* "View.MemoryView":737
+ *
+ * dst.memview = p_src.memview
+ * dst.data = p_src.data # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_4 = __pyx_v_p_src->data;
+ __pyx_v_dst.data = __pyx_t_4;
+
+ /* "View.MemoryView":742
+ *
+ *
+ * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<<
+ * cdef int *p_suboffset_dim = &suboffset_dim
+ * cdef Py_ssize_t start, stop, step, cindex
+ */
+ __pyx_v_p_dst = (&__pyx_v_dst);
+
+ /* "View.MemoryView":743
+ *
+ * cdef __Pyx_memviewslice *p_dst = &dst
+ * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t start, stop, step, cindex
+ * cdef bint have_start, have_stop, have_step
+ */
+ __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim);
+
+ /* "View.MemoryView":747
+ * cdef bint have_start, have_stop, have_step
+ *
+ * for dim, index in enumerate(indices): # <<<<<<<<<<<<<<
+ * if PyIndex_Check(index):
+ * cindex = index
+ */
+ __pyx_t_5 = 0;
+ if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) {
+ __pyx_t_2 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0;
+ __pyx_t_7 = NULL;
+ } else {
+ __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 747, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 747, __pyx_L1_error)
+ }
+ for (;;) {
+ if (likely(!__pyx_t_7)) {
+ if (likely(PyList_CheckExact(__pyx_t_2))) {
+ if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error)
+ #else
+ __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ #endif
+ } else {
+ if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error)
+ #else
+ __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ #endif
+ }
+ } else {
+ __pyx_t_8 = __pyx_t_7(__pyx_t_2);
+ if (unlikely(!__pyx_t_8)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(1, 747, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_8);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_8);
+ __pyx_t_8 = 0;
+ __pyx_v_dim = __pyx_t_5;
+ __pyx_t_5 = (__pyx_t_5 + 1);
+
+ /* "View.MemoryView":748
+ *
+ * for dim, index in enumerate(indices):
+ * if PyIndex_Check(index): # <<<<<<<<<<<<<<
+ * cindex = index
+ * slice_memviewslice(
+ */
+ __pyx_t_1 = (PyIndex_Check(__pyx_v_index) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":749
+ * for dim, index in enumerate(indices):
+ * if PyIndex_Check(index):
+ * cindex = index # <<<<<<<<<<<<<<
+ * slice_memviewslice(
+ * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ */
+ __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 749, __pyx_L1_error)
+ __pyx_v_cindex = __pyx_t_9;
+
+ /* "View.MemoryView":750
+ * if PyIndex_Check(index):
+ * cindex = index
+ * slice_memviewslice( # <<<<<<<<<<<<<<
+ * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ * dim, new_ndim, p_suboffset_dim,
+ */
+ __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_cindex, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error)
+
+ /* "View.MemoryView":748
+ *
+ * for dim, index in enumerate(indices):
+ * if PyIndex_Check(index): # <<<<<<<<<<<<<<
+ * cindex = index
+ * slice_memviewslice(
+ */
+ goto __pyx_L6;
+ }
+
+ /* "View.MemoryView":756
+ * 0, 0, 0, # have_{start,stop,step}
+ * False)
+ * elif index is None: # <<<<<<<<<<<<<<
+ * p_dst.shape[new_ndim] = 1
+ * p_dst.strides[new_ndim] = 0
+ */
+ __pyx_t_1 = (__pyx_v_index == Py_None);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":757
+ * False)
+ * elif index is None:
+ * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<<
+ * p_dst.strides[new_ndim] = 0
+ * p_dst.suboffsets[new_ndim] = -1
+ */
+ (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1;
+
+ /* "View.MemoryView":758
+ * elif index is None:
+ * p_dst.shape[new_ndim] = 1
+ * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<<
+ * p_dst.suboffsets[new_ndim] = -1
+ * new_ndim += 1
+ */
+ (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0;
+
+ /* "View.MemoryView":759
+ * p_dst.shape[new_ndim] = 1
+ * p_dst.strides[new_ndim] = 0
+ * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<<
+ * new_ndim += 1
+ * else:
+ */
+ (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L;
+
+ /* "View.MemoryView":760
+ * p_dst.strides[new_ndim] = 0
+ * p_dst.suboffsets[new_ndim] = -1
+ * new_ndim += 1 # <<<<<<<<<<<<<<
+ * else:
+ * start = index.start or 0
+ */
+ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
+
+ /* "View.MemoryView":756
+ * 0, 0, 0, # have_{start,stop,step}
+ * False)
+ * elif index is None: # <<<<<<<<<<<<<<
+ * p_dst.shape[new_ndim] = 1
+ * p_dst.strides[new_ndim] = 0
+ */
+ goto __pyx_L6;
+ }
+
+ /* "View.MemoryView":762
+ * new_ndim += 1
+ * else:
+ * start = index.start or 0 # <<<<<<<<<<<<<<
+ * stop = index.stop or 0
+ * step = index.step or 0
+ */
+ /*else*/ {
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 762, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 762, __pyx_L1_error)
+ if (!__pyx_t_1) {
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ } else {
+ __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error)
+ __pyx_t_9 = __pyx_t_11;
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ goto __pyx_L7_bool_binop_done;
+ }
+ __pyx_t_9 = 0;
+ __pyx_L7_bool_binop_done:;
+ __pyx_v_start = __pyx_t_9;
+
+ /* "View.MemoryView":763
+ * else:
+ * start = index.start or 0
+ * stop = index.stop or 0 # <<<<<<<<<<<<<<
+ * step = index.step or 0
+ *
+ */
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 763, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 763, __pyx_L1_error)
+ if (!__pyx_t_1) {
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ } else {
+ __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error)
+ __pyx_t_9 = __pyx_t_11;
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ goto __pyx_L9_bool_binop_done;
+ }
+ __pyx_t_9 = 0;
+ __pyx_L9_bool_binop_done:;
+ __pyx_v_stop = __pyx_t_9;
+
+ /* "View.MemoryView":764
+ * start = index.start or 0
+ * stop = index.stop or 0
+ * step = index.step or 0 # <<<<<<<<<<<<<<
+ *
+ * have_start = index.start is not None
+ */
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 764, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 764, __pyx_L1_error)
+ if (!__pyx_t_1) {
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ } else {
+ __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error)
+ __pyx_t_9 = __pyx_t_11;
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ goto __pyx_L11_bool_binop_done;
+ }
+ __pyx_t_9 = 0;
+ __pyx_L11_bool_binop_done:;
+ __pyx_v_step = __pyx_t_9;
+
+ /* "View.MemoryView":766
+ * step = index.step or 0
+ *
+ * have_start = index.start is not None # <<<<<<<<<<<<<<
+ * have_stop = index.stop is not None
+ * have_step = index.step is not None
+ */
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 766, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_1 = (__pyx_t_8 != Py_None);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_v_have_start = __pyx_t_1;
+
+ /* "View.MemoryView":767
+ *
+ * have_start = index.start is not None
+ * have_stop = index.stop is not None # <<<<<<<<<<<<<<
+ * have_step = index.step is not None
+ *
+ */
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 767, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_1 = (__pyx_t_8 != Py_None);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_v_have_stop = __pyx_t_1;
+
+ /* "View.MemoryView":768
+ * have_start = index.start is not None
+ * have_stop = index.stop is not None
+ * have_step = index.step is not None # <<<<<<<<<<<<<<
+ *
+ * slice_memviewslice(
+ */
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 768, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_1 = (__pyx_t_8 != Py_None);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_v_have_step = __pyx_t_1;
+
+ /* "View.MemoryView":770
+ * have_step = index.step is not None
+ *
+ * slice_memviewslice( # <<<<<<<<<<<<<<
+ * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ * dim, new_ndim, p_suboffset_dim,
+ */
+ __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error)
+
+ /* "View.MemoryView":776
+ * have_start, have_stop, have_step,
+ * True)
+ * new_ndim += 1 # <<<<<<<<<<<<<<
+ *
+ * if isinstance(memview, _memoryviewslice):
+ */
+ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
+ }
+ __pyx_L6:;
+
+ /* "View.MemoryView":747
+ * cdef bint have_start, have_stop, have_step
+ *
+ * for dim, index in enumerate(indices): # <<<<<<<<<<<<<<
+ * if PyIndex_Check(index):
+ * cindex = index
+ */
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "View.MemoryView":778
+ * new_ndim += 1
+ *
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * return memoryview_fromslice(dst, new_ndim,
+ * memviewsliceobj.to_object_func,
+ */
+ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":779
+ *
+ * if isinstance(memview, _memoryviewslice):
+ * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<<
+ * memviewsliceobj.to_object_func,
+ * memviewsliceobj.to_dtype_func,
+ */
+ __Pyx_XDECREF((PyObject *)__pyx_r);
+
+ /* "View.MemoryView":780
+ * if isinstance(memview, _memoryviewslice):
+ * return memoryview_fromslice(dst, new_ndim,
+ * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<<
+ * memviewsliceobj.to_dtype_func,
+ * memview.dtype_is_object)
+ */
+ if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) }
+
+ /* "View.MemoryView":781
+ * return memoryview_fromslice(dst, new_ndim,
+ * memviewsliceobj.to_object_func,
+ * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<<
+ * memview.dtype_is_object)
+ * else:
+ */
+ if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) }
+
+ /* "View.MemoryView":779
+ *
+ * if isinstance(memview, _memoryviewslice):
+ * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<<
+ * memviewsliceobj.to_object_func,
+ * memviewsliceobj.to_dtype_func,
+ */
+ __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 779, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":778
+ * new_ndim += 1
+ *
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * return memoryview_fromslice(dst, new_ndim,
+ * memviewsliceobj.to_object_func,
+ */
+ }
+
+ /* "View.MemoryView":784
+ * memview.dtype_is_object)
+ * else:
+ * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<<
+ * memview.dtype_is_object)
+ *
+ */
+ /*else*/ {
+ __Pyx_XDECREF((PyObject *)__pyx_r);
+
+ /* "View.MemoryView":785
+ * else:
+ * return memoryview_fromslice(dst, new_ndim, NULL, NULL,
+ * memview.dtype_is_object) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 784, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "View.MemoryView":784
+ * memview.dtype_is_object)
+ * else:
+ * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<<
+ * memview.dtype_is_object)
+ *
+ */
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+ }
+
+ /* "View.MemoryView":711
+ *
+ * @cname('__pyx_memview_slice')
+ * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<<
+ * cdef int new_ndim = 0, suboffset_dim = -1, dim
+ * cdef bint negative_step
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj);
+ __Pyx_XDECREF(__pyx_v_index);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":793
+ *
+ * @cname('__pyx_memoryview_slice_memviewslice')
+ * cdef int slice_memviewslice( # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *dst,
+ * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
+ */
+
+static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) {
+ Py_ssize_t __pyx_v_new_shape;
+ int __pyx_v_negative_step;
+ int __pyx_r;
+ int __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ #ifdef WITH_THREAD
+ PyGILState_STATE __pyx_gilstate_save;
+ #endif
+
+ /* "View.MemoryView":813
+ * cdef bint negative_step
+ *
+ * if not is_slice: # <<<<<<<<<<<<<<
+ *
+ * if start < 0:
+ */
+ __pyx_t_1 = (!__pyx_v_is_slice);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":815
+ * if not is_slice:
+ *
+ * if start < 0: # <<<<<<<<<<<<<<
+ * start += shape
+ * if not 0 <= start < shape:
+ */
+ __pyx_t_1 = (__pyx_v_start < 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":816
+ *
+ * if start < 0:
+ * start += shape # <<<<<<<<<<<<<<
+ * if not 0 <= start < shape:
+ * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim)
+ */
+ __pyx_v_start = (__pyx_v_start + __pyx_v_shape);
+
+ /* "View.MemoryView":815
+ * if not is_slice:
+ *
+ * if start < 0: # <<<<<<<<<<<<<<
+ * start += shape
+ * if not 0 <= start < shape:
+ */
+ }
+
+ /* "View.MemoryView":817
+ * if start < 0:
+ * start += shape
+ * if not 0 <= start < shape: # <<<<<<<<<<<<<<
+ * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim)
+ * else:
+ */
+ __pyx_t_1 = (0 <= __pyx_v_start);
+ if (__pyx_t_1) {
+ __pyx_t_1 = (__pyx_v_start < __pyx_v_shape);
+ }
+ __pyx_t_2 = (!__pyx_t_1);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":818
+ * start += shape
+ * if not 0 <= start < shape:
+ * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<<
+ * else:
+ *
+ */
+ __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_kp_s_Index_out_of_bounds_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 818, __pyx_L1_error)
+
+ /* "View.MemoryView":817
+ * if start < 0:
+ * start += shape
+ * if not 0 <= start < shape: # <<<<<<<<<<<<<<
+ * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim)
+ * else:
+ */
+ }
+
+ /* "View.MemoryView":813
+ * cdef bint negative_step
+ *
+ * if not is_slice: # <<<<<<<<<<<<<<
+ *
+ * if start < 0:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":821
+ * else:
+ *
+ * if have_step: # <<<<<<<<<<<<<<
+ * negative_step = step < 0
+ * if step == 0:
+ */
+ /*else*/ {
+ __pyx_t_2 = (__pyx_v_have_step != 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":822
+ *
+ * if have_step:
+ * negative_step = step < 0 # <<<<<<<<<<<<<<
+ * if step == 0:
+ * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim)
+ */
+ __pyx_v_negative_step = (__pyx_v_step < 0);
+
+ /* "View.MemoryView":823
+ * if have_step:
+ * negative_step = step < 0
+ * if step == 0: # <<<<<<<<<<<<<<
+ * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim)
+ * else:
+ */
+ __pyx_t_2 = (__pyx_v_step == 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":824
+ * negative_step = step < 0
+ * if step == 0:
+ * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<<
+ * else:
+ * negative_step = False
+ */
+ __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 824, __pyx_L1_error)
+
+ /* "View.MemoryView":823
+ * if have_step:
+ * negative_step = step < 0
+ * if step == 0: # <<<<<<<<<<<<<<
+ * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim)
+ * else:
+ */
+ }
+
+ /* "View.MemoryView":821
+ * else:
+ *
+ * if have_step: # <<<<<<<<<<<<<<
+ * negative_step = step < 0
+ * if step == 0:
+ */
+ goto __pyx_L6;
+ }
+
+ /* "View.MemoryView":826
+ * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim)
+ * else:
+ * negative_step = False # <<<<<<<<<<<<<<
+ * step = 1
+ *
+ */
+ /*else*/ {
+ __pyx_v_negative_step = 0;
+
+ /* "View.MemoryView":827
+ * else:
+ * negative_step = False
+ * step = 1 # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_v_step = 1;
+ }
+ __pyx_L6:;
+
+ /* "View.MemoryView":830
+ *
+ *
+ * if have_start: # <<<<<<<<<<<<<<
+ * if start < 0:
+ * start += shape
+ */
+ __pyx_t_2 = (__pyx_v_have_start != 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":831
+ *
+ * if have_start:
+ * if start < 0: # <<<<<<<<<<<<<<
+ * start += shape
+ * if start < 0:
+ */
+ __pyx_t_2 = (__pyx_v_start < 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":832
+ * if have_start:
+ * if start < 0:
+ * start += shape # <<<<<<<<<<<<<<
+ * if start < 0:
+ * start = 0
+ */
+ __pyx_v_start = (__pyx_v_start + __pyx_v_shape);
+
+ /* "View.MemoryView":833
+ * if start < 0:
+ * start += shape
+ * if start < 0: # <<<<<<<<<<<<<<
+ * start = 0
+ * elif start >= shape:
+ */
+ __pyx_t_2 = (__pyx_v_start < 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":834
+ * start += shape
+ * if start < 0:
+ * start = 0 # <<<<<<<<<<<<<<
+ * elif start >= shape:
+ * if negative_step:
+ */
+ __pyx_v_start = 0;
+
+ /* "View.MemoryView":833
+ * if start < 0:
+ * start += shape
+ * if start < 0: # <<<<<<<<<<<<<<
+ * start = 0
+ * elif start >= shape:
+ */
+ }
+
+ /* "View.MemoryView":831
+ *
+ * if have_start:
+ * if start < 0: # <<<<<<<<<<<<<<
+ * start += shape
+ * if start < 0:
+ */
+ goto __pyx_L9;
+ }
+
+ /* "View.MemoryView":835
+ * if start < 0:
+ * start = 0
+ * elif start >= shape: # <<<<<<<<<<<<<<
+ * if negative_step:
+ * start = shape - 1
+ */
+ __pyx_t_2 = (__pyx_v_start >= __pyx_v_shape);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":836
+ * start = 0
+ * elif start >= shape:
+ * if negative_step: # <<<<<<<<<<<<<<
+ * start = shape - 1
+ * else:
+ */
+ if (__pyx_v_negative_step) {
+
+ /* "View.MemoryView":837
+ * elif start >= shape:
+ * if negative_step:
+ * start = shape - 1 # <<<<<<<<<<<<<<
+ * else:
+ * start = shape
+ */
+ __pyx_v_start = (__pyx_v_shape - 1);
+
+ /* "View.MemoryView":836
+ * start = 0
+ * elif start >= shape:
+ * if negative_step: # <<<<<<<<<<<<<<
+ * start = shape - 1
+ * else:
+ */
+ goto __pyx_L11;
+ }
+
+ /* "View.MemoryView":839
+ * start = shape - 1
+ * else:
+ * start = shape # <<<<<<<<<<<<<<
+ * else:
+ * if negative_step:
+ */
+ /*else*/ {
+ __pyx_v_start = __pyx_v_shape;
+ }
+ __pyx_L11:;
+
+ /* "View.MemoryView":835
+ * if start < 0:
+ * start = 0
+ * elif start >= shape: # <<<<<<<<<<<<<<
+ * if negative_step:
+ * start = shape - 1
+ */
+ }
+ __pyx_L9:;
+
+ /* "View.MemoryView":830
+ *
+ *
+ * if have_start: # <<<<<<<<<<<<<<
+ * if start < 0:
+ * start += shape
+ */
+ goto __pyx_L8;
+ }
+
+ /* "View.MemoryView":841
+ * start = shape
+ * else:
+ * if negative_step: # <<<<<<<<<<<<<<
+ * start = shape - 1
+ * else:
+ */
+ /*else*/ {
+ if (__pyx_v_negative_step) {
+
+ /* "View.MemoryView":842
+ * else:
+ * if negative_step:
+ * start = shape - 1 # <<<<<<<<<<<<<<
+ * else:
+ * start = 0
+ */
+ __pyx_v_start = (__pyx_v_shape - 1);
+
+ /* "View.MemoryView":841
+ * start = shape
+ * else:
+ * if negative_step: # <<<<<<<<<<<<<<
+ * start = shape - 1
+ * else:
+ */
+ goto __pyx_L12;
+ }
+
+ /* "View.MemoryView":844
+ * start = shape - 1
+ * else:
+ * start = 0 # <<<<<<<<<<<<<<
+ *
+ * if have_stop:
+ */
+ /*else*/ {
+ __pyx_v_start = 0;
+ }
+ __pyx_L12:;
+ }
+ __pyx_L8:;
+
+ /* "View.MemoryView":846
+ * start = 0
+ *
+ * if have_stop: # <<<<<<<<<<<<<<
+ * if stop < 0:
+ * stop += shape
+ */
+ __pyx_t_2 = (__pyx_v_have_stop != 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":847
+ *
+ * if have_stop:
+ * if stop < 0: # <<<<<<<<<<<<<<
+ * stop += shape
+ * if stop < 0:
+ */
+ __pyx_t_2 = (__pyx_v_stop < 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":848
+ * if have_stop:
+ * if stop < 0:
+ * stop += shape # <<<<<<<<<<<<<<
+ * if stop < 0:
+ * stop = 0
+ */
+ __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape);
+
+ /* "View.MemoryView":849
+ * if stop < 0:
+ * stop += shape
+ * if stop < 0: # <<<<<<<<<<<<<<
+ * stop = 0
+ * elif stop > shape:
+ */
+ __pyx_t_2 = (__pyx_v_stop < 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":850
+ * stop += shape
+ * if stop < 0:
+ * stop = 0 # <<<<<<<<<<<<<<
+ * elif stop > shape:
+ * stop = shape
+ */
+ __pyx_v_stop = 0;
+
+ /* "View.MemoryView":849
+ * if stop < 0:
+ * stop += shape
+ * if stop < 0: # <<<<<<<<<<<<<<
+ * stop = 0
+ * elif stop > shape:
+ */
+ }
+
+ /* "View.MemoryView":847
+ *
+ * if have_stop:
+ * if stop < 0: # <<<<<<<<<<<<<<
+ * stop += shape
+ * if stop < 0:
+ */
+ goto __pyx_L14;
+ }
+
+ /* "View.MemoryView":851
+ * if stop < 0:
+ * stop = 0
+ * elif stop > shape: # <<<<<<<<<<<<<<
+ * stop = shape
+ * else:
+ */
+ __pyx_t_2 = (__pyx_v_stop > __pyx_v_shape);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":852
+ * stop = 0
+ * elif stop > shape:
+ * stop = shape # <<<<<<<<<<<<<<
+ * else:
+ * if negative_step:
+ */
+ __pyx_v_stop = __pyx_v_shape;
+
+ /* "View.MemoryView":851
+ * if stop < 0:
+ * stop = 0
+ * elif stop > shape: # <<<<<<<<<<<<<<
+ * stop = shape
+ * else:
+ */
+ }
+ __pyx_L14:;
+
+ /* "View.MemoryView":846
+ * start = 0
+ *
+ * if have_stop: # <<<<<<<<<<<<<<
+ * if stop < 0:
+ * stop += shape
+ */
+ goto __pyx_L13;
+ }
+
+ /* "View.MemoryView":854
+ * stop = shape
+ * else:
+ * if negative_step: # <<<<<<<<<<<<<<
+ * stop = -1
+ * else:
+ */
+ /*else*/ {
+ if (__pyx_v_negative_step) {
+
+ /* "View.MemoryView":855
+ * else:
+ * if negative_step:
+ * stop = -1 # <<<<<<<<<<<<<<
+ * else:
+ * stop = shape
+ */
+ __pyx_v_stop = -1L;
+
+ /* "View.MemoryView":854
+ * stop = shape
+ * else:
+ * if negative_step: # <<<<<<<<<<<<<<
+ * stop = -1
+ * else:
+ */
+ goto __pyx_L16;
+ }
+
+ /* "View.MemoryView":857
+ * stop = -1
+ * else:
+ * stop = shape # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ /*else*/ {
+ __pyx_v_stop = __pyx_v_shape;
+ }
+ __pyx_L16:;
+ }
+ __pyx_L13:;
+
+ /* "View.MemoryView":861
+ *
+ * with cython.cdivision(True):
+ * new_shape = (stop - start) // step # <<<<<<<<<<<<<<
+ *
+ * if (stop - start) - step * new_shape:
+ */
+ __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step);
+
+ /* "View.MemoryView":863
+ * new_shape = (stop - start) // step
+ *
+ * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<<
+ * new_shape += 1
+ *
+ */
+ __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":864
+ *
+ * if (stop - start) - step * new_shape:
+ * new_shape += 1 # <<<<<<<<<<<<<<
+ *
+ * if new_shape < 0:
+ */
+ __pyx_v_new_shape = (__pyx_v_new_shape + 1);
+
+ /* "View.MemoryView":863
+ * new_shape = (stop - start) // step
+ *
+ * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<<
+ * new_shape += 1
+ *
+ */
+ }
+
+ /* "View.MemoryView":866
+ * new_shape += 1
+ *
+ * if new_shape < 0: # <<<<<<<<<<<<<<
+ * new_shape = 0
+ *
+ */
+ __pyx_t_2 = (__pyx_v_new_shape < 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":867
+ *
+ * if new_shape < 0:
+ * new_shape = 0 # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_v_new_shape = 0;
+
+ /* "View.MemoryView":866
+ * new_shape += 1
+ *
+ * if new_shape < 0: # <<<<<<<<<<<<<<
+ * new_shape = 0
+ *
+ */
+ }
+
+ /* "View.MemoryView":870
+ *
+ *
+ * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<<
+ * dst.shape[new_ndim] = new_shape
+ * dst.suboffsets[new_ndim] = suboffset
+ */
+ (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step);
+
+ /* "View.MemoryView":871
+ *
+ * dst.strides[new_ndim] = stride * step
+ * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<<
+ * dst.suboffsets[new_ndim] = suboffset
+ *
+ */
+ (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape;
+
+ /* "View.MemoryView":872
+ * dst.strides[new_ndim] = stride * step
+ * dst.shape[new_ndim] = new_shape
+ * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset;
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":875
+ *
+ *
+ * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<<
+ * dst.data += start * stride
+ * else:
+ */
+ __pyx_t_2 = ((__pyx_v_suboffset_dim[0]) < 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":876
+ *
+ * if suboffset_dim[0] < 0:
+ * dst.data += start * stride # <<<<<<<<<<<<<<
+ * else:
+ * dst.suboffsets[suboffset_dim[0]] += start * stride
+ */
+ __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride));
+
+ /* "View.MemoryView":875
+ *
+ *
+ * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<<
+ * dst.data += start * stride
+ * else:
+ */
+ goto __pyx_L19;
+ }
+
+ /* "View.MemoryView":878
+ * dst.data += start * stride
+ * else:
+ * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<<
+ *
+ * if suboffset >= 0:
+ */
+ /*else*/ {
+ __pyx_t_3 = (__pyx_v_suboffset_dim[0]);
+ (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride));
+ }
+ __pyx_L19:;
+
+ /* "View.MemoryView":880
+ * dst.suboffsets[suboffset_dim[0]] += start * stride
+ *
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * if not is_slice:
+ * if new_ndim == 0:
+ */
+ __pyx_t_2 = (__pyx_v_suboffset >= 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":881
+ *
+ * if suboffset >= 0:
+ * if not is_slice: # <<<<<<<<<<<<<<
+ * if new_ndim == 0:
+ * dst.data = ( dst.data)[0] + suboffset
+ */
+ __pyx_t_2 = (!__pyx_v_is_slice);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":882
+ * if suboffset >= 0:
+ * if not is_slice:
+ * if new_ndim == 0: # <<<<<<<<<<<<<<
+ * dst.data = ( dst.data)[0] + suboffset
+ * else:
+ */
+ __pyx_t_2 = (__pyx_v_new_ndim == 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":883
+ * if not is_slice:
+ * if new_ndim == 0:
+ * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<<
+ * else:
+ * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d "
+ */
+ __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset);
+
+ /* "View.MemoryView":882
+ * if suboffset >= 0:
+ * if not is_slice:
+ * if new_ndim == 0: # <<<<<<<<<<<<<<
+ * dst.data = ( dst.data)[0] + suboffset
+ * else:
+ */
+ goto __pyx_L22;
+ }
+
+ /* "View.MemoryView":885
+ * dst.data = ( dst.data)[0] + suboffset
+ * else:
+ * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<<
+ * "must be indexed and not sliced", dim)
+ * else:
+ */
+ /*else*/ {
+
+ /* "View.MemoryView":886
+ * else:
+ * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d "
+ * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<<
+ * else:
+ * suboffset_dim[0] = new_ndim
+ */
+ __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 885, __pyx_L1_error)
+ }
+ __pyx_L22:;
+
+ /* "View.MemoryView":881
+ *
+ * if suboffset >= 0:
+ * if not is_slice: # <<<<<<<<<<<<<<
+ * if new_ndim == 0:
+ * dst.data = ( dst.data)[0] + suboffset
+ */
+ goto __pyx_L21;
+ }
+
+ /* "View.MemoryView":888
+ * "must be indexed and not sliced", dim)
+ * else:
+ * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<<
+ *
+ * return 0
+ */
+ /*else*/ {
+ (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim;
+ }
+ __pyx_L21:;
+
+ /* "View.MemoryView":880
+ * dst.suboffsets[suboffset_dim[0]] += start * stride
+ *
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * if not is_slice:
+ * if new_ndim == 0:
+ */
+ }
+
+ /* "View.MemoryView":890
+ * suboffset_dim[0] = new_ndim
+ *
+ * return 0 # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":793
+ *
+ * @cname('__pyx_memoryview_slice_memviewslice')
+ * cdef int slice_memviewslice( # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *dst,
+ * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ #ifdef WITH_THREAD
+ __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+ #endif
+ __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ #ifdef WITH_THREAD
+ __Pyx_PyGILState_Release(__pyx_gilstate_save);
+ #endif
+ __pyx_L0:;
+ return __pyx_r;
+}
+
+/* "View.MemoryView":896
+ *
+ * @cname('__pyx_pybuffer_index')
+ * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<<
+ * Py_ssize_t dim) except NULL:
+ * cdef Py_ssize_t shape, stride, suboffset = -1
+ */
+
+static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) {
+ Py_ssize_t __pyx_v_shape;
+ Py_ssize_t __pyx_v_stride;
+ Py_ssize_t __pyx_v_suboffset;
+ Py_ssize_t __pyx_v_itemsize;
+ char *__pyx_v_resultp;
+ char *__pyx_r;
+ __Pyx_RefNannyDeclarations
+ Py_ssize_t __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ Py_UCS4 __pyx_t_4;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("pybuffer_index", 0);
+
+ /* "View.MemoryView":898
+ * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,
+ * Py_ssize_t dim) except NULL:
+ * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t itemsize = view.itemsize
+ * cdef char *resultp
+ */
+ __pyx_v_suboffset = -1L;
+
+ /* "View.MemoryView":899
+ * Py_ssize_t dim) except NULL:
+ * cdef Py_ssize_t shape, stride, suboffset = -1
+ * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<<
+ * cdef char *resultp
+ *
+ */
+ __pyx_t_1 = __pyx_v_view->itemsize;
+ __pyx_v_itemsize = __pyx_t_1;
+
+ /* "View.MemoryView":902
+ * cdef char *resultp
+ *
+ * if view.ndim == 0: # <<<<<<<<<<<<<<
+ * shape = view.len // itemsize
+ * stride = itemsize
+ */
+ __pyx_t_2 = (__pyx_v_view->ndim == 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":903
+ *
+ * if view.ndim == 0:
+ * shape = view.len // itemsize # <<<<<<<<<<<<<<
+ * stride = itemsize
+ * else:
+ */
+ if (unlikely(__pyx_v_itemsize == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
+ __PYX_ERR(1, 903, __pyx_L1_error)
+ }
+ else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) {
+ PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
+ __PYX_ERR(1, 903, __pyx_L1_error)
+ }
+ __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize);
+
+ /* "View.MemoryView":904
+ * if view.ndim == 0:
+ * shape = view.len // itemsize
+ * stride = itemsize # <<<<<<<<<<<<<<
+ * else:
+ * shape = view.shape[dim]
+ */
+ __pyx_v_stride = __pyx_v_itemsize;
+
+ /* "View.MemoryView":902
+ * cdef char *resultp
+ *
+ * if view.ndim == 0: # <<<<<<<<<<<<<<
+ * shape = view.len // itemsize
+ * stride = itemsize
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":906
+ * stride = itemsize
+ * else:
+ * shape = view.shape[dim] # <<<<<<<<<<<<<<
+ * stride = view.strides[dim]
+ * if view.suboffsets != NULL:
+ */
+ /*else*/ {
+ __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]);
+
+ /* "View.MemoryView":907
+ * else:
+ * shape = view.shape[dim]
+ * stride = view.strides[dim] # <<<<<<<<<<<<<<
+ * if view.suboffsets != NULL:
+ * suboffset = view.suboffsets[dim]
+ */
+ __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]);
+
+ /* "View.MemoryView":908
+ * shape = view.shape[dim]
+ * stride = view.strides[dim]
+ * if view.suboffsets != NULL: # <<<<<<<<<<<<<<
+ * suboffset = view.suboffsets[dim]
+ *
+ */
+ __pyx_t_2 = (__pyx_v_view->suboffsets != NULL);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":909
+ * stride = view.strides[dim]
+ * if view.suboffsets != NULL:
+ * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<<
+ *
+ * if index < 0:
+ */
+ __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]);
+
+ /* "View.MemoryView":908
+ * shape = view.shape[dim]
+ * stride = view.strides[dim]
+ * if view.suboffsets != NULL: # <<<<<<<<<<<<<<
+ * suboffset = view.suboffsets[dim]
+ *
+ */
+ }
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":911
+ * suboffset = view.suboffsets[dim]
+ *
+ * if index < 0: # <<<<<<<<<<<<<<
+ * index += view.shape[dim]
+ * if index < 0:
+ */
+ __pyx_t_2 = (__pyx_v_index < 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":912
+ *
+ * if index < 0:
+ * index += view.shape[dim] # <<<<<<<<<<<<<<
+ * if index < 0:
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ */
+ __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim]));
+
+ /* "View.MemoryView":913
+ * if index < 0:
+ * index += view.shape[dim]
+ * if index < 0: # <<<<<<<<<<<<<<
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ *
+ */
+ __pyx_t_2 = (__pyx_v_index < 0);
+ if (unlikely(__pyx_t_2)) {
+
+ /* "View.MemoryView":914
+ * index += view.shape[dim]
+ * if index < 0:
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<<
+ *
+ * if index >= shape:
+ */
+ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 914, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_1 = 0;
+ __pyx_t_4 = 127;
+ __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ __pyx_t_1 += 37;
+ __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __Pyx_INCREF(__pyx_kp_u__7);
+ __pyx_t_1 += 1;
+ __Pyx_GIVEREF(__pyx_kp_u__7);
+ PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__7);
+ __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_5, 0, 0);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __PYX_ERR(1, 914, __pyx_L1_error)
+
+ /* "View.MemoryView":913
+ * if index < 0:
+ * index += view.shape[dim]
+ * if index < 0: # <<<<<<<<<<<<<<
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ *
+ */
+ }
+
+ /* "View.MemoryView":911
+ * suboffset = view.suboffsets[dim]
+ *
+ * if index < 0: # <<<<<<<<<<<<<<
+ * index += view.shape[dim]
+ * if index < 0:
+ */
+ }
+
+ /* "View.MemoryView":916
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ *
+ * if index >= shape: # <<<<<<<<<<<<<<
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ *
+ */
+ __pyx_t_2 = (__pyx_v_index >= __pyx_v_shape);
+ if (unlikely(__pyx_t_2)) {
+
+ /* "View.MemoryView":917
+ *
+ * if index >= shape:
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<<
+ *
+ * resultp = bufp + index * stride
+ */
+ __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 917, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_1 = 0;
+ __pyx_t_4 = 127;
+ __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ __pyx_t_1 += 37;
+ __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a);
+ __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __Pyx_INCREF(__pyx_kp_u__7);
+ __pyx_t_1 += 1;
+ __Pyx_GIVEREF(__pyx_kp_u__7);
+ PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u__7);
+ __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_5, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_3, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(1, 917, __pyx_L1_error)
+
+ /* "View.MemoryView":916
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ *
+ * if index >= shape: # <<<<<<<<<<<<<<
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ *
+ */
+ }
+
+ /* "View.MemoryView":919
+ * raise IndexError, f"Out of bounds on buffer access (axis {dim})"
+ *
+ * resultp = bufp + index * stride # <<<<<<<<<<<<<<
+ * if suboffset >= 0:
+ * resultp = ( resultp)[0] + suboffset
+ */
+ __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride));
+
+ /* "View.MemoryView":920
+ *
+ * resultp = bufp + index * stride
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * resultp = ( resultp)[0] + suboffset
+ *
+ */
+ __pyx_t_2 = (__pyx_v_suboffset >= 0);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":921
+ * resultp = bufp + index * stride
+ * if suboffset >= 0:
+ * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<<
+ *
+ * return resultp
+ */
+ __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset);
+
+ /* "View.MemoryView":920
+ *
+ * resultp = bufp + index * stride
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * resultp = ( resultp)[0] + suboffset
+ *
+ */
+ }
+
+ /* "View.MemoryView":923
+ * resultp = ( resultp)[0] + suboffset
+ *
+ * return resultp # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_resultp;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":896
+ *
+ * @cname('__pyx_pybuffer_index')
+ * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<<
+ * Py_ssize_t dim) except NULL:
+ * cdef Py_ssize_t shape, stride, suboffset = -1
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":929
+ *
+ * @cname('__pyx_memslice_transpose')
+ * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<<
+ * cdef int ndim = memslice.memview.view.ndim
+ *
+ */
+
+static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) {
+ int __pyx_v_ndim;
+ Py_ssize_t *__pyx_v_shape;
+ Py_ssize_t *__pyx_v_strides;
+ int __pyx_v_i;
+ int __pyx_v_j;
+ int __pyx_r;
+ int __pyx_t_1;
+ Py_ssize_t *__pyx_t_2;
+ long __pyx_t_3;
+ long __pyx_t_4;
+ Py_ssize_t __pyx_t_5;
+ Py_ssize_t __pyx_t_6;
+ int __pyx_t_7;
+ int __pyx_t_8;
+ int __pyx_t_9;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ #ifdef WITH_THREAD
+ PyGILState_STATE __pyx_gilstate_save;
+ #endif
+
+ /* "View.MemoryView":930
+ * @cname('__pyx_memslice_transpose')
+ * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil:
+ * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<<
+ *
+ * cdef Py_ssize_t *shape = memslice.shape
+ */
+ __pyx_t_1 = __pyx_v_memslice->memview->view.ndim;
+ __pyx_v_ndim = __pyx_t_1;
+
+ /* "View.MemoryView":932
+ * cdef int ndim = memslice.memview.view.ndim
+ *
+ * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t *strides = memslice.strides
+ *
+ */
+ __pyx_t_2 = __pyx_v_memslice->shape;
+ __pyx_v_shape = __pyx_t_2;
+
+ /* "View.MemoryView":933
+ *
+ * cdef Py_ssize_t *shape = memslice.shape
+ * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_2 = __pyx_v_memslice->strides;
+ __pyx_v_strides = __pyx_t_2;
+
+ /* "View.MemoryView":937
+ *
+ * cdef int i, j
+ * for i in range(ndim // 2): # <<<<<<<<<<<<<<
+ * j = ndim - 1 - i
+ * strides[i], strides[j] = strides[j], strides[i]
+ */
+ __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2);
+ __pyx_t_4 = __pyx_t_3;
+ for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) {
+ __pyx_v_i = __pyx_t_1;
+
+ /* "View.MemoryView":938
+ * cdef int i, j
+ * for i in range(ndim // 2):
+ * j = ndim - 1 - i # <<<<<<<<<<<<<<
+ * strides[i], strides[j] = strides[j], strides[i]
+ * shape[i], shape[j] = shape[j], shape[i]
+ */
+ __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i);
+
+ /* "View.MemoryView":939
+ * for i in range(ndim // 2):
+ * j = ndim - 1 - i
+ * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<<
+ * shape[i], shape[j] = shape[j], shape[i]
+ *
+ */
+ __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]);
+ __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]);
+ (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5;
+ (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6;
+
+ /* "View.MemoryView":940
+ * j = ndim - 1 - i
+ * strides[i], strides[j] = strides[j], strides[i]
+ * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<<
+ *
+ * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
+ */
+ __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]);
+ __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]);
+ (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6;
+ (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5;
+
+ /* "View.MemoryView":942
+ * shape[i], shape[j] = shape[j], shape[i]
+ *
+ * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<<
+ * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions")
+ *
+ */
+ __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0);
+ if (!__pyx_t_8) {
+ } else {
+ __pyx_t_7 = __pyx_t_8;
+ goto __pyx_L6_bool_binop_done;
+ }
+ __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0);
+ __pyx_t_7 = __pyx_t_8;
+ __pyx_L6_bool_binop_done:;
+ if (__pyx_t_7) {
+
+ /* "View.MemoryView":943
+ *
+ * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
+ * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<<
+ *
+ * return 0
+ */
+ __pyx_t_9 = __pyx_memoryview_err(PyExc_ValueError, __pyx_kp_s_Cannot_transpose_memoryview_with); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L1_error)
+
+ /* "View.MemoryView":942
+ * shape[i], shape[j] = shape[j], shape[i]
+ *
+ * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<<
+ * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions")
+ *
+ */
+ }
+ }
+
+ /* "View.MemoryView":945
+ * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions")
+ *
+ * return 0 # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":929
+ *
+ * @cname('__pyx_memslice_transpose')
+ * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<<
+ * cdef int ndim = memslice.memview.view.ndim
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ #ifdef WITH_THREAD
+ __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+ #endif
+ __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ #ifdef WITH_THREAD
+ __Pyx_PyGILState_Release(__pyx_gilstate_save);
+ #endif
+ __pyx_L0:;
+ return __pyx_r;
+}
+
+/* "View.MemoryView":963
+ * cdef int (*to_dtype_func)(char *, object) except 0
+ *
+ * def __dealloc__(self): # <<<<<<<<<<<<<<
+ * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1)
+ *
+ */
+
+/* Python wrapper */
+static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) {
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+ __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+ /* "View.MemoryView":964
+ *
+ * def __dealloc__(self):
+ * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<<
+ *
+ * cdef convert_item_to_object(self, char *itemp):
+ */
+ __PYX_XCLEAR_MEMVIEW((&__pyx_v_self->from_slice), 1);
+
+ /* "View.MemoryView":963
+ * cdef int (*to_dtype_func)(char *, object) except 0
+ *
+ * def __dealloc__(self): # <<<<<<<<<<<<<<
+ * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1)
+ *
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":966
+ * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1)
+ *
+ * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
+ * if self.to_object_func != NULL:
+ * return self.to_object_func(itemp)
+ */
+
+static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("convert_item_to_object", 0);
+
+ /* "View.MemoryView":967
+ *
+ * cdef convert_item_to_object(self, char *itemp):
+ * if self.to_object_func != NULL: # <<<<<<<<<<<<<<
+ * return self.to_object_func(itemp)
+ * else:
+ */
+ __pyx_t_1 = (__pyx_v_self->to_object_func != NULL);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":968
+ * cdef convert_item_to_object(self, char *itemp):
+ * if self.to_object_func != NULL:
+ * return self.to_object_func(itemp) # <<<<<<<<<<<<<<
+ * else:
+ * return memoryview.convert_item_to_object(self, itemp)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 968, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":967
+ *
+ * cdef convert_item_to_object(self, char *itemp):
+ * if self.to_object_func != NULL: # <<<<<<<<<<<<<<
+ * return self.to_object_func(itemp)
+ * else:
+ */
+ }
+
+ /* "View.MemoryView":970
+ * return self.to_object_func(itemp)
+ * else:
+ * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<<
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value):
+ */
+ /*else*/ {
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 970, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+ }
+
+ /* "View.MemoryView":966
+ * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1)
+ *
+ * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
+ * if self.to_object_func != NULL:
+ * return self.to_object_func(itemp)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":972
+ * return memoryview.convert_item_to_object(self, itemp)
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
+ * if self.to_dtype_func != NULL:
+ * self.to_dtype_func(itemp, value)
+ */
+
+static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("assign_item_from_object", 0);
+
+ /* "View.MemoryView":973
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value):
+ * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<<
+ * self.to_dtype_func(itemp, value)
+ * else:
+ */
+ __pyx_t_1 = (__pyx_v_self->to_dtype_func != NULL);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":974
+ * cdef assign_item_from_object(self, char *itemp, object value):
+ * if self.to_dtype_func != NULL:
+ * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<<
+ * else:
+ * memoryview.assign_item_from_object(self, itemp, value)
+ */
+ __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 974, __pyx_L1_error)
+
+ /* "View.MemoryView":973
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value):
+ * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<<
+ * self.to_dtype_func(itemp, value)
+ * else:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":976
+ * self.to_dtype_func(itemp, value)
+ * else:
+ * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<<
+ *
+ * cdef _get_base(self):
+ */
+ /*else*/ {
+ __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 976, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":972
+ * return memoryview.convert_item_to_object(self, itemp)
+ *
+ * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
+ * if self.to_dtype_func != NULL:
+ * self.to_dtype_func(itemp, value)
+ */
+
+ /* function exit code */
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":978
+ * memoryview.assign_item_from_object(self, itemp, value)
+ *
+ * cdef _get_base(self): # <<<<<<<<<<<<<<
+ * return self.from_object
+ *
+ */
+
+static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_get_base", 0);
+
+ /* "View.MemoryView":979
+ *
+ * cdef _get_base(self):
+ * return self.from_object # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_self->from_object);
+ __pyx_r = __pyx_v_self->from_object;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":978
+ * memoryview.assign_item_from_object(self, itemp, value)
+ *
+ * cdef _get_base(self): # <<<<<<<<<<<<<<
+ * return self.from_object
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+ if (unlikely(__pyx_nargs > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+ if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
+ __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+ /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+ __PYX_ERR(1, 2, __pyx_L1_error)
+
+ /* "(tree fragment)":1
+ * def __reduce_cython__(self): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self,
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+ CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+ #if !CYTHON_METH_FASTCALL
+ CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+ #endif
+ CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+ {
+ PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+ PyObject* values[1] = {0};
+ if (__pyx_kwds) {
+ Py_ssize_t kw_args;
+ switch (__pyx_nargs) {
+ case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+ switch (__pyx_nargs) {
+ case 0:
+ if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--;
+ else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ const Py_ssize_t kwd_pos_args = __pyx_nargs;
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+ }
+ } else if (unlikely(__pyx_nargs != 1)) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+ }
+ __pyx_v___pyx_state = values[0];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), __pyx_v___pyx_state);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+ /* "(tree fragment)":4
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
+ */
+ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+ __PYX_ERR(1, 4, __pyx_L1_error)
+
+ /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
+ * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":999
+ *
+ * @cname('__pyx_memoryview_fromslice')
+ * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<<
+ * int ndim,
+ * object (*to_object_func)(char *),
+ */
+
+static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) {
+ struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
+ Py_ssize_t __pyx_v_suboffset;
+ PyObject *__pyx_v_length = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_TypeInfo *__pyx_t_4;
+ Py_buffer __pyx_t_5;
+ Py_ssize_t *__pyx_t_6;
+ Py_ssize_t *__pyx_t_7;
+ Py_ssize_t *__pyx_t_8;
+ Py_ssize_t __pyx_t_9;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("memoryview_fromslice", 0);
+
+ /* "View.MemoryView":1007
+ * cdef _memoryviewslice result
+ *
+ * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<<
+ * return None
+ *
+ */
+ __pyx_t_1 = (((PyObject *)__pyx_v_memviewslice.memview) == Py_None);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1008
+ *
+ * if memviewslice.memview == Py_None:
+ * return None # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1007
+ * cdef _memoryviewslice result
+ *
+ * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<<
+ * return None
+ *
+ */
+ }
+
+ /* "View.MemoryView":1013
+ *
+ *
+ * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) # <<<<<<<<<<<<<<
+ *
+ * result.from_slice = memviewslice
+ */
+ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(Py_None);
+ __Pyx_GIVEREF(Py_None);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+ __pyx_t_2 = 0;
+ __pyx_t_2 = ((PyObject *)__pyx_tp_new__memoryviewslice(((PyTypeObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error)
+ __Pyx_GOTREF((PyObject *)__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "View.MemoryView":1015
+ * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object)
+ *
+ * result.from_slice = memviewslice # <<<<<<<<<<<<<<
+ * __PYX_INC_MEMVIEW(&memviewslice, 1)
+ *
+ */
+ __pyx_v_result->from_slice = __pyx_v_memviewslice;
+
+ /* "View.MemoryView":1016
+ *
+ * result.from_slice = memviewslice
+ * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<<
+ *
+ * result.from_object = ( memviewslice.memview)._get_base()
+ */
+ __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1);
+
+ /* "View.MemoryView":1018
+ * __PYX_INC_MEMVIEW(&memviewslice, 1)
+ *
+ * result.from_object = ( memviewslice.memview)._get_base() # <<<<<<<<<<<<<<
+ * result.typeinfo = memviewslice.memview.typeinfo
+ *
+ */
+ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->__pyx_vtab)->_get_base(((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1018, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_GIVEREF(__pyx_t_2);
+ __Pyx_GOTREF(__pyx_v_result->from_object);
+ __Pyx_DECREF(__pyx_v_result->from_object);
+ __pyx_v_result->from_object = __pyx_t_2;
+ __pyx_t_2 = 0;
+
+ /* "View.MemoryView":1019
+ *
+ * result.from_object = ( memviewslice.memview)._get_base()
+ * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<<
+ *
+ * result.view = memviewslice.memview.view
+ */
+ __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo;
+ __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4;
+
+ /* "View.MemoryView":1021
+ * result.typeinfo = memviewslice.memview.typeinfo
+ *
+ * result.view = memviewslice.memview.view # <<<<<<<<<<<<<<
+ * result.view.buf = memviewslice.data
+ * result.view.ndim = ndim
+ */
+ __pyx_t_5 = __pyx_v_memviewslice.memview->view;
+ __pyx_v_result->__pyx_base.view = __pyx_t_5;
+
+ /* "View.MemoryView":1022
+ *
+ * result.view = memviewslice.memview.view
+ * result.view.buf = memviewslice.data # <<<<<<<<<<<<<<
+ * result.view.ndim = ndim
+ * (<__pyx_buffer *> &result.view).obj = Py_None
+ */
+ __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data);
+
+ /* "View.MemoryView":1023
+ * result.view = memviewslice.memview.view
+ * result.view.buf = memviewslice.data
+ * result.view.ndim = ndim # <<<<<<<<<<<<<<
+ * (<__pyx_buffer *> &result.view).obj = Py_None
+ * Py_INCREF(Py_None)
+ */
+ __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim;
+
+ /* "View.MemoryView":1024
+ * result.view.buf = memviewslice.data
+ * result.view.ndim = ndim
+ * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<<
+ * Py_INCREF(Py_None)
+ *
+ */
+ ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None;
+
+ /* "View.MemoryView":1025
+ * result.view.ndim = ndim
+ * (<__pyx_buffer *> &result.view).obj = Py_None
+ * Py_INCREF(Py_None) # <<<<<<<<<<<<<<
+ *
+ * if (memviewslice.memview).flags & PyBUF_WRITABLE:
+ */
+ Py_INCREF(Py_None);
+
+ /* "View.MemoryView":1027
+ * Py_INCREF(Py_None)
+ *
+ * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<<
+ * result.flags = PyBUF_RECORDS
+ * else:
+ */
+ __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1028
+ *
+ * if (memviewslice.memview).flags & PyBUF_WRITABLE:
+ * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<<
+ * else:
+ * result.flags = PyBUF_RECORDS_RO
+ */
+ __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS;
+
+ /* "View.MemoryView":1027
+ * Py_INCREF(Py_None)
+ *
+ * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<<
+ * result.flags = PyBUF_RECORDS
+ * else:
+ */
+ goto __pyx_L4;
+ }
+
+ /* "View.MemoryView":1030
+ * result.flags = PyBUF_RECORDS
+ * else:
+ * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<<
+ *
+ * result.view.shape = result.from_slice.shape
+ */
+ /*else*/ {
+ __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO;
+ }
+ __pyx_L4:;
+
+ /* "View.MemoryView":1032
+ * result.flags = PyBUF_RECORDS_RO
+ *
+ * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<<
+ * result.view.strides = result.from_slice.strides
+ *
+ */
+ __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape);
+
+ /* "View.MemoryView":1033
+ *
+ * result.view.shape = result.from_slice.shape
+ * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides);
+
+ /* "View.MemoryView":1036
+ *
+ *
+ * result.view.suboffsets = NULL # <<<<<<<<<<<<<<
+ * for suboffset in result.from_slice.suboffsets[:ndim]:
+ * if suboffset >= 0:
+ */
+ __pyx_v_result->__pyx_base.view.suboffsets = NULL;
+
+ /* "View.MemoryView":1037
+ *
+ * result.view.suboffsets = NULL
+ * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<<
+ * if suboffset >= 0:
+ * result.view.suboffsets = result.from_slice.suboffsets
+ */
+ __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim);
+ for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
+ __pyx_t_6 = __pyx_t_8;
+ __pyx_v_suboffset = (__pyx_t_6[0]);
+
+ /* "View.MemoryView":1038
+ * result.view.suboffsets = NULL
+ * for suboffset in result.from_slice.suboffsets[:ndim]:
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * result.view.suboffsets = result.from_slice.suboffsets
+ * break
+ */
+ __pyx_t_1 = (__pyx_v_suboffset >= 0);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1039
+ * for suboffset in result.from_slice.suboffsets[:ndim]:
+ * if suboffset >= 0:
+ * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<<
+ * break
+ *
+ */
+ __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets);
+
+ /* "View.MemoryView":1040
+ * if suboffset >= 0:
+ * result.view.suboffsets = result.from_slice.suboffsets
+ * break # <<<<<<<<<<<<<<
+ *
+ * result.view.len = result.view.itemsize
+ */
+ goto __pyx_L6_break;
+
+ /* "View.MemoryView":1038
+ * result.view.suboffsets = NULL
+ * for suboffset in result.from_slice.suboffsets[:ndim]:
+ * if suboffset >= 0: # <<<<<<<<<<<<<<
+ * result.view.suboffsets = result.from_slice.suboffsets
+ * break
+ */
+ }
+ }
+ __pyx_L6_break:;
+
+ /* "View.MemoryView":1042
+ * break
+ *
+ * result.view.len = result.view.itemsize # <<<<<<<<<<<<<<
+ * for length in result.view.shape[:ndim]:
+ * result.view.len *= length
+ */
+ __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize;
+ __pyx_v_result->__pyx_base.view.len = __pyx_t_9;
+
+ /* "View.MemoryView":1043
+ *
+ * result.view.len = result.view.itemsize
+ * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<<
+ * result.view.len *= length
+ *
+ */
+ __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim);
+ for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
+ __pyx_t_6 = __pyx_t_8;
+ __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1043, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "View.MemoryView":1044
+ * result.view.len = result.view.itemsize
+ * for length in result.view.shape[:ndim]:
+ * result.view.len *= length # <<<<<<<<<<<<<<
+ *
+ * result.to_object_func = to_object_func
+ */
+ __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1044, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1044, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1044, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_v_result->__pyx_base.view.len = __pyx_t_9;
+ }
+
+ /* "View.MemoryView":1046
+ * result.view.len *= length
+ *
+ * result.to_object_func = to_object_func # <<<<<<<<<<<<<<
+ * result.to_dtype_func = to_dtype_func
+ *
+ */
+ __pyx_v_result->to_object_func = __pyx_v_to_object_func;
+
+ /* "View.MemoryView":1047
+ *
+ * result.to_object_func = to_object_func
+ * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<<
+ *
+ * return result
+ */
+ __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func;
+
+ /* "View.MemoryView":1049
+ * result.to_dtype_func = to_dtype_func
+ *
+ * return result # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_memoryview_get_slice_from_memoryview')
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF((PyObject *)__pyx_v_result);
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":999
+ *
+ * @cname('__pyx_memoryview_fromslice')
+ * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<<
+ * int ndim,
+ * object (*to_object_func)(char *),
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XDECREF(__pyx_v_length);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1052
+ *
+ * @cname('__pyx_memoryview_get_slice_from_memoryview')
+ * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *mslice) except NULL:
+ * cdef _memoryviewslice obj
+ */
+
+static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) {
+ struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0;
+ __Pyx_memviewslice *__pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("get_slice_from_memview", 0);
+
+ /* "View.MemoryView":1055
+ * __Pyx_memviewslice *mslice) except NULL:
+ * cdef _memoryviewslice obj
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * obj = memview
+ * return &obj.from_slice
+ */
+ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1056
+ * cdef _memoryviewslice obj
+ * if isinstance(memview, _memoryviewslice):
+ * obj = memview # <<<<<<<<<<<<<<
+ * return &obj.from_slice
+ * else:
+ */
+ if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1056, __pyx_L1_error)
+ __pyx_t_2 = ((PyObject *)__pyx_v_memview);
+ __Pyx_INCREF(__pyx_t_2);
+ __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "View.MemoryView":1057
+ * if isinstance(memview, _memoryviewslice):
+ * obj = memview
+ * return &obj.from_slice # <<<<<<<<<<<<<<
+ * else:
+ * slice_copy(memview, mslice)
+ */
+ __pyx_r = (&__pyx_v_obj->from_slice);
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1055
+ * __Pyx_memviewslice *mslice) except NULL:
+ * cdef _memoryviewslice obj
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * obj = memview
+ * return &obj.from_slice
+ */
+ }
+
+ /* "View.MemoryView":1059
+ * return &obj.from_slice
+ * else:
+ * slice_copy(memview, mslice) # <<<<<<<<<<<<<<
+ * return mslice
+ *
+ */
+ /*else*/ {
+ __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice);
+
+ /* "View.MemoryView":1060
+ * else:
+ * slice_copy(memview, mslice)
+ * return mslice # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_memoryview_slice_copy')
+ */
+ __pyx_r = __pyx_v_mslice;
+ goto __pyx_L0;
+ }
+
+ /* "View.MemoryView":1052
+ *
+ * @cname('__pyx_memoryview_get_slice_from_memoryview')
+ * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *mslice) except NULL:
+ * cdef _memoryviewslice obj
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_obj);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1063
+ *
+ * @cname('__pyx_memoryview_slice_copy')
+ * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<<
+ * cdef int dim
+ * cdef (Py_ssize_t*) shape, strides, suboffsets
+ */
+
+static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) {
+ int __pyx_v_dim;
+ Py_ssize_t *__pyx_v_shape;
+ Py_ssize_t *__pyx_v_strides;
+ Py_ssize_t *__pyx_v_suboffsets;
+ __Pyx_RefNannyDeclarations
+ Py_ssize_t *__pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ int __pyx_t_4;
+ Py_ssize_t __pyx_t_5;
+ __Pyx_RefNannySetupContext("slice_copy", 0);
+
+ /* "View.MemoryView":1067
+ * cdef (Py_ssize_t*) shape, strides, suboffsets
+ *
+ * shape = memview.view.shape # <<<<<<<<<<<<<<
+ * strides = memview.view.strides
+ * suboffsets = memview.view.suboffsets
+ */
+ __pyx_t_1 = __pyx_v_memview->view.shape;
+ __pyx_v_shape = __pyx_t_1;
+
+ /* "View.MemoryView":1068
+ *
+ * shape = memview.view.shape
+ * strides = memview.view.strides # <<<<<<<<<<<<<<
+ * suboffsets = memview.view.suboffsets
+ *
+ */
+ __pyx_t_1 = __pyx_v_memview->view.strides;
+ __pyx_v_strides = __pyx_t_1;
+
+ /* "View.MemoryView":1069
+ * shape = memview.view.shape
+ * strides = memview.view.strides
+ * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<<
+ *
+ * dst.memview = <__pyx_memoryview *> memview
+ */
+ __pyx_t_1 = __pyx_v_memview->view.suboffsets;
+ __pyx_v_suboffsets = __pyx_t_1;
+
+ /* "View.MemoryView":1071
+ * suboffsets = memview.view.suboffsets
+ *
+ * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<<
+ * dst.data = memview.view.buf
+ *
+ */
+ __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview);
+
+ /* "View.MemoryView":1072
+ *
+ * dst.memview = <__pyx_memoryview *> memview
+ * dst.data = memview.view.buf # <<<<<<<<<<<<<<
+ *
+ * for dim in range(memview.view.ndim):
+ */
+ __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf);
+
+ /* "View.MemoryView":1074
+ * dst.data = memview.view.buf
+ *
+ * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<<
+ * dst.shape[dim] = shape[dim]
+ * dst.strides[dim] = strides[dim]
+ */
+ __pyx_t_2 = __pyx_v_memview->view.ndim;
+ __pyx_t_3 = __pyx_t_2;
+ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+ __pyx_v_dim = __pyx_t_4;
+
+ /* "View.MemoryView":1075
+ *
+ * for dim in range(memview.view.ndim):
+ * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<<
+ * dst.strides[dim] = strides[dim]
+ * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
+ */
+ (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]);
+
+ /* "View.MemoryView":1076
+ * for dim in range(memview.view.ndim):
+ * dst.shape[dim] = shape[dim]
+ * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<<
+ * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
+ *
+ */
+ (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]);
+
+ /* "View.MemoryView":1077
+ * dst.shape[dim] = shape[dim]
+ * dst.strides[dim] = strides[dim]
+ * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_memoryview_copy_object')
+ */
+ if ((__pyx_v_suboffsets != 0)) {
+ __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]);
+ } else {
+ __pyx_t_5 = -1L;
+ }
+ (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5;
+ }
+
+ /* "View.MemoryView":1063
+ *
+ * @cname('__pyx_memoryview_slice_copy')
+ * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<<
+ * cdef int dim
+ * cdef (Py_ssize_t*) shape, strides, suboffsets
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":1080
+ *
+ * @cname('__pyx_memoryview_copy_object')
+ * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<<
+ * "Create a new memoryview object"
+ * cdef __Pyx_memviewslice memviewslice
+ */
+
+static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) {
+ __Pyx_memviewslice __pyx_v_memviewslice;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("memoryview_copy", 0);
+
+ /* "View.MemoryView":1083
+ * "Create a new memoryview object"
+ * cdef __Pyx_memviewslice memviewslice
+ * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<<
+ * return memoryview_copy_from_slice(memview, &memviewslice)
+ *
+ */
+ __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice));
+
+ /* "View.MemoryView":1084
+ * cdef __Pyx_memviewslice memviewslice
+ * slice_copy(memview, &memviewslice)
+ * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_memoryview_copy_object_from_slice')
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1084, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1080
+ *
+ * @cname('__pyx_memoryview_copy_object')
+ * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<<
+ * "Create a new memoryview object"
+ * cdef __Pyx_memviewslice memviewslice
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1087
+ *
+ * @cname('__pyx_memoryview_copy_object_from_slice')
+ * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<<
+ * """
+ * Create a new memoryview object from a given memoryview object and slice.
+ */
+
+static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) {
+ PyObject *(*__pyx_v_to_object_func)(char *);
+ int (*__pyx_v_to_dtype_func)(char *, PyObject *);
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *(*__pyx_t_2)(char *);
+ int (*__pyx_t_3)(char *, PyObject *);
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0);
+
+ /* "View.MemoryView":1094
+ * cdef int (*to_dtype_func)(char *, object) except 0
+ *
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * to_object_func = (<_memoryviewslice> memview).to_object_func
+ * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ */
+ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1095
+ *
+ * if isinstance(memview, _memoryviewslice):
+ * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<<
+ * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ * else:
+ */
+ __pyx_t_2 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func;
+ __pyx_v_to_object_func = __pyx_t_2;
+
+ /* "View.MemoryView":1096
+ * if isinstance(memview, _memoryviewslice):
+ * to_object_func = (<_memoryviewslice> memview).to_object_func
+ * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<<
+ * else:
+ * to_object_func = NULL
+ */
+ __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func;
+ __pyx_v_to_dtype_func = __pyx_t_3;
+
+ /* "View.MemoryView":1094
+ * cdef int (*to_dtype_func)(char *, object) except 0
+ *
+ * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<<
+ * to_object_func = (<_memoryviewslice> memview).to_object_func
+ * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":1098
+ * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ * else:
+ * to_object_func = NULL # <<<<<<<<<<<<<<
+ * to_dtype_func = NULL
+ *
+ */
+ /*else*/ {
+ __pyx_v_to_object_func = NULL;
+
+ /* "View.MemoryView":1099
+ * else:
+ * to_object_func = NULL
+ * to_dtype_func = NULL # <<<<<<<<<<<<<<
+ *
+ * return memoryview_fromslice(memviewslice[0], memview.view.ndim,
+ */
+ __pyx_v_to_dtype_func = NULL;
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":1101
+ * to_dtype_func = NULL
+ *
+ * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<<
+ * to_object_func, to_dtype_func,
+ * memview.dtype_is_object)
+ */
+ __Pyx_XDECREF(__pyx_r);
+
+ /* "View.MemoryView":1103
+ * return memoryview_fromslice(memviewslice[0], memview.view.ndim,
+ * to_object_func, to_dtype_func,
+ * memview.dtype_is_object) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_4 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1101, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_r = __pyx_t_4;
+ __pyx_t_4 = 0;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1087
+ *
+ * @cname('__pyx_memoryview_copy_object_from_slice')
+ * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<<
+ * """
+ * Create a new memoryview object from a given memoryview object and slice.
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1109
+ *
+ *
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<<
+ * return -arg if arg < 0 else arg
+ *
+ */
+
+static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) {
+ Py_ssize_t __pyx_r;
+ Py_ssize_t __pyx_t_1;
+
+ /* "View.MemoryView":1110
+ *
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil:
+ * return -arg if arg < 0 else arg # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_get_best_slice_order')
+ */
+ if ((__pyx_v_arg < 0)) {
+ __pyx_t_1 = (-__pyx_v_arg);
+ } else {
+ __pyx_t_1 = __pyx_v_arg;
+ }
+ __pyx_r = __pyx_t_1;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1109
+ *
+ *
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<<
+ * return -arg if arg < 0 else arg
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1113
+ *
+ * @cname('__pyx_get_best_slice_order')
+ * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<<
+ * """
+ * Figure out the best memory access order for a given slice.
+ */
+
+static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) {
+ int __pyx_v_i;
+ Py_ssize_t __pyx_v_c_stride;
+ Py_ssize_t __pyx_v_f_stride;
+ char __pyx_r;
+ int __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ int __pyx_t_4;
+
+ /* "View.MemoryView":1118
+ * """
+ * cdef int i
+ * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t f_stride = 0
+ *
+ */
+ __pyx_v_c_stride = 0;
+
+ /* "View.MemoryView":1119
+ * cdef int i
+ * cdef Py_ssize_t c_stride = 0
+ * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<<
+ *
+ * for i in range(ndim - 1, -1, -1):
+ */
+ __pyx_v_f_stride = 0;
+
+ /* "View.MemoryView":1121
+ * cdef Py_ssize_t f_stride = 0
+ *
+ * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<<
+ * if mslice.shape[i] > 1:
+ * c_stride = mslice.strides[i]
+ */
+ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
+ __pyx_v_i = __pyx_t_1;
+
+ /* "View.MemoryView":1122
+ *
+ * for i in range(ndim - 1, -1, -1):
+ * if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
+ * c_stride = mslice.strides[i]
+ * break
+ */
+ __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":1123
+ * for i in range(ndim - 1, -1, -1):
+ * if mslice.shape[i] > 1:
+ * c_stride = mslice.strides[i] # <<<<<<<<<<<<<<
+ * break
+ *
+ */
+ __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
+
+ /* "View.MemoryView":1124
+ * if mslice.shape[i] > 1:
+ * c_stride = mslice.strides[i]
+ * break # <<<<<<<<<<<<<<
+ *
+ * for i in range(ndim):
+ */
+ goto __pyx_L4_break;
+
+ /* "View.MemoryView":1122
+ *
+ * for i in range(ndim - 1, -1, -1):
+ * if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
+ * c_stride = mslice.strides[i]
+ * break
+ */
+ }
+ }
+ __pyx_L4_break:;
+
+ /* "View.MemoryView":1126
+ * break
+ *
+ * for i in range(ndim): # <<<<<<<<<<<<<<
+ * if mslice.shape[i] > 1:
+ * f_stride = mslice.strides[i]
+ */
+ __pyx_t_1 = __pyx_v_ndim;
+ __pyx_t_3 = __pyx_t_1;
+ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+ __pyx_v_i = __pyx_t_4;
+
+ /* "View.MemoryView":1127
+ *
+ * for i in range(ndim):
+ * if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
+ * f_stride = mslice.strides[i]
+ * break
+ */
+ __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":1128
+ * for i in range(ndim):
+ * if mslice.shape[i] > 1:
+ * f_stride = mslice.strides[i] # <<<<<<<<<<<<<<
+ * break
+ *
+ */
+ __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
+
+ /* "View.MemoryView":1129
+ * if mslice.shape[i] > 1:
+ * f_stride = mslice.strides[i]
+ * break # <<<<<<<<<<<<<<
+ *
+ * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
+ */
+ goto __pyx_L7_break;
+
+ /* "View.MemoryView":1127
+ *
+ * for i in range(ndim):
+ * if mslice.shape[i] > 1: # <<<<<<<<<<<<<<
+ * f_stride = mslice.strides[i]
+ * break
+ */
+ }
+ }
+ __pyx_L7_break:;
+
+ /* "View.MemoryView":1131
+ * break
+ *
+ * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<<
+ * return 'C'
+ * else:
+ */
+ __pyx_t_2 = (abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride));
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":1132
+ *
+ * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
+ * return 'C' # <<<<<<<<<<<<<<
+ * else:
+ * return 'F'
+ */
+ __pyx_r = 'C';
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1131
+ * break
+ *
+ * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<<
+ * return 'C'
+ * else:
+ */
+ }
+
+ /* "View.MemoryView":1134
+ * return 'C'
+ * else:
+ * return 'F' # <<<<<<<<<<<<<<
+ *
+ * @cython.cdivision(True)
+ */
+ /*else*/ {
+ __pyx_r = 'F';
+ goto __pyx_L0;
+ }
+
+ /* "View.MemoryView":1113
+ *
+ * @cname('__pyx_get_best_slice_order')
+ * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<<
+ * """
+ * Figure out the best memory access order for a given slice.
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1137
+ *
+ * @cython.cdivision(True)
+ * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<<
+ * char *dst_data, Py_ssize_t *dst_strides,
+ * Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
+ */
+
+static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
+ CYTHON_UNUSED Py_ssize_t __pyx_v_i;
+ CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent;
+ Py_ssize_t __pyx_v_dst_extent;
+ Py_ssize_t __pyx_v_src_stride;
+ Py_ssize_t __pyx_v_dst_stride;
+ int __pyx_t_1;
+ int __pyx_t_2;
+ Py_ssize_t __pyx_t_3;
+ Py_ssize_t __pyx_t_4;
+ Py_ssize_t __pyx_t_5;
+
+ /* "View.MemoryView":1144
+ *
+ * cdef Py_ssize_t i
+ * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t dst_extent = dst_shape[0]
+ * cdef Py_ssize_t src_stride = src_strides[0]
+ */
+ __pyx_v_src_extent = (__pyx_v_src_shape[0]);
+
+ /* "View.MemoryView":1145
+ * cdef Py_ssize_t i
+ * cdef Py_ssize_t src_extent = src_shape[0]
+ * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t src_stride = src_strides[0]
+ * cdef Py_ssize_t dst_stride = dst_strides[0]
+ */
+ __pyx_v_dst_extent = (__pyx_v_dst_shape[0]);
+
+ /* "View.MemoryView":1146
+ * cdef Py_ssize_t src_extent = src_shape[0]
+ * cdef Py_ssize_t dst_extent = dst_shape[0]
+ * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t dst_stride = dst_strides[0]
+ *
+ */
+ __pyx_v_src_stride = (__pyx_v_src_strides[0]);
+
+ /* "View.MemoryView":1147
+ * cdef Py_ssize_t dst_extent = dst_shape[0]
+ * cdef Py_ssize_t src_stride = src_strides[0]
+ * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<<
+ *
+ * if ndim == 1:
+ */
+ __pyx_v_dst_stride = (__pyx_v_dst_strides[0]);
+
+ /* "View.MemoryView":1149
+ * cdef Py_ssize_t dst_stride = dst_strides[0]
+ *
+ * if ndim == 1: # <<<<<<<<<<<<<<
+ * if (src_stride > 0 and dst_stride > 0 and
+ * src_stride == itemsize == dst_stride):
+ */
+ __pyx_t_1 = (__pyx_v_ndim == 1);
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1150
+ *
+ * if ndim == 1:
+ * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<<
+ * src_stride == itemsize == dst_stride):
+ * memcpy(dst_data, src_data, itemsize * dst_extent)
+ */
+ __pyx_t_2 = (__pyx_v_src_stride > 0);
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L5_bool_binop_done;
+ }
+ __pyx_t_2 = (__pyx_v_dst_stride > 0);
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L5_bool_binop_done;
+ }
+
+ /* "View.MemoryView":1151
+ * if ndim == 1:
+ * if (src_stride > 0 and dst_stride > 0 and
+ * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<<
+ * memcpy(dst_data, src_data, itemsize * dst_extent)
+ * else:
+ */
+ __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize);
+ if (__pyx_t_2) {
+ __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride));
+ }
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L5_bool_binop_done:;
+
+ /* "View.MemoryView":1150
+ *
+ * if ndim == 1:
+ * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<<
+ * src_stride == itemsize == dst_stride):
+ * memcpy(dst_data, src_data, itemsize * dst_extent)
+ */
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1152
+ * if (src_stride > 0 and dst_stride > 0 and
+ * src_stride == itemsize == dst_stride):
+ * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<<
+ * else:
+ * for i in range(dst_extent):
+ */
+ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent)));
+
+ /* "View.MemoryView":1150
+ *
+ * if ndim == 1:
+ * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<<
+ * src_stride == itemsize == dst_stride):
+ * memcpy(dst_data, src_data, itemsize * dst_extent)
+ */
+ goto __pyx_L4;
+ }
+
+ /* "View.MemoryView":1154
+ * memcpy(dst_data, src_data, itemsize * dst_extent)
+ * else:
+ * for i in range(dst_extent): # <<<<<<<<<<<<<<
+ * memcpy(dst_data, src_data, itemsize)
+ * src_data += src_stride
+ */
+ /*else*/ {
+ __pyx_t_3 = __pyx_v_dst_extent;
+ __pyx_t_4 = __pyx_t_3;
+ for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+ __pyx_v_i = __pyx_t_5;
+
+ /* "View.MemoryView":1155
+ * else:
+ * for i in range(dst_extent):
+ * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<<
+ * src_data += src_stride
+ * dst_data += dst_stride
+ */
+ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize));
+
+ /* "View.MemoryView":1156
+ * for i in range(dst_extent):
+ * memcpy(dst_data, src_data, itemsize)
+ * src_data += src_stride # <<<<<<<<<<<<<<
+ * dst_data += dst_stride
+ * else:
+ */
+ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
+
+ /* "View.MemoryView":1157
+ * memcpy(dst_data, src_data, itemsize)
+ * src_data += src_stride
+ * dst_data += dst_stride # <<<<<<<<<<<<<<
+ * else:
+ * for i in range(dst_extent):
+ */
+ __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
+ }
+ }
+ __pyx_L4:;
+
+ /* "View.MemoryView":1149
+ * cdef Py_ssize_t dst_stride = dst_strides[0]
+ *
+ * if ndim == 1: # <<<<<<<<<<<<<<
+ * if (src_stride > 0 and dst_stride > 0 and
+ * src_stride == itemsize == dst_stride):
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":1159
+ * dst_data += dst_stride
+ * else:
+ * for i in range(dst_extent): # <<<<<<<<<<<<<<
+ * _copy_strided_to_strided(src_data, src_strides + 1,
+ * dst_data, dst_strides + 1,
+ */
+ /*else*/ {
+ __pyx_t_3 = __pyx_v_dst_extent;
+ __pyx_t_4 = __pyx_t_3;
+ for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+ __pyx_v_i = __pyx_t_5;
+
+ /* "View.MemoryView":1160
+ * else:
+ * for i in range(dst_extent):
+ * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<<
+ * dst_data, dst_strides + 1,
+ * src_shape + 1, dst_shape + 1,
+ */
+ _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize);
+
+ /* "View.MemoryView":1164
+ * src_shape + 1, dst_shape + 1,
+ * ndim - 1, itemsize)
+ * src_data += src_stride # <<<<<<<<<<<<<<
+ * dst_data += dst_stride
+ *
+ */
+ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
+
+ /* "View.MemoryView":1165
+ * ndim - 1, itemsize)
+ * src_data += src_stride
+ * dst_data += dst_stride # <<<<<<<<<<<<<<
+ *
+ * cdef void copy_strided_to_strided(__Pyx_memviewslice *src,
+ */
+ __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
+ }
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":1137
+ *
+ * @cython.cdivision(True)
+ * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<<
+ * char *dst_data, Py_ssize_t *dst_strides,
+ * Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
+ */
+
+ /* function exit code */
+}
+
+/* "View.MemoryView":1167
+ * dst_data += dst_stride
+ *
+ * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *dst,
+ * int ndim, size_t itemsize) noexcept nogil:
+ */
+
+static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
+
+ /* "View.MemoryView":1170
+ * __Pyx_memviewslice *dst,
+ * int ndim, size_t itemsize) noexcept nogil:
+ * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<<
+ * src.shape, dst.shape, ndim, itemsize)
+ *
+ */
+ _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize);
+
+ /* "View.MemoryView":1167
+ * dst_data += dst_stride
+ *
+ * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *dst,
+ * int ndim, size_t itemsize) noexcept nogil:
+ */
+
+ /* function exit code */
+}
+
+/* "View.MemoryView":1174
+ *
+ * @cname('__pyx_memoryview_slice_get_size')
+ * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: # <<<<<<<<<<<<<<
+ * "Return the size of the memory occupied by the slice in number of bytes"
+ * cdef Py_ssize_t shape, size = src.memview.view.itemsize
+ */
+
+static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) {
+ Py_ssize_t __pyx_v_shape;
+ Py_ssize_t __pyx_v_size;
+ Py_ssize_t __pyx_r;
+ Py_ssize_t __pyx_t_1;
+ Py_ssize_t *__pyx_t_2;
+ Py_ssize_t *__pyx_t_3;
+ Py_ssize_t *__pyx_t_4;
+
+ /* "View.MemoryView":1176
+ * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil:
+ * "Return the size of the memory occupied by the slice in number of bytes"
+ * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<<
+ *
+ * for shape in src.shape[:ndim]:
+ */
+ __pyx_t_1 = __pyx_v_src->memview->view.itemsize;
+ __pyx_v_size = __pyx_t_1;
+
+ /* "View.MemoryView":1178
+ * cdef Py_ssize_t shape, size = src.memview.view.itemsize
+ *
+ * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<<
+ * size *= shape
+ *
+ */
+ __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim);
+ for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
+ __pyx_t_2 = __pyx_t_4;
+ __pyx_v_shape = (__pyx_t_2[0]);
+
+ /* "View.MemoryView":1179
+ *
+ * for shape in src.shape[:ndim]:
+ * size *= shape # <<<<<<<<<<<<<<
+ *
+ * return size
+ */
+ __pyx_v_size = (__pyx_v_size * __pyx_v_shape);
+ }
+
+ /* "View.MemoryView":1181
+ * size *= shape
+ *
+ * return size # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_fill_contig_strides_array')
+ */
+ __pyx_r = __pyx_v_size;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1174
+ *
+ * @cname('__pyx_memoryview_slice_get_size')
+ * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: # <<<<<<<<<<<<<<
+ * "Return the size of the memory occupied by the slice in number of bytes"
+ * cdef Py_ssize_t shape, size = src.memview.view.itemsize
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1184
+ *
+ * @cname('__pyx_fill_contig_strides_array')
+ * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<<
+ * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
+ * int ndim, char order) noexcept nogil:
+ */
+
+static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) {
+ int __pyx_v_idx;
+ Py_ssize_t __pyx_r;
+ int __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ int __pyx_t_4;
+
+ /* "View.MemoryView":1193
+ * cdef int idx
+ *
+ * if order == 'F': # <<<<<<<<<<<<<<
+ * for idx in range(ndim):
+ * strides[idx] = stride
+ */
+ __pyx_t_1 = (__pyx_v_order == 'F');
+ if (__pyx_t_1) {
+
+ /* "View.MemoryView":1194
+ *
+ * if order == 'F':
+ * for idx in range(ndim): # <<<<<<<<<<<<<<
+ * strides[idx] = stride
+ * stride *= shape[idx]
+ */
+ __pyx_t_2 = __pyx_v_ndim;
+ __pyx_t_3 = __pyx_t_2;
+ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+ __pyx_v_idx = __pyx_t_4;
+
+ /* "View.MemoryView":1195
+ * if order == 'F':
+ * for idx in range(ndim):
+ * strides[idx] = stride # <<<<<<<<<<<<<<
+ * stride *= shape[idx]
+ * else:
+ */
+ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
+
+ /* "View.MemoryView":1196
+ * for idx in range(ndim):
+ * strides[idx] = stride
+ * stride *= shape[idx] # <<<<<<<<<<<<<<
+ * else:
+ * for idx in range(ndim - 1, -1, -1):
+ */
+ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
+ }
+
+ /* "View.MemoryView":1193
+ * cdef int idx
+ *
+ * if order == 'F': # <<<<<<<<<<<<<<
+ * for idx in range(ndim):
+ * strides[idx] = stride
+ */
+ goto __pyx_L3;
+ }
+
+ /* "View.MemoryView":1198
+ * stride *= shape[idx]
+ * else:
+ * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<<
+ * strides[idx] = stride
+ * stride *= shape[idx]
+ */
+ /*else*/ {
+ for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) {
+ __pyx_v_idx = __pyx_t_2;
+
+ /* "View.MemoryView":1199
+ * else:
+ * for idx in range(ndim - 1, -1, -1):
+ * strides[idx] = stride # <<<<<<<<<<<<<<
+ * stride *= shape[idx]
+ *
+ */
+ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
+
+ /* "View.MemoryView":1200
+ * for idx in range(ndim - 1, -1, -1):
+ * strides[idx] = stride
+ * stride *= shape[idx] # <<<<<<<<<<<<<<
+ *
+ * return stride
+ */
+ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
+ }
+ }
+ __pyx_L3:;
+
+ /* "View.MemoryView":1202
+ * stride *= shape[idx]
+ *
+ * return stride # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_memoryview_copy_data_to_temp')
+ */
+ __pyx_r = __pyx_v_stride;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1184
+ *
+ * @cname('__pyx_fill_contig_strides_array')
+ * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<<
+ * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
+ * int ndim, char order) noexcept nogil:
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1205
+ *
+ * @cname('__pyx_memoryview_copy_data_to_temp')
+ * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *tmpslice,
+ * char order,
+ */
+
+static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) {
+ int __pyx_v_i;
+ void *__pyx_v_result;
+ size_t __pyx_v_itemsize;
+ size_t __pyx_v_size;
+ void *__pyx_r;
+ Py_ssize_t __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ struct __pyx_memoryview_obj *__pyx_t_4;
+ int __pyx_t_5;
+ int __pyx_t_6;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ #ifdef WITH_THREAD
+ PyGILState_STATE __pyx_gilstate_save;
+ #endif
+
+ /* "View.MemoryView":1216
+ * cdef void *result
+ *
+ * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<<
+ * cdef size_t size = slice_get_size(src, ndim)
+ *
+ */
+ __pyx_t_1 = __pyx_v_src->memview->view.itemsize;
+ __pyx_v_itemsize = __pyx_t_1;
+
+ /* "View.MemoryView":1217
+ *
+ * cdef size_t itemsize = src.memview.view.itemsize
+ * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<<
+ *
+ * result = malloc(size)
+ */
+ __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim);
+
+ /* "View.MemoryView":1219
+ * cdef size_t size = slice_get_size(src, ndim)
+ *
+ * result = malloc(size) # <<<<<<<<<<<<<<
+ * if not result:
+ * _err_no_memory()
+ */
+ __pyx_v_result = malloc(__pyx_v_size);
+
+ /* "View.MemoryView":1220
+ *
+ * result = malloc(size)
+ * if not result: # <<<<<<<<<<<<<<
+ * _err_no_memory()
+ *
+ */
+ __pyx_t_2 = (!(__pyx_v_result != 0));
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":1221
+ * result = malloc(size)
+ * if not result:
+ * _err_no_memory() # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_3 = __pyx_memoryview_err_no_memory(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1221, __pyx_L1_error)
+
+ /* "View.MemoryView":1220
+ *
+ * result = malloc(size)
+ * if not result: # <<<<<<<<<<<<<<
+ * _err_no_memory()
+ *
+ */
+ }
+
+ /* "View.MemoryView":1224
+ *
+ *
+ * tmpslice.data = result # <<<<<<<<<<<<<<
+ * tmpslice.memview = src.memview
+ * for i in range(ndim):
+ */
+ __pyx_v_tmpslice->data = ((char *)__pyx_v_result);
+
+ /* "View.MemoryView":1225
+ *
+ * tmpslice.data = result
+ * tmpslice.memview = src.memview # <<<<<<<<<<<<<<
+ * for i in range(ndim):
+ * tmpslice.shape[i] = src.shape[i]
+ */
+ __pyx_t_4 = __pyx_v_src->memview;
+ __pyx_v_tmpslice->memview = __pyx_t_4;
+
+ /* "View.MemoryView":1226
+ * tmpslice.data = result
+ * tmpslice.memview = src.memview
+ * for i in range(ndim): # <<<<<<<<<<<<<<
+ * tmpslice.shape[i] = src.shape[i]
+ * tmpslice.suboffsets[i] = -1
+ */
+ __pyx_t_3 = __pyx_v_ndim;
+ __pyx_t_5 = __pyx_t_3;
+ for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+ __pyx_v_i = __pyx_t_6;
+
+ /* "View.MemoryView":1227
+ * tmpslice.memview = src.memview
+ * for i in range(ndim):
+ * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<<
+ * tmpslice.suboffsets[i] = -1
+ *
+ */
+ (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]);
+
+ /* "View.MemoryView":1228
+ * for i in range(ndim):
+ * tmpslice.shape[i] = src.shape[i]
+ * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<<
+ *
+ * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order)
+ */
+ (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L;
+ }
+
+ /* "View.MemoryView":1230
+ * tmpslice.suboffsets[i] = -1
+ *
+ * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order));
+
+ /* "View.MemoryView":1233
+ *
+ *
+ * for i in range(ndim): # <<<<<<<<<<<<<<
+ * if tmpslice.shape[i] == 1:
+ * tmpslice.strides[i] = 0
+ */
+ __pyx_t_3 = __pyx_v_ndim;
+ __pyx_t_5 = __pyx_t_3;
+ for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+ __pyx_v_i = __pyx_t_6;
+
+ /* "View.MemoryView":1234
+ *
+ * for i in range(ndim):
+ * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<<
+ * tmpslice.strides[i] = 0
+ *
+ */
+ __pyx_t_2 = ((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":1235
+ * for i in range(ndim):
+ * if tmpslice.shape[i] == 1:
+ * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<<
+ *
+ * if slice_is_contig(src[0], order, ndim):
+ */
+ (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0;
+
+ /* "View.MemoryView":1234
+ *
+ * for i in range(ndim):
+ * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<<
+ * tmpslice.strides[i] = 0
+ *
+ */
+ }
+ }
+
+ /* "View.MemoryView":1237
+ * tmpslice.strides[i] = 0
+ *
+ * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<<
+ * memcpy(result, src.data, size)
+ * else:
+ */
+ __pyx_t_2 = __pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim);
+ if (__pyx_t_2) {
+
+ /* "View.MemoryView":1238
+ *
+ * if slice_is_contig(src[0], order, ndim):
+ * memcpy(result, src.data, size) # <<<<<<<<<<<<<<
+ * else:
+ * copy_strided_to_strided(src, tmpslice, ndim, itemsize)
+ */
+ (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size));
+
+ /* "View.MemoryView":1237
+ * tmpslice.strides[i] = 0
+ *
+ * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<<
+ * memcpy(result, src.data, size)
+ * else:
+ */
+ goto __pyx_L9;
+ }
+
+ /* "View.MemoryView":1240
+ * memcpy(result, src.data, size)
+ * else:
+ * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<<
+ *
+ * return result
+ */
+ /*else*/ {
+ copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize);
+ }
+ __pyx_L9:;
+
+ /* "View.MemoryView":1242
+ * copy_strided_to_strided(src, tmpslice, ndim, itemsize)
+ *
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "View.MemoryView":1205
+ *
+ * @cname('__pyx_memoryview_copy_data_to_temp')
+ * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<<
+ * __Pyx_memviewslice *tmpslice,
+ * char order,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ #ifdef WITH_THREAD
+ __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+ #endif
+ __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ #ifdef WITH_THREAD
+ __Pyx_PyGILState_Release(__pyx_gilstate_save);
+ #endif
+ __pyx_L0:;
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1247
+ *
+ * @cname('__pyx_memoryview_err_extents')
+ * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<<
+ * Py_ssize_t extent2) except -1 with gil:
+ * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})"
+ */
+
+static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ Py_ssize_t __pyx_t_2;
+ Py_UCS4 __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_lineno = 0;
+ const char *__pyx_filename = NULL;
+ int __pyx_clineno = 0;
+ #ifdef WITH_THREAD
+ PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+ #endif
+ __Pyx_RefNannySetupContext("_err_extents", 0);
+
+ /* "View.MemoryView":1249
+ * cdef int _err_extents(int i, Py_ssize_t extent1,
+ * Py_ssize_t extent2) except -1 with gil:
+ * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" # <<<<<<<<<<<<<<
+ *
+ * @cname('__pyx_memoryview_err_dim')
+ */
+ __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1249, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = 0;
+ __pyx_t_3 = 127;
+ __Pyx_INCREF(__pyx_kp_u_got_differing_extents_in_dimensi);
+ __pyx_t_2 += 35;
+ __Pyx_GIVEREF(__pyx_kp_u_got_differing_extents_in_dimensi);
+ PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_got_differing_extents_in_dimensi);
+ __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __Pyx_INCREF(__pyx_kp_u_got);
+ __pyx_t_2 += 6;
+ __Pyx_GIVEREF(__pyx_kp_u_got);
+ PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_got);
+ __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent1, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __Pyx_INCREF(__pyx_kp_u_and);
+ __pyx_t_2 += 5;
+ __Pyx_GIVEREF(__pyx_kp_u_and);
+ PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_and);
+ __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent2, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __Pyx_INCREF(__pyx_kp_u__7);
+ __pyx_t_2 += 1;
+ __Pyx_GIVEREF(__pyx_kp_u__7);
+ PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__7);
+ __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_4, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(1, 1249, __pyx_L1_error)
+
+ /* "View.MemoryView":1247
+ *
+ * @cname('__pyx_memoryview_err_extents')
+ * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<<
+ * Py_ssize_t extent2) except -1 with gil:
+ * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})"
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __Pyx_RefNannyFinishContext();
+ #ifdef WITH_THREAD
+ __Pyx_PyGILState_Release(__pyx_gilstate_save);
+ #endif
+ return __pyx_r;
+}
+
+/* "View.MemoryView":1252
+ *
+ * @cname('__pyx_memoryview_err_dim')
+ * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<<
+ * raise