From a6b2d2e69c462bb6bcf41797c5dea9f19632896e Mon Sep 17 00:00:00 2001 From: Michael Hansen Date: Fri, 11 Nov 2022 11:01:59 -0600 Subject: [PATCH] Initial check in of Python training code --- .gitignore | 14 +- .projectile | 2 + src/python/README.md | 0 src/python/build_monotonic_align.sh | 13 + src/python/larynx_train/.gitignore | 11 + src/python/larynx_train/.isort.cfg | 6 + src/python/larynx_train/VERSION | 1 + src/python/larynx_train/__init__.py | 0 src/python/larynx_train/__main__.py | 61 + src/python/larynx_train/_resources.py | 20 + src/python/larynx_train/export_onnx.py | 107 + src/python/larynx_train/infer.py | 78 + src/python/larynx_train/infer_onnx.py | 189 + .../larynx_train/norm_audio/__init__.py | 92 + .../norm_audio/models/silero_vad.onnx | Bin 0 -> 797513 bytes src/python/larynx_train/norm_audio/trim.py | 54 + src/python/larynx_train/norm_audio/vad.py | 54 + src/python/larynx_train/phonemize.py | 166 + src/python/larynx_train/preprocess.py | 157 + src/python/larynx_train/py.typed | 0 src/python/larynx_train/pylintrc | 40 + src/python/larynx_train/setup.cfg | 22 + src/python/larynx_train/vits/__init__.py | 0 src/python/larynx_train/vits/attentions.py | 417 + src/python/larynx_train/vits/commons.py | 146 + src/python/larynx_train/vits/config.py | 330 + src/python/larynx_train/vits/dataset.py | 208 + src/python/larynx_train/vits/lightning.py | 330 + src/python/larynx_train/vits/losses.py | 58 + .../larynx_train/vits/mel_processing.py | 137 + src/python/larynx_train/vits/models.py | 727 + src/python/larynx_train/vits/modules.py | 527 + .../vits/monotonic_align/Makefile | 2 + .../vits/monotonic_align/__init__.py | 20 + .../larynx_train/vits/monotonic_align/core.c | 21608 ++++++++++++++++ .../vits/monotonic_align/core.pyx | 42 + .../vits/monotonic_align/setup.py | 13 + src/python/larynx_train/vits/transforms.py | 212 + src/python/larynx_train/vits/utils.py | 16 + src/python/larynx_train/vits/utterance.py | 172 + src/python/larynx_train/vits/wavfile.py | 860 + src/python/mypy.ini | 11 + src/python/requirements.txt | 7 + src/python/requirements_dev.txt | 7 + src/python/scripts/check.sh | 29 + src/python/setup.py | 61 + 46 files changed, 27024 insertions(+), 3 deletions(-) create mode 100644 src/python/README.md create mode 100755 src/python/build_monotonic_align.sh create mode 100644 src/python/larynx_train/.gitignore create mode 100644 src/python/larynx_train/.isort.cfg create mode 100644 src/python/larynx_train/VERSION create mode 100644 src/python/larynx_train/__init__.py create mode 100644 src/python/larynx_train/__main__.py create mode 100644 src/python/larynx_train/_resources.py create mode 100644 src/python/larynx_train/export_onnx.py create mode 100644 src/python/larynx_train/infer.py create mode 100644 src/python/larynx_train/infer_onnx.py create mode 100644 src/python/larynx_train/norm_audio/__init__.py create mode 100644 src/python/larynx_train/norm_audio/models/silero_vad.onnx create mode 100644 src/python/larynx_train/norm_audio/trim.py create mode 100644 src/python/larynx_train/norm_audio/vad.py create mode 100644 src/python/larynx_train/phonemize.py create mode 100644 src/python/larynx_train/preprocess.py create mode 100644 src/python/larynx_train/py.typed create mode 100644 src/python/larynx_train/pylintrc create mode 100644 src/python/larynx_train/setup.cfg create mode 100644 src/python/larynx_train/vits/__init__.py create mode 100644 src/python/larynx_train/vits/attentions.py create mode 100644 src/python/larynx_train/vits/commons.py create mode 100644 src/python/larynx_train/vits/config.py create mode 100644 src/python/larynx_train/vits/dataset.py create mode 100644 src/python/larynx_train/vits/lightning.py create mode 100644 src/python/larynx_train/vits/losses.py create mode 100644 src/python/larynx_train/vits/mel_processing.py create mode 100644 src/python/larynx_train/vits/models.py create mode 100644 src/python/larynx_train/vits/modules.py create mode 100644 src/python/larynx_train/vits/monotonic_align/Makefile create mode 100644 src/python/larynx_train/vits/monotonic_align/__init__.py create mode 100644 src/python/larynx_train/vits/monotonic_align/core.c create mode 100644 src/python/larynx_train/vits/monotonic_align/core.pyx create mode 100644 src/python/larynx_train/vits/monotonic_align/setup.py create mode 100644 src/python/larynx_train/vits/transforms.py create mode 100644 src/python/larynx_train/vits/utils.py create mode 100644 src/python/larynx_train/vits/utterance.py create mode 100644 src/python/larynx_train/vits/wavfile.py create mode 100644 src/python/mypy.ini create mode 100644 src/python/requirements.txt create mode 100644 src/python/requirements_dev.txt create mode 100755 src/python/scripts/check.sh create mode 100644 src/python/setup.py diff --git a/.gitignore b/.gitignore index b1a3979..30b9ba8 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,14 @@ *.log tmp/ -build/ -data/ -*.wav +*.py[cod] +*.egg +build +htmlcov + +/data/ +/build/ +/local/ +*.so + +.venv/ diff --git a/.projectile b/.projectile index c18996a..190a047 100644 --- a/.projectile +++ b/.projectile @@ -1 +1,3 @@ - /build/ +- /src/python/.venv/ +- /local/ diff --git a/src/python/README.md b/src/python/README.md new file mode 100644 index 0000000..e69de29 diff --git a/src/python/build_monotonic_align.sh b/src/python/build_monotonic_align.sh new file mode 100755 index 0000000..921cbdb --- /dev/null +++ b/src/python/build_monotonic_align.sh @@ -0,0 +1,13 @@ +#!/usr/bin/env bash +set -eo pipefail + +this_dir="$( cd "$( dirname "$0" )" && pwd )" + +if [ -d "${this_dir}/.venv" ]; then + source "${this_dir}/.venv/bin/activate" +fi + +cd "${this_dir}/larynx_train/vits/monotonic_align" +mkdir -p monotonic_align +cythonize -i core.pyx +mv core*.so monotonic_align/ diff --git a/src/python/larynx_train/.gitignore b/src/python/larynx_train/.gitignore new file mode 100644 index 0000000..794cd0f --- /dev/null +++ b/src/python/larynx_train/.gitignore @@ -0,0 +1,11 @@ +.DS_Store +.idea +*.log +tmp/ + +*.py[cod] +*.egg +build +htmlcov + +.venv/ diff --git a/src/python/larynx_train/.isort.cfg b/src/python/larynx_train/.isort.cfg new file mode 100644 index 0000000..ba2778d --- /dev/null +++ b/src/python/larynx_train/.isort.cfg @@ -0,0 +1,6 @@ +[settings] +multi_line_output=3 +include_trailing_comma=True +force_grid_wrap=0 +use_parentheses=True +line_length=88 diff --git a/src/python/larynx_train/VERSION b/src/python/larynx_train/VERSION new file mode 100644 index 0000000..6e8bf73 --- /dev/null +++ b/src/python/larynx_train/VERSION @@ -0,0 +1 @@ +0.1.0 diff --git a/src/python/larynx_train/__init__.py b/src/python/larynx_train/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/python/larynx_train/__main__.py b/src/python/larynx_train/__main__.py new file mode 100644 index 0000000..f6153e4 --- /dev/null +++ b/src/python/larynx_train/__main__.py @@ -0,0 +1,61 @@ +import argparse +import json +import logging +from pathlib import Path + +import torch +from pytorch_lightning import Trainer + +from .vits.lightning import VitsModel + +_LOGGER = logging.getLogger(__package__) + + +def main(): + logging.basicConfig(level=logging.DEBUG) + + parser = argparse.ArgumentParser() + parser.add_argument( + "--dataset-dir", required=True, help="Path to pre-processed dataset directory" + ) + Trainer.add_argparse_args(parser) + VitsModel.add_model_specific_args(parser) + parser.add_argument("--seed", type=int, default=1234) + args = parser.parse_args() + _LOGGER.debug(args) + + args.dataset_dir = Path(args.dataset_dir) + if not args.default_root_dir: + args.default_root_dir = args.dataset_dir + + torch.backends.cudnn.benchmark = True + torch.manual_seed(args.seed) + + config_path = args.dataset_dir / "config.json" + dataset_path = args.dataset_dir / "dataset.jsonl" + + with open(config_path, "r", encoding="utf-8") as config_file: + # See preprocess.py for format + config = json.load(config_file) + num_symbols = int(config["num_symbols"]) + num_speakers = int(config["num_speakers"]) + sample_rate = int(config["audio"]["sample_rate"]) + + trainer = Trainer.from_argparse_args(args) + dict_args = vars(args) + model = VitsModel( + num_symbols=num_symbols, + num_speakers=num_speakers, + sample_rate=sample_rate, + dataset=[dataset_path], + **dict_args + ) + + trainer.fit(model) + + +# ----------------------------------------------------------------------------- + + +if __name__ == "__main__": + main() diff --git a/src/python/larynx_train/_resources.py b/src/python/larynx_train/_resources.py new file mode 100644 index 0000000..549ceae --- /dev/null +++ b/src/python/larynx_train/_resources.py @@ -0,0 +1,20 @@ +"""Shared access to package resources""" +import json +import os +import typing +from pathlib import Path + +try: + import importlib.resources + + files = importlib.resources.files +except (ImportError, AttributeError): + # Backport for Python < 3.9 + import importlib_resources # type: ignore + + files = importlib_resources.files + +_PACKAGE = "larynx_train" +_DIR = Path(typing.cast(os.PathLike, files(_PACKAGE))) + +__version__ = (_DIR / "VERSION").read_text(encoding="utf-8").strip() diff --git a/src/python/larynx_train/export_onnx.py b/src/python/larynx_train/export_onnx.py new file mode 100644 index 0000000..9f7b057 --- /dev/null +++ b/src/python/larynx_train/export_onnx.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +import argparse +import logging +from pathlib import Path +from typing import Optional + +import torch + +from .vits.lightning import VitsModel + +_LOGGER = logging.getLogger("mimic3_train.export_onnx") + +OPSET_VERSION = 15 + + +def main(): + """Main entry point""" + torch.manual_seed(12345) + + parser = argparse.ArgumentParser(prog="mimic3_train.export_onnx") + parser.add_argument("checkpoint", help="Path to model checkpoint (.ckpt)") + parser.add_argument("output", help="Path to output model (.onnx)") + + parser.add_argument( + "--debug", action="store_true", help="Print DEBUG messages to the console" + ) + args = parser.parse_args() + + if args.debug: + logging.basicConfig(level=logging.DEBUG) + else: + logging.basicConfig(level=logging.INFO) + + _LOGGER.debug(args) + + # ------------------------------------------------------------------------- + + args.checkpoint = Path(args.checkpoint) + args.output = Path(args.output) + args.output.parent.mkdir(parents=True, exist_ok=True) + + model = VitsModel.load_from_checkpoint(args.checkpoint) + model_g = model.model_g + + num_symbols = model_g.n_vocab + num_speakers = model_g.n_speakers + + # Inference only + model_g.eval() + + with torch.no_grad(): + model_g.dec.remove_weight_norm() + + # old_forward = model_g.infer + + def infer_forward(text, text_lengths, scales, sid=None): + noise_scale = scales[0] + length_scale = scales[1] + noise_scale_w = scales[2] + audio = model_g.infer( + text, + text_lengths, + noise_scale=noise_scale, + length_scale=length_scale, + noise_scale_w=noise_scale_w, + sid=sid, + )[0].unsqueeze(1) + + return audio + + model_g.forward = infer_forward + + sequences = torch.randint(low=0, high=num_symbols, size=(1, 50), dtype=torch.long) + sequence_lengths = torch.LongTensor([sequences.size(1)]) + + sid: Optional[int] = None + if num_speakers > 1: + sid = torch.LongTensor([0]) + + # noise, noise_w, length + scales = torch.FloatTensor([0.667, 1.0, 0.8]) + + dummy_input = (sequences, sequence_lengths, scales, sid) + + # Export + torch.onnx.export( + model=model_g, + args=dummy_input, + f=str(args.output), + verbose=True, + opset_version=OPSET_VERSION, + input_names=["input", "input_lengths", "scales", "sid"], + output_names=["output"], + dynamic_axes={ + "input": {0: "batch_size", 1: "phonemes"}, + "input_lengths": {0: "batch_size"}, + "output": {0: "batch_size", 1: "time"}, + }, + ) + + _LOGGER.info("Exported model to %s", args.output) + + +# ----------------------------------------------------------------------------- + +if __name__ == "__main__": + main() diff --git a/src/python/larynx_train/infer.py b/src/python/larynx_train/infer.py new file mode 100644 index 0000000..924ad3b --- /dev/null +++ b/src/python/larynx_train/infer.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +import argparse +import json +import logging +import sys +import time +from pathlib import Path + +import torch + +from .vits.lightning import VitsModel +from .vits.utils import audio_float_to_int16 +from .vits.wavfile import write as write_wav + +_LOGGER = logging.getLogger("mimic3_train.infer") + + +def main(): + """Main entry point""" + logging.basicConfig(level=logging.DEBUG) + parser = argparse.ArgumentParser(prog="mimic3_train.infer") + parser.add_argument( + "--checkpoint", required=True, help="Path to model checkpoint (.ckpt)" + ) + parser.add_argument("--output-dir", required=True, help="Path to write WAV files") + parser.add_argument("--sample-rate", type=int, default=22050) + args = parser.parse_args() + + args.output_dir = Path(args.output_dir) + args.output_dir.mkdir(parents=True, exist_ok=True) + + model = VitsModel.load_from_checkpoint(args.checkpoint) + + # Inference only + model.eval() + + with torch.no_grad(): + model.model_g.dec.remove_weight_norm() + + for i, line in enumerate(sys.stdin): + line = line.strip() + if not line: + continue + + utt = json.loads(line) + # utt_id = utt["id"] + utt_id = str(i) + phoneme_ids = utt["phoneme_ids"] + + text = torch.LongTensor(phoneme_ids).unsqueeze(0) + text_lengths = torch.LongTensor([len(phoneme_ids)]) + scales = [0.667, 1.0, 0.8] + + start_time = time.perf_counter() + audio = model(text, text_lengths, scales).detach().numpy() + audio = audio_float_to_int16(audio) + end_time = time.perf_counter() + + audio_duration_sec = audio.shape[-1] / args.sample_rate + infer_sec = end_time - start_time + real_time_factor = ( + infer_sec / audio_duration_sec if audio_duration_sec > 0 else 0.0 + ) + + _LOGGER.debug( + "Real-time factor for %s: %0.2f (infer=%0.2f sec, audio=%0.2f sec)", + i + 1, + real_time_factor, + infer_sec, + audio_duration_sec, + ) + + output_path = args.output_dir / f"{utt_id}.wav" + write_wav(str(output_path), args.sample_rate, audio) + + +if __name__ == "__main__": + main() diff --git a/src/python/larynx_train/infer_onnx.py b/src/python/larynx_train/infer_onnx.py new file mode 100644 index 0000000..b289572 --- /dev/null +++ b/src/python/larynx_train/infer_onnx.py @@ -0,0 +1,189 @@ +#!/usr/bin/env python3 +import argparse +import json +import logging +import math +import sys +import time +from pathlib import Path + +import numpy as np +import onnxruntime + +from .vits.utils import audio_float_to_int16 +from .vits.wavfile import write as write_wav + +_LOGGER = logging.getLogger("mimic3_train.infer_onnx") + + +def main(): + """Main entry point""" + logging.basicConfig(level=logging.DEBUG) + parser = argparse.ArgumentParser(prog="mimic3_train.infer_onnx") + parser.add_argument("--model", required=True, help="Path to model (.onnx)") + parser.add_argument("--output-dir", required=True, help="Path to write WAV files") + parser.add_argument("--sample-rate", type=int, default=22050) + parser.add_argument("--noise-scale", type=float, default=0.667) + parser.add_argument("--noise-scale-w", type=float, default=0.8) + parser.add_argument("--length-scale", type=float, default=1.0) + args = parser.parse_args() + + args.output_dir = Path(args.output_dir) + args.output_dir.mkdir(parents=True, exist_ok=True) + + sess_options = onnxruntime.SessionOptions() + _LOGGER.debug("Loading model from %s", args.model) + model = onnxruntime.InferenceSession(str(args.model), sess_options=sess_options) + _LOGGER.info("Loaded model from %s", args.model) + + text_empty = np.zeros((1, 300), dtype=np.int64) + text_lengths_empty = np.array([text_empty.shape[1]], dtype=np.int64) + scales = np.array( + [args.noise_scale, args.length_scale, args.noise_scale_w], + dtype=np.float32, + ) + bias_audio = model.run( + None, + {"input": text_empty, "input_lengths": text_lengths_empty, "scales": scales}, + )[0].squeeze((0, 1)) + bias_spec, _ = transform(bias_audio) + + for i, line in enumerate(sys.stdin): + line = line.strip() + if not line: + continue + + utt = json.loads(line) + # utt_id = utt["id"] + utt_id = str(i) + phoneme_ids = utt["phoneme_ids"] + + text = np.expand_dims(np.array(phoneme_ids, dtype=np.int64), 0) + text_lengths = np.array([text.shape[1]], dtype=np.int64) + scales = np.array( + [args.noise_scale, args.length_scale, args.noise_scale_w], + dtype=np.float32, + ) + + start_time = time.perf_counter() + audio = model.run( + None, {"input": text, "input_lengths": text_lengths, "scales": scales} + )[0].squeeze((0, 1)) + audio = denoise(audio, bias_spec, 10) + audio = audio_float_to_int16(audio.squeeze()) + end_time = time.perf_counter() + + audio_duration_sec = audio.shape[-1] / args.sample_rate + infer_sec = end_time - start_time + real_time_factor = ( + infer_sec / audio_duration_sec if audio_duration_sec > 0 else 0.0 + ) + + _LOGGER.debug( + "Real-time factor for %s: %0.2f (infer=%0.2f sec, audio=%0.2f sec)", + i + 1, + real_time_factor, + infer_sec, + audio_duration_sec, + ) + + output_path = args.output_dir / f"{utt_id}.wav" + write_wav(str(output_path), args.sample_rate, audio) + + +def denoise( + audio: np.ndarray, bias_spec: np.ndarray, denoiser_strength: float +) -> np.ndarray: + audio_spec, audio_angles = transform(audio) + + a = bias_spec.shape[-1] + b = audio_spec.shape[-1] + repeats = max(1, math.ceil(b / a)) + bias_spec_repeat = np.repeat(bias_spec, repeats, axis=-1)[..., :b] + + audio_spec_denoised = audio_spec - (bias_spec_repeat * denoiser_strength) + audio_spec_denoised = np.clip(audio_spec_denoised, a_min=0.0, a_max=None) + audio_denoised = inverse(audio_spec_denoised, audio_angles) + + return audio_denoised + + +def stft(x, fft_size, hopsamp): + """Compute and return the STFT of the supplied time domain signal x. + Args: + x (1-dim Numpy array): A time domain signal. + fft_size (int): FFT size. Should be a power of 2, otherwise DFT will be used. + hopsamp (int): + Returns: + The STFT. The rows are the time slices and columns are the frequency bins. + """ + window = np.hanning(fft_size) + fft_size = int(fft_size) + hopsamp = int(hopsamp) + return np.array( + [ + np.fft.rfft(window * x[i : i + fft_size]) + for i in range(0, len(x) - fft_size, hopsamp) + ] + ) + + +def istft(X, fft_size, hopsamp): + """Invert a STFT into a time domain signal. + Args: + X (2-dim Numpy array): Input spectrogram. The rows are the time slices and columns are the frequency bins. + fft_size (int): + hopsamp (int): The hop size, in samples. + Returns: + The inverse STFT. + """ + fft_size = int(fft_size) + hopsamp = int(hopsamp) + window = np.hanning(fft_size) + time_slices = X.shape[0] + len_samples = int(time_slices * hopsamp + fft_size) + x = np.zeros(len_samples) + for n, i in enumerate(range(0, len(x) - fft_size, hopsamp)): + x[i : i + fft_size] += window * np.real(np.fft.irfft(X[n])) + return x + + +def inverse(magnitude, phase): + recombine_magnitude_phase = np.concatenate( + [magnitude * np.cos(phase), magnitude * np.sin(phase)], axis=1 + ) + + x_org = recombine_magnitude_phase + n_b, n_f, n_t = x_org.shape # pylint: disable=unpacking-non-sequence + x = np.empty([n_b, n_f // 2, n_t], dtype=np.complex64) + x.real = x_org[:, : n_f // 2] + x.imag = x_org[:, n_f // 2 :] + inverse_transform = [] + for y in x: + y_ = istft(y.T, fft_size=1024, hopsamp=256) + inverse_transform.append(y_[None, :]) + + inverse_transform = np.concatenate(inverse_transform, 0) + + return inverse_transform + + +def transform(input_data): + x = input_data + real_part = [] + imag_part = [] + for y in x: + y_ = stft(y, fft_size=1024, hopsamp=256).T + real_part.append(y_.real[None, :, :]) # pylint: disable=unsubscriptable-object + imag_part.append(y_.imag[None, :, :]) # pylint: disable=unsubscriptable-object + real_part = np.concatenate(real_part, 0) + imag_part = np.concatenate(imag_part, 0) + + magnitude = np.sqrt(real_part**2 + imag_part**2) + phase = np.arctan2(imag_part.data, real_part.data) + + return magnitude, phase + + +if __name__ == "__main__": + main() diff --git a/src/python/larynx_train/norm_audio/__init__.py b/src/python/larynx_train/norm_audio/__init__.py new file mode 100644 index 0000000..cb0df33 --- /dev/null +++ b/src/python/larynx_train/norm_audio/__init__.py @@ -0,0 +1,92 @@ +from hashlib import sha256 +from pathlib import Path +from typing import Optional, Tuple, Union + +import librosa +import torch + +from larynx_train.vits.mel_processing import spectrogram_torch + +from .trim import trim_silence +from .vad import SileroVoiceActivityDetector + +_DIR = Path(__file__).parent + + +def make_silence_detector() -> SileroVoiceActivityDetector: + silence_model = _DIR / "models" / "silero_vad.onnx" + return SileroVoiceActivityDetector(silence_model) + + +def cache_norm_audio( + audio_path: Union[str, Path], + cache_dir: Union[str, Path], + detector: SileroVoiceActivityDetector, + sample_rate: int, + silence_threshold: float = 0.2, + silence_samples_per_chunk: int = 480, + silence_keep_chunks_before: int = 2, + silence_keep_chunks_after: int = 2, + filter_length: int = 1024, + window_length: int = 1024, + hop_length: int = 256, + ignore_cache: bool = False, +) -> Tuple[Path, Path]: + audio_path = Path(audio_path).absolute() + cache_dir = Path(cache_dir) + + # Cache id is the SHA256 of the full audio path + audio_cache_id = sha256(str(audio_path).encode()).hexdigest() + + audio_norm_path = cache_dir / f"{audio_cache_id}.pt" + audio_spec_path = cache_dir / f"{audio_cache_id}.spec.pt" + + # Normalize audio + audio_norm_tensor: Optional[torch.FloatTensor] = None + if ignore_cache or (not audio_norm_path.exists()): + # Trim silence first. + # + # The VAD model works on 16khz, so we determine the portion of audio + # to keep and then just load that with librosa. + vad_sample_rate = 16000 + audio_16khz, _sr = librosa.load(path=audio_path, sr=vad_sample_rate) + + offset_sec, duration_sec = trim_silence( + audio_16khz, + detector, + threshold=silence_threshold, + samples_per_chunk=silence_samples_per_chunk, + sample_rate=vad_sample_rate, + keep_chunks_before=silence_keep_chunks_before, + keep_chunks_after=silence_keep_chunks_after, + ) + + # NOTE: audio is already in [-1, 1] coming from librosa + audio_norm_array, _sr = librosa.load( + path=audio_path, + sr=sample_rate, + offset=offset_sec, + duration=duration_sec, + ) + + # Save to cache directory + audio_norm_tensor = torch.FloatTensor(audio_norm_array).unsqueeze(0) + torch.save(audio_norm_tensor, audio_norm_path) + + # Compute spectrogram + if ignore_cache or (not audio_spec_path.exists()): + if audio_norm_tensor is None: + # Load pre-cached normalized audio + audio_norm_tensor = torch.load(audio_norm_path) + + audio_spec_tensor = spectrogram_torch( + y=audio_norm_tensor, + n_fft=filter_length, + sampling_rate=sample_rate, + hop_size=hop_length, + win_size=window_length, + center=False, + ).squeeze(0) + torch.save(audio_spec_tensor, audio_spec_path) + + return audio_norm_path, audio_spec_path diff --git a/src/python/larynx_train/norm_audio/models/silero_vad.onnx b/src/python/larynx_train/norm_audio/models/silero_vad.onnx new file mode 100644 index 0000000000000000000000000000000000000000..127ffc922b59569d015492eba7cb276e860edbcd GIT binary patch literal 797513 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 z zC%S&B?xt~|8tCwahm?0&hNy*^#8o+{{_?ki%tK}nf{;ZD-vhZ|4Uf^i~gT8{lD1s z|5UG$ypcchX!?KN^#6kC|7re3|1UEAKh=i>C#L_$`XBv2)sqzczhL@*8PosM{U>l} z`hTiV2~JJ_&w*dj|I3*EUu^n+s&@(Q;h*ULIn)1BeN55+i%kCy{S5T~R8JFLnf{;Z zZNfX&|DykwG5xV=AKDEt5D z|7J}8H)Z<2sy8aSqxAn}M2A%MNJW=a^+`piG&22P_Ak-@RXtPDHC266(K(Gx|5x`v zMF%xD{ofqZ|BX!lm;HZqR8>z^bX9}t|3;?&tNX7XJ=;n3SVfmr^;t!yRrOj$x0U_> zAUdwW^nYX1|5d$L(S6nUiw>;n!HOdT7GY-0Mqy8kRX zw6W>`;!ltMujHh}P|4p0zujBk%bZ}JMvoGI2Hi-(dQ`_%ERU>rDSw^_d^pQPrFNFZ=)K z|2otEjmR%~HvL~2zv}<09<=EHI@AA+P5+nufAoJHn%;HMj-8qW>FA|2H!I-yGBbW&aEP-^lcTRUaFknEr1Je?Hl;7kN&^vnTxKu>YIzsd2IUs_@4#QL61!TU-i*N zCtdZ@MK_)Ee<%9?k?H@ZP5)o@)Mx8yy(K?50C!8>cxw0yhlG?bmW8S|Hr2P?@a$+=Wo%W_on|JO#eSJ z{eSw`z3AAhp1tVWtG>PH+$X00FZ@^ie`osts*f)^`Kp&+K)i6Je;)mRXZrt<>Hn+V zzUc1j{3$y8s>d(7{ND8cW7Gc+==ayGG+6cgMb}^T{YB^BoBqFyU-kck>Hn)g0KaGY z|D6A${~t{MKQ{e;^&8;6Pgec^*!2H7|408{{T#@v>Hn+W19>O^ z;K20%)gJRE|37W|{}K2F$EN?U{uZMD zA58yW@h|%Sk?H@(rvI;g8SuvR|0C1?PnrIIZ2JHF{eu2~Z2JFc)Bn#l{eSd3(EnFI z57Gb6G5!B6)Bjigix0>)^Z&^*{~z@W5#JE%|1#nul4Jfq_>1HJlQ#b!tv?bUlF0mj z@F&OrCu9CU)c>W$$3*>1#MdM;|DTNc|LFJMV}BQS=KrJqDB_di%>Re_Dg1w8^Z!wQ z74cb7zZLOa(fTX#Vab^PkNUHSPmB7sh;Iw^f8woqzcc@zjQRhl-;4OZIN~QhFzN>* zzA*U19~@`?KhFGr)GtSTbEy9d;-iz8|Bo~OA7}nQ%>VfCs2`8`@+95Q z`Tscc|Dk^${~z`95nmtm_Yt3;#Qc9`{ObSX%>O4b{~z@W;&Xgn{D1U%;{W5gKKC*I zALf7je-iWm(dQHYA7}nQ)c@iCqkcx>|C5;ikB*md^Y;&NF#jL*M-u;^#QcA#pTz&i zng5UaD~bP)H~*hN{h#>%MCSkF%>O4b{~z=l@c#+s|C2WVA7}nQ%3p9`{y)L|e=_F( zL;WBAKk6q1uFU@@nEy|P`af`J{y*wZCH_Co{D07|!2c&>{y*w(CH_Cb{D08@#s4QZ z|DTNc|EOOUyn#RB{}Y-2kMc|We=_F(!~Bo`Pi+1_Y4iV4zQSAc|4EtuPmcNjWSReu z@?U(wwweE5mihmwUzqrYQU8zsU$*)GslS-`jH%z4_>QsuPm2#(+Wi0UC&&L!{mR6* zERy==SbWT4^Z&!&9RI(_{Qorm;)CYQ{||q3Cq8Kz^Z%p%A0IXKQxjh`{MGUQi_QO! z^*{c9>c=L&Z0gS@K5fqY|J1)-eB9K}tx4)D^>-7WH}!iH-#7S=|DXE7i7y=f@c94v ziRb+PsQ>rkBbPS+Km6sL_{=5d|L3Vc7azJ{{(r&z|J1KeeCw$H7rn1?-u(Y!{O!c& zE|~wH&R^n#mze*b%wOvN=gj|)`hR@%)K5=*^%C>{bLRht{=WZX^$qIBC%$~%{Qna3 z|BL1175_i=^Ale`_4gB>KX3kj5`Xpo3+Df){($_R`Tu!7FaCeA`Tr&6|EGR~+?V@{ z|DQgO`2RWc|5Lw0p4i_ZoOPl|nGygyJn*?{@PyGLa`Txb{|EGSH;MV;AocaG{%>OSo|3B`J|6efwzsUUm z(&qmc!ykBL{(rIg|0&<#9sGlb=Kq&A|G$j+|7Dy1pZa-<|6h*z|7Dr~pYmUPK)0Fy zZCSGYX6b=kY<_xulkdUPpSHqif<|XfB64q z%>P&YO~vOlGXG!Q{}dn8$ozltN5}tH{Zhp@mHxk2d{l$^|KhKX|F8P3itj4>|B?8x zI`jX{nE$W(wTf>m{eQ9exCZn8jm-a7{a(fQRq!u<)SG`-KiKUxCg2Z`|8Fq=Unl+J zk@(0a=Kt%=|2H!K-$4JF_|U2!t@zU7Pmlj^Wd6TS`q!NJ*s7nc_}b!cpNP+GF#q4c z`M3DssvoZS;wI+*>&*X`{&_Dxy6UGZzPjqKD?Yo4`Tu6{z@G5=rs|M34+KWlJp{=bTMaL@j~`2Pm;|5bl% z@&Ap@|2G4F;F0dzEUQ*Is6?_=;G};(DVy2k?!2Uqzpb|TYstSuU*F*S_O72yos|>l zzkhsC9HwM9Om3b#T<;%ejYuBt*2Hgmc&C&8{p7RBue!QLoB9n;->RSQ*Z4MH^jOp6 z!6UE9_@{dQ=QTg)`urZh&*%6&*Wr3xm-o33_v60YpXcCtcrM=OIeA{5o9Aa7jE8aY zKI3G(jGOTj2jW3oc%L{CFXBf0h$HbNuDnm2i8pa4{^WstkQd%3Pvncdkw5ZCKFKTZ zljpa-j{|v^mmVBcthpwD3*HAO;04@(A8=Hl$ZQ9$cpsdBH*g33z#(`9m%I;7!7I20 zzu*`=gKORg=inXOgMWC?X?{)&FL)oGTyftc5xjvv@CZJ^E8d4^@D1L@9>`2>rYMDcA)r2+nXipp! z(*K{iBrcwW-zH9wB^M9)ToF(arV?WKbnA1=F$7fABo5{NOfz0f3{h9y8=d)(~ zP0xp;YMrjr@2`vZEsdHzbX)q+;eE{iQSEs*M0M_#zj=IT{r>x`YuPZcV1e}DrB(1p z5AWBzCjR-=F7C#mM`OM}?|povYq@t!d}M8xAm6X<=>C=IoWEv=(`S0>_iv~7mxn@^ zm3DJy+=M@SNPpZsdb#B)H*?H#{r+BG<~=vM>iuEw#DVy`yUuTw4P6Fr3SB#YtNF^e z=clmpU-A98wLbpv$vlyK==||}o&Q|h3Fjprzp*Tq`Nbc3@$>L+ulZqF z{sub#Oe%3YtUkZKzi@c}SmvkXx|J9De+Q&pr-iL`{u=nfe)n^ctCJ@42RNDEeBS&~ za^TFR@uj=Z&41}HmW9{ni}qLRw}Q-%$=;;{{Ei8QLyt$=>HJyh-s&#r#o@`Gc4e6V zUAdRXB&Dxh;X2&eSm)nC-Cj+%dttDz`g@xBKa{)sZhzzQyvdfOrFH)9xOq^xiNCn-jnf9P57VJ{G9jsJ$|3hG5>QNuE%w`KKJ2%+?V;E=iqsG zE}oC)U$p ze2^FNL!QVNd1L-3kK~iQl3(&nzR5fI2M6E*T!0U70$#uk^FKHOPv8oCfiv(1?wJ3< zA$SCr;1isJS8xk{!7+FS*WeqRgLiPx{0|S{1H6DA@C3fV8|Hs_1fSp){DNoj4c;;T z!$bH8FX1OVg|F}y{=#GU46orgJcsY_p7DQKXx6qlJ@;&H(`pUt|LuK$YM--k*pk%u zgW{H~A8OxQCf)48M^d-%n$P+_-CG`c{k#PE*g*N}`_uVt=ONJNz&Fj8g zSU-~WQ7E?gc=S)5*P;z4uhsR_manV2%Sw+92X4GLlJ%9#zj;jf=Y#JuPhJ10uD|kq z@I~C~=NH@+&o^cLALg&y?j{yG9IvRlK-X_)m#xbDuwqBJecUG2|52}!--iXaFLqbV z*80Na-HwCZ(i>L0Ze0rE4<9}8*7vUZxV*`bekU@lAG^9Ep;p`?485@${_^4Qw`)S% zE_MB?c_VfGnY#WmKjA7_=hUu>KfPbv{ZO=He9L6XulaTT`t|ru$xHKgxagWc@V8IO zt?ud;4Xfqvn9^3~qv_K-`fhFNCnKKfFaEWIe3t>|B|V-x5DpI-q3h?yPgF@hd1$CV zJGoep^>tG6^X|TNg(PaYVYsfpM{Zu_>RvM;`KMDJ*8hI?iit_7;qzUQAt_zIkDb~v zdhemZzRZCxtpCHO|4#6acB_$;I)ovJFO$9-A< z^Bg=6&&BicoIEej&HA5lFdoLm_!uYSW!&J8I1mrwLVSo5@gi=l|A`~R`6lmj`ve?-2XFyCzzKK(H?04`5qJVu;0v6A zH*m-L9~^>5a0x!aDR>39tpC9=cm~(t8=Ql8aL@SR0epZL@B^N}7kI<^A0ELccm==U z8GM6xtpDL5e1wO`~Kve`epqtWH*SK?M#KdzXCzj%6FgUzYAZH{Jowcn`y|0i2CjEi6XR(i$X z$M7eQTilRFo?x{@MlInjJpEtH+ zJgHx8w`t1TvG}9Mm;chvjmoz^UbC!VVE^>0|0c)R_Gu9=j>fY8pShy!=&*X&BsZhk zM)hCcaM?uH``;DOno%#Y|L>~Ty4YPkZ)YfXL3`c5b;~~pFJE596+XTgfA_Gp;d4=q z2VZkZ@q-%w-#Z+4hd1vJ5B-u8%l@#xz546nuf5`%v$L%3A6NQlQ8;$Aif?(#bo}MR z8>KGsHG0+#`QObi^>;P>o-MuNpR+3^9bT)%{(p3BrzXkrMJ0Xjr9E~3ze}Uj?z`vL zy3?<8WB=dXyzV#m&Wc{iiZ!zw``;7h^-OMkE1%o)ZF4XC<4KKO8#8yW>ft{e(Omb> zuU$CQKd`Q9Qn<^SAp8G5tjwFd_{3k~tNwTD{(Jo;)st^akMYlJ=pST%KAHOVO}^#n z_Hnx+19bns;Af|!@;SFBdp5UV|KF|sW>ON3xY#eOix%3{g#UTX&v~EUv3JK&waQb_htW|=iqsGE}oC)|4#i6Gvc(p6DDLiVMRxa|1SwXeP+W@B z;!p|&iu9dt_`UqIpL_2)Cz*Mk=Y%AaneIFLt7X;3IsJ|w^P}33cdBW1I0^f+s#zA< zvyGVNH>hLX{_UyW|M;D}i>l7JY3%=-(FvcZx_Z2s*Sjb8YgJ8ZwUnA;3LZ#IeRy-f z`X2M;KVRwhiHo@X0 zm)IYr`O9a%=Xb8-dhT=a1M(c6$8&i;?a&_W!XNrUf9Mzeqo4GbezX6N9oU0i*oU3Y zUa=ed@dN(AFZc&P;V=Bg{y%=ipZFF3;%EGg-)SElzyn;s2b{nQ+}QsINALt!@C9e^ z26wq#!vpvLFW?6}fiLie{eO4_pWqezf@kmz-qAihgpcqNe!^4u3UAr}hsW?4Uc+yA z4&UKD@h|8AJ)jHpflkm1x?%qx9ib<5g}%@kdP8@#j}Flzx}+i0jZo@~ z2NqAwAKbQLTJUCx#4i5mK(WigK2a6Dn668LQlH$Pkb1P2u;I_axRdI+_@yiD9tB%B z9`Dco{v7dt{-)lW{1NNpsC~=QyZ2vIiLcd)KDqtli{coGk5Yx!74omP|Jw8qtLx&Y z-c&7R76*E$5>ty)U)|IlI9jbpP{@x;*~i6S{WUm;Kd8k7b8*>n;{W_UKP)gm7u%-d z)Oj2verxPZU&RjF6kK;&;=Wd&P(PLr4?Z|`#;mA%#o^bz^gUC%(zhPQ{Q}B-;ICe2KH1} zLYmt@GGr$HPi<`8&YC!x^@CS4T>Rf2FO&YM>~eMKvaH{o&8Y3STh*G>eQhn1p7CG( zGku`ll{BqxqkmDd7;Co&Q|iOZFR9L@hPwE@btCVo-|7yxKle>c{GS>*YlQuKe0-_@ z`$6m{{{MsGGvD(&*Ks}f5&y??cplH?`LsiOv`hQ+gZ|Jj`bR(MFa0L|4?D02yRZ*C zu@}1;|M3InHsp zTX5TxL&X34vx**yUHsQWZ&8Vt?)_DuSz=YXZd%i{d$NGUN2>E{@+`Avc75>m||AEpXG7>I`-94Q$5RJZ{+)))MqzU-+b^g-5sb> z*~2b=`}WnLYGKDKW=fXw#Q!V*_7hWRbQjgRLlpYA87_@e>q-n$#mXn4KD-(rb!c*= zNo~KHxzoju=WdnBuKxYFN-(^olK66a?(%J=c2-pjuM}|c=O4}%QMaxYv1f-QA^u-& zd|c8-oJpsjul&Q+uOAjKm;SxLagO{D$Z7 z9o}O<~r zknYy5VA6kM!z*^V<<1{fuk#|J|Bh5%>jMor{}(uUtg!ba^N;?Y2jjT&OKXBLe&Uk# zyt4NydUC$WFYISv5WMR(#nGt1TRqWla zX4}25-1)zF&1afzb@8eZW1pD9+Mn}0Xubv5?gZ|?n{Yu@kbWp!o)Q4A> zddS-G`V^}FuG8-P*y>g7)yk>9D!eNv_2pIFLu*u@N1-x)9aEe?PaIa~@CDwylkXwgbb756Pjp@hSe&MR9yn)AO zItGu;_$ET?iwBk;{3ST4LfOEyA@kk&<3nMG0+GY#2Bt+er9QcLaap~<%K78`ff>iR z_5F197x^g*$9TzetGU{C|bCWz>I9;;On0H*@}9 zEf_Y_o1Sc!$y9Ew!?)`9+fCT7$JL+)+k83SZOSixpzbvYH}!&(c)sqkcZR7lrH)y8 zB%zl2@Fqq0E&srxL^`v6=i1M02y{0*-Z*Qwls;8eHSY;m9dLjC6 zspmwzHWjCBH0Kwz)^a}H&RbE!1idD@Xy4B@1adX6tZQy>We=YSSMi#J>U>+iwME9q zs4sIQ)|~(UG*Dsc|PsX9_`XT{h&Yei~iA1`b)pv{bC39 zU>EjbC-!1D_TvZqfnV?se!^e)jr;K<{=~2N7eC`~{Eq*@0X)D3e8363z>WLC5j?>a ze8CyK!CijV@Blu*3-|#~;0wIres~0*;1&FWXYdW)!9REiAK@kZgs1Qo-f}-YhR^UC ze#3M44)59jM+fKuU7!zif?m)K_oE~9gs#vRIzw;hj`RQM5Iv$x^odT7USl z5qZcvm}NEje}ab_T=q(zeC}8M`app9-+(1qOq`R`z17LLd6FN+B;OK8jVe~d%doPh z%b!yDZA@(K->R8>69$q0$IsKQu$kU=rt17CmwW#%zq3r;pFYG~PEm;bEUMR*b>`&I zPTsL&Kf3%a@#7a#*%!1|*OT8eQr}%gC-~^qD}CS83_a=aDc0wr*?;|msZM0c%#zei|V@{-L;>N$or|C_@ zel_&TU6siH<6UlCSjXIJXLk==r)2!puTu50E7m60Wed$!l3&LjPpWl=CfchNx1Jk+ z4_<0+p54o5_igx|{68jR;yb3scab`}eG$fgv$TFUeZNyn`zga*PxAZdft?50K*!B$ zXvZ|7k0{GuKJz`la~;=nANTVdp2u@}KJCyR?K1w;5BfvD=pX&0zx12_V+ZzN7xrN% z_F^~VKYqX;_yzyqC;Wxq@E?A}pZFF3;%EGg-x>eG0X)D3e8363z>WMr;0T`J3clbB z-rx@Z;Q@Sr7w`j~z!!KUOmA{6~lA5nZBBbc$ZlE&4^r=oww3 zZ*-2{(LMIR%n{tTwqe=mD#h24|1b9O_Z7lgr=1uP`TimE|A^TePDXTSI6$6Vjr@NR z_3y+4PlcQdbV|P>mifoq6NSCi9ioF-KE(tjKbbc%cNKqc3Q4NM7teL`ueB}9dxiGQF}cn!RZ^ebzmRjNDe(J# zH9+3+GJi93Zk|$WuC6ynl*!H#jQ)Q4BC z=iCmqe|pCh?wrcykJJ5@n=4JS>5Yf47|AbZj>gTXM?Fe!cQ!idG5`GWNpYLC>Sh(W zajBC0boSKTNM{(;uTt>o9!%gX&~&is7eJZaO< z&A-o-O=W5pYNe0N?m+%O6>_?O&hz&V_EEfe%>Px~s6qDX*~)rfSanbG``JFb`{-&D zXPcXm8D)Hp(){H!-}5`yaXt5OKhNQLJeTLw4(-t{^MCq5f9Mzeqo4Gbe$#*Kz#iNZUhR^UC ze#3M44)3ua9iRtvfj-a)dOlK%-|c>1NAGC5GFAbeus-Vrg=UaYXdKG-6GO9lqo@^DE7&Y*-YG4y07!Tk?|s*9+db<89hs*Oa)P zob`Y2ul0@1rF-qw?a7^d$**dcd%|^V_Q3>36|c)Tm@|o}Xo$I)s`?#Oy@I0Q&^J$0nXqWYW`ayr_7yYB3^p}3qf9${>?7}|m z#9r*ie*Azx@C*LIPxuSJ;XnL{Kk+O6#n1Q~zvF*!01t2hA8-OMa05SZ1W#}UUvLI* zaEJf!06xGA$^Ywk0$<<_{DDXC30}c3cn06#9qa$_5I(|7_z6$pE4+oj@EAVBYxoV% z;XAx%{U05m2Xuix&nX0jWc#%3`EGx_Vt;tLNf75N%F7+_i z3Ul~C7LWSv<;t8h7xwg1+k3|&zq|26&Z?GgeZP9orAExxk263SKvB2P|TAk{*j{PlfftLwsl-!ZFYpGfN4>)lJkZN!^=>U{Ae^8f#q zwod#n^}73oRal#kE`R><&}je3o+`R^$}Z&pS9ANocA=qLT9-?IPj z?7$xE!anT8UhKwx{D4333;w}R_zS<`Km3S4@hkqt&-fd^(>^$W2e^O_IDr?qfgd=6 zC%A$yIDFJg1;5}Ke1mti4-erZyo8_d6u!b++5b22 z7(T;m_zlnDJG^KAA040vbb&t533@>{=m#C4Cv=6r&>4C|ceIZV(IdJrLJ8!q)hVr$174ez@uLqwU#2d;j|FHa7}{B|Qx zFmvPC)c*;tY&SLbkG7`*f7OZS;*VZ^ToTw9RDPG^B|NE55_@A{S%2fG8Q$q3m5Bcf z#*SO*H4FOwia1%Q|KlB<_0q4K@`9JHNIv)et1&K{O4Q<*e{6YX>Z7Q{r^=eDk(0ew zUte_fe-3SrQ19zi3Vxe3V5Gi^%2p|tY1(_5Up&qP7k{;L(J8O-Noi@PO2pG4D3#)n{IAGcUer>CT^5*qFnv zm|t8S-g-ez?;T;+bxEp==g;WfzL&{Tzh>jbBWCo{iKg}a@>=TK+uQxalz#Y0UEAEu zjenKoeAl}VC2XF7t*HNF(*L~L3~SIr7x}g(@qa39^;9}0>Ra0;MPBOvchtJTHHO$WGp z;0T`J3clbB-rx@Z;Q@Sr7w`j~z!!J}f8Y^(f>-bhp20VGNBkc=gpcqNe!^4u3U4L; z&%k5&46orgJcsY_p79?Ypa*n;KF|qzK{x0J9ib<5g}%@kdP8@_|Di+lh%V75Iz_MO zR^tBx=ometYxIrI(L1`w{zU1|?+ab{{l0C>r%@j~c1eei;pHBj3h$8os;eK?EbF+~ zH3R>Q4SzbF`hUSUoBBoczdtWDgjd&> z`s`|S#y#fo?lLO=&V-8k?cZFpDthHd|BwH=8maHDRu4C3!(HW-+$Ht6Wd7GN_jYw~ zZbPq~y-t02J$~OTli<5hlV^A$E%D=ab+v}-)qiu;o@!aG)R)saIv)1_%X-DMxmH*c zf4-?qa{s+fuKh`6ssE=oM~5l1eqOa}+SX>@(?B;{+s%0A6WD#b zztdlJ4%nit%X`G%$ItP-{dRp;eQscC6}M`AJNi_wByVx4P%~Dgc z%6WvyAMDO%b#$er$NY`=s9_wX`O9a%=Xb8-dhV0>f6a4v9?#|Zv_pHe>*D{VAM}TQ z(Lef0f9W^<#}4elF6_fj?8R>Qhad0BFvm zXyW(hV=FE09s4okNa~9Rzx*RCu%S`TK+{M6y7NbKpA8K@$h|&jR@I|Exj*;G)WC!j z>AVr~7Ws01$-5OfB6uNPAAdlmOVt1MZ`4m6sFP=>w=hp~xBgjuLu5qKlJETd8H-c@ z*WdbhfAC$Ud@9SwCa!+!xpnou#T}cNkcc0Y)K~Xg{IcD@7&%7ON->S~e{burU#N%+ z%gl@Ci>d$X=SmS~ypORe#r^f1|MR}vQ|_)m0rAPvyt;-{>cmRb&DpMZ2F7Kl+>439ZICPJ+kH0 zf2W!1&Ywk|&99#p$!nLM>87MUt?~+%v;8CT>1-tm89BdZZcCkvFH+>O6Tbh&llr#0 zQ{qN;{)B9L{Dloc*1xl^YON2fO=lmr9pg)VTz#QvC);Uw68**3**QOF>wMEyCmHd| z%xX7+`nvkdOkHiou4mNl*4t(N+sQUA(NUM}x6V}Qe2e)c-}t=oww3Z*-2{(LMHmsCU!-4aqSiTXZ9Ta|PUcE!CFx zKK08Br5oeM`G@5fcv9co-*Hm*Kjh!yjYr-7=gSkf-0vlGzW1a)x=B?hnZxDJnO_^~ zr`K&!!09w(URfpe)lKS3)!grG8Z|Sr|EltsZ`|+IBL^#~&u+r~G4A(yt)?34w|7rH z*Ztn;`cl>6!5`-S=W##I_E~O!SC<_W?S7Bb^q`XZ@OD<=6Yl<@Z_XJxKd$R;z3zVB zT>HL~`tr8osn2=C&V~Nt&YzcS|H=Jcv{Za8_33R$_C#)6U-m4irG9^k1dj`rg9obLC!qw-ieKd*EBEBSKe-|31W z`sAHH_Cd?fc?R-TC~P@@-}+S%_xtev#dLyUKiK8|=XLehXG>T)zpu}2`&=h)XVX%; zY{wC{;E_`9`R_iKlKZ0c=f82{@IAkC9qn-+_wyV+^IV=!JA9^H+NU3UreE}re)5@q z(|_#XGj?GgcJdj!u^&J18Nc8k{KRMchX3#*pYbdH#m{`k@0|Y!2R?%f_<$3i!43St zkk2OjYmUcoPT#%Fj3|KK5?;U)Zpr+kLD@E0EQ z8D7J0c+O{d&;CC;;4`{FALxY7=m!0uBR-=m^o7p&jP5x9j}G~aF3~4Cab3XsS?oISP#{aUb-hSi8|I<|}GXBRDxi`tZKURen2+I2;B3b3s?)@@v{XWM3 zpz7Dwy?^dM$?ePgC@`zoME8EGS|-Yq_mv+nFxkDok|x{d%lpjhq8hvR+ljy4c=EpU zTkmfZ%log!gKS3LhhDDu4cz-N!`Mnn-j`*TSSOq_3b?@h~O;#y+Uz?nNHgWIoyJNN(d7mp)ZjyVyU!1c`$@|{y zE4JC;WUl^XWIWJGGM{ndL+7L0m5dj5Zo1c;ANSY1S!-lG(UsC9cjL>vQuCCIH#T>! z>~8$YJ$R&%@knx&uaXt4j{_`B3$8#C~X@~Y`m+_x|&>#B6_)kCSFa2ix#}4elF2;ZC#9r)X{KpUY z1HUl-<0t%u-x&Y#BmTs%jQ{uHi1Xsp?a0YL1M+fi# zKEMmce|Q34;0@zHJc3W~it!(w!8dpZ|KK5fgqMu}@D#qnTgHEQ44>gO<3Buy@9-Y} zqXYDSE*SsO33@>{jQ{8eJ)tYce{_c4&>iDHIz*4?lJOs%qE~dw_>Yd!GrDH{N9X7r z-D7`voJY+6%hjFU$juLKv~3h2^M#lUmFl|r!;0<^L77iP{8#EnH@}D;elj5Qjo^aF zOEJtpmJTiI%Y4LJ*gTG#pVUb<(v$g$Un2d*0P~jz*Vg+opYb+aZtLbZd3PN3WWHnG zF8AGg?C$UjzRZVI)fFk+{OIDeUp$#FnUPH@yZKYf9?N~1PpPL@hq(FG@165{GT$-< z(#&`BuaLD-0hy1f*b|cbL*{4o`|t5(zGgax1>O8@_mI-e|GhlB_PhDruhph9|M#mU zibnr-vy2BaAM|(ZUFGJ7DF^<;{9mmJjdJtHW=~RUnNONLbF&)em%ld7XJx*rGOtg} z{=XTzuB4XvsGWEEir{lrd2Pb1%vW{&j$_>X_4}q}w9IGi;o0Zi{C4|4Ay($Qx_3k> zH?9>dn^wzw*#5r0l$#%SY4g~~d|9`u-_XsU`(|FIWIk=Dm+0o^*Z+p6Ff!lPRiX#D z`FAH>(UYJ3z^NU3JXd+s)tqt#!r7eBQ+FZ|Uau*K1~E{_kyANBn)1 z<}aW5p7}r5aXt4j|K~Y8kLNP~rybg(UFQGvgZ|Jj=Ku7Q{?c#e|JZ>&*v0%GJFyqL z;U9j$ANYm&KYqer_>K8Le#D>n760OA{Egr7KRAE~xPT8hffu+j{|86#1Xt$&;0)g2 z4*u`}KEMm+|L_F9z#HcO@CZJ^EBFP^;2XSS{tpk~BfMn(4^QDMyk-6mkKr@CX8sS) z;XAy?esq8y&;|2_8Suc$Ja#I|){-1Sfm7uIA2EI-DFq-wn4%<%z zWW6!?XVF4#{jtD{EWWHqdUwyi53)XaVn=yT)+_xo!{i*0tY2QvUCx*FOz%PIU)=iU zox4{8vfk-WJN0@0e{jZ#fUJjlhbk6!>!W*5PW5HI)SvP;;MPxcG zMVGFu|9k&EOzhVGSIl3eWIfjWUAvFZ`mDDx*2sFTy7_Y@w|*Nl`J|HdTyr&D8MnS$ zxZN=$>%Ho1=2h(Buy-THC-GxI%J|2KIv-(9HB(}2NZ{D1#;KqOc@|o{h|K~cc=RVf|c@EFxxkFh0mv(56c3J&*v0xkc49AfV?Tay{t&<5AN+*B@Ehy@_z{2NSJwaWGycZ!tp9@pcz_G* z{|+a?3*1=$2S@M(SMUXA@CJAI4-eo2ykPwwp1>D)!}>owf=}=Ye!(;N2Jcw^hllVH zUb6lVPvI-PW&Ix>!)JKS`ae8}@9>`We{_Hz&;{%N=mfo>8}x&Y&=a~sU+4_Ip*z<9 z(II+7m*^9nqE~dw`ae2G&*+-JL2V_6fTh#Sex4&7rOAq${gLA81b^D)V?Q8b`{ewN$x&6^YV**C@OTC}# zYz(k}TJL!;CHtvnX>hK`{%VbJgN^LBs{2JMIQyL#R6XMb5aKU}t?PPjU^+n-K*r;U>RYP(=U zCAWWlIAp0O``PO1Tez>WS;=J1*FPprTmHl#^ zqxT+<{qt0DdurKFw|n1Ca{KEK_BOGy->ysd$?X3Bu<@TPTK3~@f;6q&{(P$EGmPxl z>r|VExc&R56_5I|pKrrb3~>AVr4#+7WWQf^yk5nP|NP}M-?RVEbzIMV?Emu|_dIzn z`~S2+UePW3MaSqFU9&e1!%=l(=*-xB{9*7fmM zEFBJRaRq}A+hX%*-f)Y;@D0?uQi!XXQWm-Vuje>xH3Z{JUIew}17Xv(rXNr9_FVe*~4S)S7@qgZlij&;?Z_L50O5&kR zid{i){oRisKS4|&~$Hh-gOn=dncq((H(J&WZ)wa&>5fX2uLZwbC@mFalk9t|C&8*XeFLbMI3LSh_4%7v7eTBJDXtFC>MV>yIM0V z@p!s%szNS4Z{`mPwZ!Y$DmnVN_`S?i=lBxOr(0DY;^O-*l>F65yq~FcyoMY9`O9a% zC;pG?xSson|KmA4kLMEqM?17fyTt#|5BfvD=pX&0zx12>~aTJFyqL8UOJE z{=hH9|KTV6h2QWWe#D>n760OA{Egr7KRAE~xPT8hffu+D{|AoX39jG^&fpF1@E;z) z2Y3NL;0b(zH}D4@!6$e{{2x4nZ}1NO!9(~6FNyzyr|=ct68{H};WNA@{tuqRcX-eE zj}FiSx`>tdKXig#&<*i_=m zSEuxPH~&f6!S^H{+Wb>Izl)EavmsMZ;-yv3Ee&1#^xYG$e2J$Hc5hw8#sAkZ!GRZrQsBEGx-$?U}c zo1(Lhp?`aE<8Q?On^J|t4DsPthks=yUR-V2oXW+IXTO|4OFX%)QuT!*zI?~==|qU(M{E0eixr!tZ^LT|NW5(esS^ZOV(Gi63?zr)X(J;-#$4|O-sDH zU3M;x8$Z)W#yu6Lx(!s^g>r*e4#M66&_vdi&|1VRvvJ!8v zW}g0v{Cn1#0b1hmZIzC4ZdKy*f6(Dp;`MdWhs|C5{*!+PDT(K|Ph*C=`2KhmHY|KmseiC>BT$Itj1zsvkzfdhDe3;2K&c!3-7|KJFo z;0nIr4Bp@l{_p@kzzg^RPv8r@A^sm8!6$e{{69Q{Z}1NO!9(~6FNyz$r|=ct68{g6 z;WNA@{vV#hcX*He=m0&S3-p0b&i>aTg z`o!yP$TnqQ{7_kYEN^OT$iGZp)M;m(Iu%M{|tc`;QdVG_&v zv1=tRasJO+a&m^^eA%Zv`LvujGh?P^bmz~W$@nJc(RA)=sonXsmOp=|*9%E6&GN8pUZAMB*7cJFKDJf6PN_La~1yv*a;YdNoH zm*$r|dvbp7#H&+A&httBo#F0$U)gpOjGXr~g{m}g<3E4-%=euC<2tVAK6idlp2PEa zF3+bO+M`|Cryul(esTVfe$rq1&G|p8}x&Y&=b1i{2w|)Z|IKmf9McBqD#*Ip;PpVZqY9~M$hOPeWP>qj_$F)T&?)g zavnG==gdiAoDcqTXWs}pFC058-Z&Qru)5&yv2va`@YC2C?tJl(Mk`|Fym9bCseA7H z@yPV4JvomYoV_MA$ob?+k)wP$uk76%SImv?Tc_6Zgs&$`dZd2MwzM_Z@wdcXBla-Q4FZGPRI@1B?@+LQC% z>d}f{`CUh*y~_E2_3!r=JSU;ba&_(sl~ zn|!g7XG_kXubP%l%XxHj@kC0)`Sb=oBdnZP*GU?XUsv9**={L0&u$+bsp-zQr^}gF z$$57*=}bxa|9?x#wO!WAd3e=+Y*EGe_(`MMYdJ4(|0^HY{r{j>@%UEG)9a~+dsxob zchBq@Id5-{N7vGvzn>Ichx7l^pNfX_`7E#}D`ezi|E^KjAO@#{Kvaf8tmCi=Xi~e#igd03P7N`G0T%FL2|2 za0E|q1z&ImZ*Z5NH9UY1@PhOI@C3fV8}5fk@CjbQFL(yu;GOLM8+ZsG;U(w);VFED zx7-hp;WNC3-|!s1!+ZAs(E)lu7o7h`C+G#;a6dXiPv{DLp)>S`?l}LC4$&jJ%KVdKK6%HdmNP$n?BP3r)Y)GTEjQ=s$t4xoT zd?JArZ)dsuA{S273QE3_m@!F~y7$k*EQLMEN8&H5)jdFdlG}r7_>!;0o9@kU`Afof zq>hz*CjK|`4!Ha#HUB$A{vUti;5Y95cPc|>Bl%ENqNuAr`B9$c-Qh{T6!Rq8=lm%z zUhnrLpNiLfZivhOv+=}uBl%WTsH*SYzf0eZm9^>(rozqnEi=^(_de@{6AGXK30(~Mm4PD#ERzph$l zWc<<-R@bnS&qn|IFxrsc=1kFeTJqi4jd2^f@$XZw3QF?fsE`K5UH+e5-`BR1FGo%M zX%FM4eSN!`mV7!kUWL*wzfPITBaP(S(QW@X{@(aL1^Iux$#8nc@EFxxjdhC zXpeRo|LF()po@9>`SA040vbV2?fbb?;cjg0?J zN9YM%p)YiX-q0Q6KRQH@=#um92$Ns$bVT|Mx3l!Zo+2t2IPXb!|2L<>TTk+x`OiaVxc6J_KC67m zho)w>F7EQ9g%4csOTM(=w)Syd{=cjvdn(DNX1;i_)g!;!O63{Jx2E3jnC0eQ|5aM% zSI=_Te^_Lc%l|jpZda18%^cm(!y|v2`F^93d~WLJ40486^1GEP5fhYrZ)RSxi|F4j zeRGTaf2QEimxAPn`{!m{EBWGdl_M{h|EpYu_Ii>}&Q#lwQIlUTNzr%Y|1&2GhmikY zz5k(zm3(x%QrUNg{B-B`M=8lyXFIp7sL5Yfpxz55`Rx1>C$<~%+dXa}^WU8T{Y~o| zj(?;Dr7ww8Q;HqF$oF2CQ<-PJwG_or4( zZso>*{_>gc$^XZ7T+e;n&vSSl&n5pK?a&_WGXJL^^oM@YKl(|3={NcRumgLr3;VDW zd$Ak-;RpPIU+@op!e96e|KUgciC^(Ae#YPU9sh#^cz_G|fD?Fu8~A}Ec!DeVf-`u7 zJNUx`_y8~92Rwl<@CN?CBlrZb$o~h=;2XSS{tpk~BfNy4@D#qnTbchGcnqK6HTnPG zIedrr*pCj-1G*spA38xV=m!0uBlLu>$p44V&>Ol#f9McBqD%7sp;PpVZqY9~M$hOP zeWP>qj_zr{M&~5ak`FX&bpK@g$Pc=*MEwZK7aF^Iz$MNP$5yY=BV6){MoeDP&*c{_ z_g|3wzk%kR#>KM!cym-zPx6uaX%g0U`AIXsEFF-1rGY;4`?&nS6WZ+XC7-ER>ZKnf zzv<$ye)1&WsR>V=*sXuwnH}OuK2$H$y;m+j>YFm^23gemi6Gle+2c>ajt%RPN#*A`1R zjC{8CR&)(be%o>nQ<4AIJl)%s{5LvscVjF0aCO~3a=HAtCzn)Lk}ucJeb8FV`ni30 zT55TfU2dXwlyO`ONp^|K&Qa=RWS|IXsW&lK+=>XpeST z|EC}HhknsN`bmH3H~q&B?7=Sb|6(WhVmJ2V2mFCw@DF~%U-(Vd{}q13pZFF3;%EGg z-&y|$2k-zF@Bt_A0ypyif+Ki>EBJylc!N9qhX?QhUXcG6p1>D)1ApKVe1ccx|AlAp z4c@^&cnBZirOQt(JcY0D7XHFx_zbVf{|nFIJG^K8A040vbb&t533@>{?z6m*oFNr|1>kqF;23p3yb>M(5}q-DCgeipioSA9&bdFIhDC!5a)$ z5t1)FHp{s`B4qzCwoUeLA|#)9MEnYYAo<021y2Pf-*}*Thmmgoao?IX0m(=1uUpo_ zBR~1};|0k7A8b5$Uy%Ie|Jt3to!kFhR`g3H`Oy6q zYI1=5=%#u`Bl*(Rj0^Q#{`5FulYGgi?&sK($L0T@TW*SyeCwv}l&>6qS%zmal8;@z zy|UHiXWw18w~>79-puR|IR9@NXFQ=KpS#(h*+@%`yZrXcpRVyF-@Vx$t>pjzE$yb& z74?xtZ_F=kw|nHrKliejm3;a7%av^{`SUktoMZ`6xe>WeJi zeLN`jMgm#S{mTAhV8W@o5mJvN_}rHBs84bwVz4LmO8mLQHUuPoDKP6&7hmd`cyTvf zcJ)mX6_A>y+ZP4OH|EP*bXA(bVP9ILB zA3n%tcZR2R^<`SOO{1jVjLP2mu8Th_+OedSdNg|1#3P3KG|MJWq+X3Z*4oq5ugM-i zyOw%3rhc21LF(I#i(A-Ay&Jutc^x30{O2#9`JVbeT*vj?$NfBq=kZ+X|IiNY(Jt-N z5BfvDsQ*Jh=`a13_&?z6m*^9nqE~c_e$g>{M%U;YouhYjkNwu9h?aU_Vfp56j;21?wi=B{{mYknXI|rheck+L(UbAiLo;v77gE$m zTNjZ{Nxd|``KZtU_0!UJD`upgnu_io&@2nxU+g_|UU3SfN z_1RLlYVAqAHm`O0aYo{|RhNIy8L8){Zk!+M>boTy^@k_*-pn)qHu|@RzJ98fwA*No zOiSSE!>tV6WTal4zP>A+rG8x5xo4^Wr-n5$9`)tAg{Ra~Z_XCEms=Bm9;Z`3CH3gM zwa1L1KHZrFo|Sra`qk`IR^r#y!j{=Qsb^<0rp%|QZx>Ukj+T0Nw#CzZ?)`HyI!HY{ zy`+fzUtmsK-TAuY!di4i^gw}d9-qcYy*{(xe2A<6SMJwgTI%`PS5G8vR_gnWj2uk8KmD}hH*Wmr zFQ56I-?@(KxliK%EzjY3JeT@^v_pHeOZ)VL{?IS#|IttSOTXzqc3=;7VIOv4FLuK} z{D4333;w}R_zS<`Km3S4@hkqt&-fd^<9~1f4{!k=Z~`xI13z#CPjIFFA2@?IxPw1D zfDiD3`hV~QzQ7y!1CQVnyrTXeJcDoW4*tPI_y{kl{|8UuE4+oj@EAVBYxoV%;XAy? zesq8y&;|AX&lDfrjNceIuIsphcg(q+V$3+7^#p{m|@wu7K1NjSbdL6+wN`a*4+WrQT>@ zSg|DT{89HhFRA|`j_=k#i=6N5OFh)!S6i2P)JGlpyQidHs+m2ktgD~8?blqM)Km3F2D7{RzmvvH zF;Z_;O`qJ_oxe)AJx)OCv6_&iV_p5bnjp zahv+Ts&eO=j(-hiHKrb{Nirm!rao-;c>hxW*Tl4n&-p*E)K9yN)RWc29_O$_rM~Rm zwV$Z}tJdtC5aj$>yDIUt)T6Zpz6^8qX*=e8tfXG8+0!~9=hxJ;ZlPA{+3Ix_tGW8N ze^oO^>fL&)H!O1N-(?@w(NYiBCVx=f)yGX*W`L4<+m4 zx_>U2=1aX@Q~&P*vi{J?Mzr`|OFdqj_ERobpEr4de|)Let7{yrYpLJ+=*9O|>iO!h z9`DUisqb5&({k$l+Ldv7xbdIAeCB(8=Q^(EKJMo^Jdfv6|Ce@Xk9KLFe$XHKMg3p; zNq^}#{l^aM!7l3mVkh=uH|ziS0e|2Z>i^;={Dt4}AAZE2_?7y<_!)oWcl-|y-~le+ z15V%tZr}%w;0dna3(nvT?(iQTzz29i{a<(jU*HY=fk*HOUS*T|zwivc!8^|X!9(~6 zFF#5BUw8^%;Vt!l;W2!M*YF#j!*_Vk`ae2A59k7YpcC|hZqN@pLQm)leW5e-hVD53 zhYryrxi?o+^o*|2H#$e}=pOrz-$@lM^}xfT9wdt4bJoSdaH$s_yWq+V zS3i8z{jve6Cm!6H?XHUlcoLS4dgFopGd{ZW#~&N!@}(ZRSFr6mw;nKYnN(9h zep_ftE%oG0{^En({S$XaQEy%)KAXdG{`^AWd{*kw>$&l#x%*31m`S~Qn|NGlP5t_@ zEyA_bv$s{erSAT-uU1g+UN1RWP5%GiQrG{pmfbirtNxUCv%CL6iEXNI>D>0?i>6x6 z&)d{a{k}x2tA=Ien)5M z4c&46A047cbjk1N6uqKbIsYF-$LJYd^E*06@93V-MH;1vF8StRSl2DtW90o1_G|yq z;m@lyinYg2xbZ(%w#tF7vl<3l%_u{C@z?{6|BmTuY6tQkJ>uR!<<}JT_vZ@pBIo3# zK6zkJ)p)^H^QQ)rzb@n6UwJF+@fJ2Y>aU*_q`tY|s%FKM7 zUp-u0z{vYiB`bB%fAryH;9N81-k-m&t*Gub>}y6`ic<1^H9BQE_0tcB{jqtT$MXJd z_Mw9*K5&8BR&JY-_p@sHahB;Qxfm+!p5Wf!XVQ04mHKZp4aZ$p@_sjQE}v5ehpaLq zO-YC6`Qrg|w&hQ1=g`+i#s__4P*S`9m&fWU92N|e-7N1Zo2ug&yid{$G|NbZ{&&Gq)sNH>1(-!A72 zHfPY;lTBd!_m|zhuVQ9+w)?NW-T2R6KJz`la~;=nALBpI;dwll=hF`D(JtdZ{h&Ye zi~iA1`b)nV|FHvmunYUJ6MM0n@gG0n5B!3E@Du*RZ;b!=5r5)W{EMIQH-5+e-~b-r z0zTjbUf{;~502mouHXyK;0^BZA0EI5cmY4)34DP!jQ{WmKEW&a1<&9cyn}!65I(|7 z_z6$pE4*d=hsW?4Uc+yA4&UKD<3Bn;59k7YpcC|hZW#a35qd&b=nI{pH+0ANj}Flz zxM(5}q-DCf?&1s{9>0gB%on0nI<_BRrR;CP(TP%OVs=SFiU6cbuet%5uZaA3I;mYzvgns4GOovogO_aeGUS&?4jf1(#>L z`RCsYa_L)_OWQ^tOKO>)+V&gos+-c!=<=C-=C4}@B(lHcETz93UE9k1R)<8Dwuys@ zbo)K7{!Eqj_zrH(erfCvCBS&T_0XMM%D+zFO54;uHc(zF|)ePcI$`3 zF6u!2(gTC-dru0;`eN`!$u@!3dmhC09+#8-|G@RJ_k(-Z74SZ_ZsN=Oq!$(F@Atgd z%uBK)i(9`O@uWN=-Ucd6Dm56VKmiyq=|JOgC=GEzPI2d)~Wl+{f zz2RF@m~}ZK)WoUH-1_PMeD%z;RQXkS@84Me4>Wl@$oq3kdXsZbSGWFJzSk;MZqsU0 ztIurevm2W&k(!xzez0uS3vT_ke*JYO;igln{rp=-)_2vkKM$CYFJ`E_8?w0f|AWbS zRMYp%%;TN6l&lZiG|RuzV@oEr=NmjB|F227FRLOcQ`pv@^6J|2 z3tQHo3zST3$KQ@spO)le{ofDVTBuIvi)Wj>3U%w(2a8tMTUV8{cZ2D)tZ$p&eoCo! z<$v!@{{Em_|E`(4icQkHwH~>+jlG$-y6$%=t8LWwu)25tuFv}U*y9h>&SJ&v%?mBH ztgqYCeWeCSk_I+^(j0F6{kO$4ysszqRVShnSXrOf1;_TV;n#=gEiwJw`u!Kpve@6J zZc-sNjs<0X-y|)aM%Nut$395f-;MwL7(UL_bCOx8TRn~yAuS37uk$kjlqq#?fSPkK)~ zjq%^yndY_0GR5s*4$WN5FJECv;L^(w_BZ|g`<8g)r(gF&GbeKUpG~u5R5gD~W{TFm z?aBVAe>YO{2TaWA#XWS=?Vl!n+rS+EufOVAe58^6Rn_G}3sdDnF7-k3EztSWl1OJM|9QQk@0#gqW2&U~N6DKl`}4Md)azZ);CtI6Q9HMPpJDcM^=W%m z^Y8nk?C-0pMRVEqF^%=Y7X#e*&tE?CJ->4u*K;5H|2&81@m!uyJG4i;_@92zANocA z=qLUCQu@vQKXzabc3~fOVlQ@MKYqX;_yzyqC;Wxq*#F0m_!Gb4U;K=}@jLB<19*T7 z_<$35fgAh(;0T`J3clbB-rz2`Yj^-3;064EC-4Q{u>TK_;1j%pU+@gR!8_WAhwu?z z!cTY#U*RqL|L_<-!)y2r&*3|~Xa64^pa*n;KF|qzK{xFGqa*Z$uFw}cLvQGg_R%4F zM3?9jouXHC%lqj_$dCdeMy0!+ItP&v17@jKl|pr+?QhrhB=`(b0`E zxcI+0`_cz4J!=zeR%~WK;){aSZ|@JpX|O*y?ArQ(ynljezuFv;_RJpZU4k@B4I3 zRo|Sr@4o~!9kn^L*GefH%;`(XbGIWaHeAzmYYh((8`YL() z+(@(Y1NQbyKi{zaDoMdnrk1KI#p~}H^;u$I%aP*9-t4B!?9r}%>(4(<$T9hD8n4*j z67^kX*5OSudCehaZLt`R-;qz_nO;dI$#?ON8Ptc#5&7fWGmDa{L3I+k`mr)MPMJUB zPmpI0+}5Zs(V_LkzLiIhb`^NUF8(&>ukbKhh?<5iOi_C|MK^L`JohiM3+=jb1rnUsLxYt zHw?6)|Fu=qhACISC%Y{(_E9B~c5F+D`aUzdav@c^&u{jRZ3Eo(pRat+&-wp6j>q#n z*8i~`w#RnaKKo&R?3ev>92^hF#qn{R952Vs`ajNt^WnTWKhBf$<-B?QXB-$0#)a`= zoLsyRH^z@~WIP#H#+Pwsycu`KpLt+Dm>1@Ud1AhpH`f0#kIX0Y%KS3V%s2B+{>cG( zAQ$9=oRAlC!}>pRM4reM`66fJjogtxa!4M@CHW+$V=j5H-^ZHL6 zP!H4v^+BCbFVqd||EMGCiMpb`s59z~x}*N6L+X*bq&}%r>Xo`>{U3EqJyX}zH+4?E zQ}>*I*L-OrYKVB@3ulet{@~%^ao0u;O%N}<@2sg@{~xT8{Z-%{wvySGX`F}pV*ljO zvtH&*kNq2+U%2}JKI?XQlWMo~A8*MUKz*{8Va!86`}I;HPKgn&etF1|eR|sD|SX!}f(o!u(y%wmCHr0L)ll7z4G!L&dboJBY!)&H-VI>prKvr@MDeXBuzwmh(7gIRfYt}K|ZhpXRC zm3gqfQ8}-k(K3}peYe>kxm7OOeidsu-%EZs*%F7{yg&SKJzGVeHpqriAH@oyx&&I zh{qpHtMj3*{=euSl~n5T)$GR&Wfkh%ZI*NimACJNsa>e9`~F!os-cOJ`l1{YKb1v& zy!t+_k^Q!#z50>4gR7rku}RoeH&d#b+fK9oU)C)x#g<`HP4w5_T>bs2QuS5b3*BvD zF<7BK-(CuDtDd|pYX_`J>FW1eWKSW}tve=8UfpC+->(XF7xu);)~Z9*LGJp`SH9=x z{C^(D<9QzI|Je@PW4mmh{jfjw%ldzggX7`2I6jV(;K6Sc_LTji=2@+a>x3Aa!4M@CHW+$%rGIizcVeXsmA%3++ced4;&@2zRFB3)L(AN)5KhARM4%z+L57^I9uTluWRq1#`-MzS9pJO zbp2vE;@}>)errhH%O>WdOLE2L;|A-y`GyP~p6Q9C?w&%YZE z2v-s3>)679mI~|R?5(CvRJ<=0Z0-@c-1@mYpEtvTA zR>u8rTXphSU;CisAeDS%FRU$SrdBtQ_Hc=mYS_oqT)!``Oh4wO8aUA0Ztz%QeVXU&fj7X51Nn=7ITOUYH-| ziTPsQm_O!``D9+1U*?(lX5Ps^IUo<@f_#t@@P)l@T*T_2b)L4 z3N#M*t{$LC{d9q8{{(}HZfEnbzSyt*Xp^_L_-#MVf|zdo@ua%>#EcEa^Jk#G7NGpn6?4_~3S-jYLRzFMnK|~oG*Zuyv=AU$CXtQ)O z!CKVlHV=`#AK%owdMp)}hvs(rOnx#<)a_(+RFzm_eYM$Kvx|(~ZoJ9aV6MdPujba? z<#P6wC8kEoSrY5B&B3{~W!HMi&BQ26Tz&^GU874D%qdT=7;Lb%-;QmCMY#zgo%oub#R7zfO8D%%r~NQm$PR>&s2N^YPT& z)EVr#ec0>%TOpgbOCi9$z?%Q8xXIY!h=*H1TCO^&6b=#zz`oG_!$5$*Rzx~{8 zPJa(kSYK~r4X>h(Zxj7qOJRM!?XWhU8v1L$>D{=3>%Ur! zie}~AgYxaR1QzT2Rm++6?UNR$C5$)JUH|#Y_xzmy&*OMJ&m$jfhwZUlw$FapANyth z90$k4adCVcC&$Zi^L);O^WnTWKhBf$<-9q6#)0u*To@n5iSc6Gc)p7x;>ox&zKk>D z&A2oE%meemyf8n^6Z6Hq@qFfy`D9+1U*?(lX5R7NiX4y!azQ@G33(wmJf9qqCvru; z$QgMfcjS*8l1Fk$KFKM0CAU1E9Fu2qO}@!Fc_;V${hvCZ9;gfIgF2yJs2iS79Z^rz z74=1(QE${8*Z)(8)FX9CeNv~?D|O5BsblJyx~9IVbLySC=l|&IQ&QLB@qKsB@TYe6G?v&e_*TO-ltC6{jmE_-1`5g-SdhS z?aJ$tv6~3^ljv;gx{D&QyXa!6e{=pNquZqtUH(4g=S}-70Dlv2!qO1^{Bj%7WBy9_ z{kQl-R1+4GTK<_WuYo^`+&i$mX>+==JT$eUp?}Jc?)l80MUu;rgPzgW{H1|U{O8C2& zk*7P$TrsnmV~01o{0wWhQ;&RKO#U-qyn#QA{59)_$$a{ojCL)arGLzjU+HX?)}d<4 ze`zfIWmIr_h*eh~%e18<-Sy|_s!+45Un22j*KPrS8q?s)CRzBOf6Srk37!8>i4LXI zJ?xD)vQSM0e;a%6O*M70OBs9hTp@S;8=U8-d^pvZu^)QU|3|mkJ5IN(-%5s0_YJO} zs^sM?b_ABOJvrCF!e2+N7~RVr>C#u3#68{hw+f!UZ_ipv)f$(^!kY$Z}al$9{KcfG}~%!4h4T7d!$zjb@yQ}+q3ZR?)uMHzUSxse;&ur?aB46Z;ypcOz|H&bFB$woqoRU{^OMb~Qc_!E7o1Bw(a?k5ObwE8(7t{xJ zLcLHoxc)mGQBTwr^+lagZ`2*H|I{J%NL^B&)G75!-BQ2QG4)JcQ{U7%^-kS${*8;I zkLZ*lRd|YV%Ol|r7Pv6KL@@MMtAHPUP!RVIfieBd1l8#M;R8N*3WvW~@Lbh+-cP@^ zpMJzDcmGi;FylQcY#y z*^|uG0c&N(pVlmBe^s9U@2RoTKk@ox&+Ln;R*i^aQ}y{Q;SXohKe;TUdXc7H`b84= zkLLV_RPxA}!TSE(pFaHMP{ZBEXj;aS$x z|IgHHR6*nq9uXf;^ym728MZo_T{I5+V}154{QcD2bRBKQ%l*`|Lc`qkpRat+&-wp6 zj>q#np3ipJ9@}O6?1%laU*7+792^hF#qn{R952Vs@pB%W59h`Cah{wn=S}_?2gZYO zVSE@T#*1-d{1`{ZlW}Ey8E3|uap(O%^T2#CFU$|~#C$Pt%pdc}d@`@hFZ0ZNGw;kl zIUo<@f_#t@@=-Fhlh$s@TWpX8Lhl3Vgij>$8*Cg0?oypwy* zpE{r(s0-?YI-y>u8|sHTqMoQL>Wey~-l#j?|5Jz5BXvoAQm51_bxZwH$J8@*O?^}6 z)H`+0{_pHfA2B9Jn()b+*F?e}G|*&7mEfm#V*>rA{u!iyXv!Zug6+Dj34D${ItYK! z!2Kp!!Z(he5?tCbseAtarsx*WmV55kJ&{ttpHz=K-b!59F-Cv8F;CFHbV!v*ajC)y zeS6Xs5$t|P$Ef;HM2>r?3oO3lp8s!|cSx*%vRVInF`fRuI{v%acfguPfNqpjI$;Lj@K8)rRX`ipVOb;ZKPN@I+|&Iv4Vs@tQp*Q zjZB&Sh^hDef%A_|*(RP!d?tlWQ#6BuzpOo&CYMT7A-BDKFsI`4=bIzbtI3Cx+U9Ly zD)`fy&I3=&i4ki|`SAm|e%-X{++Eaenn^5clYsuV^5n=(X2#FI<+u1T@b_<8wfRSW zTP~|o9hTRy@W)lBC$_frCv;FUMkh=E+*o0)?C=i_)u}*L3x8deBTY`bGJg{FbmCk3 z@8h@ZF{a|JB=Y{JLq7a@_33KOWS%D*%&3kJQS%hv2EJui1=oA_(3si^{=WA3A3fC8 z{DW+hIK$obpRat+&-wp6j>q#np3ipJ9@}O6?1%laU-r*&a6B9r$H#GUyc{>j&v|e@ zZeExl=gIkU-kd+&kR$R$uE-ZTBX8u6&;Q9Gc_f$Qlbn)Q za!Y>6F?lA}HKnCXg-taVNU0tJ}OQs`M5+}Gxqp@^#9lM7p)S1?QN%<9e?efFAN(VMK2vRRy2xs zn*Qu^+P6aHLxVhUYC*4@6Dh;zr6D8rKy-Yz8cvhlk@*i-Lt%{v8$dc_p+6R zzrRYcrk{=ddWc#aIow_U`O5eFod3_`cs$R;@BgkHw#RnaKKo&R?3es-92^hF#qn{R z952Vs@pB%W59h`Cah{wn=gs*u4vYum!uT*wj2Gj^_%V)*C*#WaGR}-Q2j+u$ zVSbn==8Jh_{+LJRlX+!+nP=vkdB^FB9FPZcK|aU{c_BCS|0hS}iCmE{az@_B9s4JT zVdkTKByDwg}TA-|4v8L6Lm#>QD@W} zb;tgxL+X*bq&}%r>Xo{seyL;XnYyOFsdMU`y65?ghJ;4c&6hqre%URN*dHVi^+o$& z=bFm{Pw!rE`~Qd+>HYXmi+k;tR`;>Li1%l*9)9ye1H4*i2KcN$O5d-Ue>t7wv%g(1Fee@Bm;5u8j(M++#?tfF7ZljvM9+`*hd3XyR6pvu&wc-mig+WI zC5dH*#7rr%KMK}m7L!N+DQi~LsUuN8WqMTYCeIBSWV#+3C9%JX@h(l0eREDT=Vr~2 ztiRgUVwOC=Xr?)VdKB!>V*dRP&*Za@Hf_K4m)yT4OQ||?-HC8>a(8C#|6|VIJSTG8 zpQeX>OzQZV`deCkZ`q%s!RtSntvO}bFRVt*PnEw-}1%_^fNM1d!Mm2zrX`?9uC ztO|?|3~f}7hyh*SuFDx8^rbV z@`ZY$^KA_m3%&(C?60Fg@69d~-RWk^?_Eg$e-m%m9rONZVWm@^-L0-*s2m-^YIMHCU}kHVj?>Bi!|$uYAwX`TsnQ$MZby|HF3J z9@}O6?1%laU-r*&a6B9r$H#GUyc{>j&v|e@oEPWEd2+s-H?RMU1LMKCFg}bE zB6r5n@Y!p(Mq+=kz_NHfgMl3z0&UYjbo>8({kN$9a7<$_$N1qs_80T!#b4_uOc~*w zZ+6Pn|6l(0!k0t8cwfpz)7YO3zj4IYaht{w|K5nDQNJvr?fvE-|NhK7y5^#f{mr~q zFJ}4`qSp4xZT+7=Y3zAl0_$##@pJS!?_qy5U3QQXtAFdIUpJT~xPRKeb5DtaQ=aQn zLt;qmuV#|n$tj2a8)gcRtS(u9z2!e)uqXYVeF`fYRZ z(lPlh)&-N|^$m&r-Au&7=dwikcV=UkFYf+7_zinOtc+pLy^5uZYDMk%wp!A73j531eu-kK9+g7u)GtvK>(76m_g415_QVWKe4G2zn-oJ2 z%R77bn2_k}CF<8r<0s?g;N0Df|F$ys|1-ndeHQVLuG2k_=XT#el`G`e3H4thRrC<< zk0+B2ZDHC)87JEvSYl8=FU!6X*dE(u`|OAPv0v8za~vEG$Hnn+oE$I5&GB;{oDb*4`Ej0{ zFXv7E7zf6KabbKIC&r6$WBeFL#*=Ynd>LoPn{j9SnFr>Bd0~E-C+3TJ9DU*wFukvsB74#^|AB%kDzypmh;OODAi zxhCJ_oV=5J&YwD<9;gfIgF2yJs2l2sI-;JaE9#3nqu!`H*8fw7)FX9CeNv~?D|O5L z|EOc?nYyOFsdMU`x@Z48{tk^uvpqDtTdM7m*dH`-dUn6yy3ShzZ`QwZ`~MaxQPv-m zy@$8**EApdi+b&h#{Q(DA z`H6QnvH4nell@}ItFoow1kz9XP z=J-t6xAYSH_PthOe_GSOl`ltEIA(?hE=sIlGao8HmAe|fH`m+$l-S?aW-S?4`CAjg z-#P{U{!MEWUeBmHgl4y;Yv)neAJ>lSUrdc}8)m~wNX7kg!$wt7T|QK^NufRLuWLj5 zH&&NwHM47fwZ#2zTb$oP{qdu-ee|}Q!v4HAF81MRv$&ris)-|PhX?<={_~aZ`8ofe$MJZc$Me|^+he&kR$R$uE-ZTBX8u6{E;mi&@q@=UJDH#sNoQD@W}b;tF8 z)FJgqT~eRaDfLR-a{piIn0ltJsc-6>dZ+F=|GQ5@BaYt>4PP*8dnEP;4|qKW1fwTQkNw5HNx`%J@SgvANds}*`s33(3hHtz%8OE4urJZ2 z-r{+zKlJ>qGsW&ZOWpqE@lQqSPh(Dqy}|1m`NO$D16?w@`tc@H!0*dW>c!YG6N)n&zhrkMScXUTMB7r6D; zFK)xL{lEq}ZO2xF{n_Q7eL<7p^a1(p=`q9o+ph&Ko4Y-4${ic-8SL*a@8)@BYV>+9 zH|_o6?*H>q#np3ipJ z9@}O6?1%laU-r*&a6B9r$H#GUyc{>j&v|e@oEPWEd2+s-H-GM;E&8B6OaA$^w?ecF`{)nUqu$$ypSfyBE`7f`lJ$eF`xFS4Thb$V zqUzEh{ROJ;i0W^sm)ZY`{e}7a!-Njg{HIyh`*T+vraysSBwKVn;ZzDe@JDXeFX|$p zjr5fiy>x>{f6(7ZM`^cG*T}X*pV@VgfB)#`@*f?y=oejVKur37n0z(UnJ?vXm_9QL zvwp&y%~r)MY16>GebSo#N@m+`JS81G*5oNNnZLi7FAo-&z?EgD@wm< z&q!@0UCDcQVb!y)<6-_omBgcm1~s(?++wGsLtqUL5*E*y;1I zzPE4^TVP8v){odbrBmA`4bs|V<WU%d*r|0u8o4H_Wdthw} zd-YjT`eWFCF2}cRhsUvvKE`1Ej2*w}yNNU6KeOWV3qyYm@7WDgw!?YTdhSvF{$?Um z?Jy<#tTXkdE;01y>Xc%f`7K3%Q*~u?w|`ggXnxbQR|=Eqz!yz_k0br&>0-Ak>o?I( zxceWxdU!AJxxoJm94BzR#CdN25VRxFo^vWL3z6LOvAoqUisHJSpT$A#bezRmh`4J{9sxe>a6ZE96@t@4Ww4 z;6Q>02`=dWA;F0RFB06a{zrl%37#allJx%oXA-gKt}?463`X>zdY#7 zgWf#o&g1hx=+J{6J?N7DJOSu50KEpFTh{-EL&xFJb2xMzM*k1!ycG0a61p$JZ@qkP zKJCe~XyCpoy=y!F&x@mbMwWVdCi2xESy(?1tXOVEykyGVaS-SX83 zJ?&?7^IvrL_rDo`D1*t|G^eStt|0vp4E|&@8&Xy@6Ngo2{e(#r)(C4qelvgUXkqBD zaJf+%lVwI5V^*|g{e{_oRX|4L{gR{qcj zn%;E&9}kO6)*Bv5JtqEP$N%kTXS{>+>WZv2R|xt;c3T-w#^{+xe*98}^&|3+o`1;y ze$AEb_NABtNc+Kga4)~X|HDL*nD=>|1W8TZsthiccL|EG$CZ+4<~o{BZ4IO}iJfm}IM_w}J_%G%`g=TOnYqpD>3 zmE5GRbN!AyUUHMHa&fk-a&MsX|L7P$r7XAfxaj@9vU~oBSB>`?pF96g9A|L6!FjA7 zGHA!3J%e`XFKW?`MSm9k^7)^|I4s6vF)sRlSd7zRycXl;`X7sVSj@*_UY7nJn5V^j zE#}R?|1IKR5f6*F(Er0CP8RX9h#TvFEaGSpPm8$H|I;GQ7V)--JL`W8@?ek;gS^oH z!yr!v`7+2G*Z&yg(IB4&d8PlSMxHhDt&w+^e{kS|2LUde|0g&R;6;EN*8fOwB*Bve zSM-;a;7o!y3GVp(Pl7`U9woS>|Az#p61+-q%k@7J982&l!8K}>N=k4p!MgCfXqryleg zfNle<|ACGJ&~rF+?fgHW^DyYW6m;+O@7)U9o4bC*zO2g^JOA$+t?(RRRjT0U_{p=>MfxUe2NS`BKO0--!MMdi{^FdgJJs z`ugTSxqeaKjJZoU^0hvY^(g&~^}%=-brgrldcHEm)zB9ag7_&G*0h89T9g7aKXUyPa0Or=`Ef^+P>u{!ZQO z58PMt`CHnk&284)4Q!Ga)#=Y+=fy8!&o#KwVLl4;QuP18JQe1vFmHGLM;sL5ArTk)e@MhhB3=@4bNhcF zjso#yTz&d~AkG@`Hi*07^FQRlARh*Kp+Ad3o(%G3kTOkL1D*`HGW7odX9m0(a7X_y4GuMU)Zo(j(}U9> zc=f=o$NC>|EWon>*Mj~Z;9P)r0q))PA36}wgMcpR{~@3g0lf(5hV?%JIug*6fUfBO zEub?2y$R@!^}hl-^q@x%x}^Vy2c3G*s|Ve3{eA#C4nWTV=sKMKAJBOi^j-?OFUjlw z-c7uKb@1qa>*`NLeI!~1DddRbudTWE~-2X!- zYJ@dQQO@~Kx-@s+ze%bL_R@t%7jp~Mr2mJg8H^C2(f$z$kH=yCgiIK>loU5>$_ZcF zaeoDw_R2W|qZ*UD3w*VCUtifL=)vn(rQqX~=X-yjdH8Yi#p z=_4ndtH=F6WZ~^`WYf=DBsyQtUH@8atf6zyzMu}=8l%!AEVg$YqD%0 zikd$^8S7_M&PgTI%RLoT`E>QTzlOT^xT6Y<)l;3g+L!BZRIR`OmDu!E9ZvP2KZiQ} z7k;g?sbekhTtgR#m?>_G4k5`TN2A>=5|AFHS zj<-0E^*xt@23#5Xe}FRs-VC_o^FIR)4R|!*lKvkCoEq?Iz^!5Z4>&g9S%Yg${||7k!Mg_c zj(_ODgC0ESg8m-@IuX!|fNog-BcLMzJqhSa(EkHE6VRK0?zsL(K!*Z)^q@=ne|XTT z2fcdGE&V?N&~X5I4nWu8^#6d)!=U$4(7n_D=#`81-tUtpqS}gI5!@eW*5d@hiTQg3 zx2)O2`X9f?sltASoE`n;hi7nqA%Eefvwq_1Fa6)khVb_XJ@9U7UH;!t?X}84e*(R! zQ9`{X=NErv!(%?{7Z%?7J9w$s(m=-&b3FPRunGPg7QI+Fw(KENsmB3ArF~8+q+fD|xW#Z<78BS8A1&B^DHrLsF;Y`U_F};$Nam z`ATB^*Ek;cXUg`+YQ11~G&Ay0QTjKT6w4=>M>kfOdVlRT^mmw4@wQo=?WK8g^%I}} z+wD1{*|lY&*(SwN3y%Gva=v_S5{$iJ=AAyo`Vq6M&J>fVLqjtvO+xPfrMo2<>s`2W zT>RJ>=C1!QYHyeAcixbbAO500g<91+vsziCpvpWWoc>iRU#=?ZQIzUx+pcPg{ubx^ zmQgRqmQX=Z1%3DZTcU1 zY=xUix&N0b8?w*z+AzqRSpU`O53d66B|fJ=h{SOU$19x2`X7aM6xvg0SJD3i{V4RO z(677xV;lsi3$b+6d=!*O63Fu5fZvwh=*MI0xK#v}DN&gQII`yDe54xrQmj@jOpyvQ|&HcZ^ zq4O~4Jq)^c`mgm{#NM@aOGc!-o{Ihek(q~Q4>n6aF?j6JS=RsfffQx@)^+>&rwY&E z{(}DXH3$7Oxi9(2``&W*|6A%^@K?8v@S``H?e-_^e!q5b@8Cy)U7Z$rtY0{nsIoI9==(4n}y{~xw=jLElWuBqC64gDF+rQt!7>-K(A;l%;^ zH<~YT_Lwy{*PCm1=NbAtJULU1}np=0yYW-_$Ou-PFcY4eXP8)##65 zvn)BO<8H;9Jwz%CF`G};ML&0 z!RPb`u{h4+c#HE`|6|dPMSB+Qa{o_@ek}U4=-1u4hr#5hztEc6yl^1FNL_V{zoE?67dv>tMgYuoDJe_ z5O>4-f8@a;9~OC`|A$4MEb?WMH_Q4TGxE4R|-;p1=PY=)gb^8oHqWhlWlx^rE2~*3W6^$cLVS(3SJofzCYW&4cbd-v2{~ z9`xuzm-PSepi>We^`Kk&e|pey0D2BU*WCXz96Aq&-ov1Kr~e6`uI+7ppnk-Q_yy?? z5ZP~Gc(8Wb1;Hlq@3a2L|MtD2f8=@}zwd)7++WyF@pYv?>C|#R`PEtO`Ty!~Y5W&0 z(gx>eze;}sZ>Rd#dpgFw{kovPLFAHuMe)=B3jfyso_`ie zxK~6uJzX^DBj}IdO~2RCA6=-5o*8o+>nHTaJlRb3iOILko<7v{E7X|&3?|{E7y9(?ZFR+;={?qO{BbC?%(xKiPt7du?<`CGc2?FZ z{#cHR>-=BUQ+Ubmzx7>S$n-D$KV;Rvg7W!`dGhSxMywwZX;bz0mLH7Nhk8{r^q1)L zgH5S#7$J1?{m>CG4u4rRYy#|Jju6*8W2ggF+NsD#EmgAZ^;tioYQ)T| zR;*2+hNx?j{u*g(zXGpHH}M;~=l{=JgxJ@Qa@evF<>}91i*4y)tMnXfYn}g{{@wPE zl-=#)woUD|&@$Zr+pdW5-FR&_n}=}<^6#H0c$IiB@j3lL6pm9kUg12}|0uMh(4IoO zivAzyN1;E3e(66dF%F6G2#kyVBnIO&7_Y^+E$e?U4~zL&%!~VfTg=m9z83R#*MG#p zARY#Bar>hqP6F|gh#TvFB;u$LPldQD#8)BC3h`EmJO2L2s*neTd`RSl{vQ%~lE@eH z=Cl3>c{IqUL0-B4w?Uo_@@T5*H#qXalK@wO{vY5> zf;S27-1C2MD8VDvi%*u^{~Mf2@G8MA{l5h`7T{TcYmfdP;9P@u4es6bA3D&`gN82X z|DmB14ZUdShV?%hI?~XShOT`2e?VtJ=q&)wos7i{lL*KF^Et?VT6@7xpAB)m*GxFir$6 zEav_NqGYkXB60pm5wrL%L4Sjf87GOQF{_CWO>TMQ??{Tz{-RwY_0C#H=#OB&p3Z8v zN@W^GZ@~Hqvt?9gv+!DbllOijLw|*A)6<(}b?@nDE4#bz?}GbBh+i+G%Hd(<=+7W` zq*x-S$J;4aBysyU$U8aD%dm4NV(U`?i>{C|Jvr$y26wirrx#% z^oKCRpS?B*7RR#Zq9kMeh^KHkv&zz8Lsp*ctVu^+f|)sz5u|&)9j3I@+q+ezU7$RkHNgh_*7OEigXP#4Ltw zb@8uW@-i|`aU(-k#ic)oDjlVcO8dE!x)E!TV*Sqiz+kmA&{b7Sh_$`&_ZSyDp}Kee zkW6GMx&HBL@ZR8a`hQp)XK}p6d944jXvd;Gi*_yjKhTdwe+K=!{xJ@T@koqIVSEbX zR2Z+qxE1SvFb{?KD9lUI{{!=sn6JdVUH^!KK|BoNLVpyCI9bHYB5thzv52EZJT2mC z>HmQ^8^qfn?yi62K_VX#d7(dxM4lA#rI0tp`XA&`A)g9)mGu8Wo+a`vk$0DWaG=41 z0T=ZDFyO?17Xxls|6{*Mg7hEs>NGs* z_1&ICj4v; zWVM*)b^Q#cpD09s1oJ*&z!aQX*!)v1)bRS>u*D|5D0)(T?eqeV{tE9N$Cb%1mzU>1 z4RYVVb^5K4V(JE5gEr8gL4L|MO$Hx!kO^aE;r?#k9_l&WrW#)VE2l_m&lW0ZC)X}- z>2Gl?dR=>_ZxuUccL{g>yPM;s>79L^8C32T{V~MV#nWY)y02u)ZkgQmzek;BszAxE z>dU?!ivAkLIv3d~nx-tO-o#6ck*3UQ(T zheDhb;-wHb#p^%fC=pMAxN7=;AkGHyHi*0X`wMxn$cIH<=>K7nCxd($tS97ynhXTp*6|B&EBf){ebzaKR?GT_O8D?|SeaAv@p0e9~2 zPjG0!qXCx&e3DZiyb5qDc>M>*5I`yDe54v^Nf9N;>JqMuc0R2Cp z^Kj@r47xAH@2}H?((GGyV@^bwkv-`D5gZh=Q?T=pZNcpeU%UJNQTHbW~#gYShO>xIGEcLCptH!KY?gIwwE{*Xf0w^65PK)q$>ZL7dIq> ze5tWI>#X$az5VI-|IB$Q zfy`K|w5+$gi=@B8rN}9=p*KaYS}@w(e`Ot(OIA*QL_GR;q6dElef*D1Chf!i#-F*| z-Txo|_kvl}=7#xe{3Szwhou#knS5i~o8`OSx$o~U&wq+_MTW@_GxpIRLKdzNOJz!y zR2?sy+};0I+Wb|nzI{S2Su;t}UqVI?(Q-#c^YqIOcmH{!Qd)cO?*evBy)gPy*s&&` z4V+J5U#58O?*F$ReyMNgS}qRMm@MgUQRrlP6%Y5pyN}gz_rH%)HdO7$msgqB=b%4^ zyct*|cYog{%1(*x?*D6Tif=2OFKK7BZEWeU(Kl`%+p}b6doNdAcmMr&ho2^6B}m6vjpW4~20mj8|dY%B^3T z5}WhUn3tjd2j*!pUyFI;`>&}*94z8t5f}QS7{tjSUK(+8`+p*i67f`stD^r0;;ayF zg}A%tFUW&LKA0DQ{21iPAYTS~iE5Evw8+ZQ?jwE=J;7Zc}1DyHbO@ll4{0STy@Myp#{XYyiHQ?2NTkc<@!LbjXJ#a1P z{{hY=c$eVbJ^z9ZB=jJl3;KTu=tMv-9(3dL{vSHh(36I)wDbSy+*Ctv8oJ~DA3k*G zLytam83}y`pwj^K>Or^e{vSFHK+gf_Izayq=sX;H4}3{i@Q#Y$WUjLbHucp62^2wj|i1ks-hpivn^?$~W zC3;1#tU6V{$pQEyh;}D0ikq#{$S*(3xaa?Cdv=#gye_h8#rl%|3LDxz5-Vcl6Wi0K zaL->auc%@MG?`#Fy20MxaqQj#SKagHblJD*62q^G*D7yux|z`9IoGXiuVD z=l_9z4EnR^7uVmm7UQrOkHxs?|6wssi}4za+pYh_JS66$FfT=a6U`9I=l5l@S_TKaz=&Ia+;h`V6@1@a(~4~4uaiDQ^S9u@fCmFE=>K8Bi3TqoxN*<_!I1<{5?o38e}FRy z-XyqlzdwOP@~FY32A>9;8t`hst$Y3tjtzJ=;9ArF1DprJy8!os*MI0hKo1hSp#O(} zP6YHKpc}#G|Ikqodh($wP5%$*Oha!Px^ut3L5Du{=tGx2{6DDE0Q4GwZr$^L=r{m9 z2cYW!{Xd}daOgb@x_A2D*QDgWE8Vw7d@eVU{vW~qvVU;z%Pqkzk(b@?|J61GgKy@j z;L>eR!|5;3Fvl3LQHo<;qq@=E?~k#v ztNhh^@9HCZ%C>8o{stuq?$?nmXX{1(W_91cTW6LMA8$m8iRI(aA3=^yP+pdcSxruu zq}=cSnFibwm9mx8~*4ND>9)dxPoH=^1E zUlZE+9~0Sj1w$-<|1X_kwkcHmvu;^wxS+p8+9p?Iv&soo*;zT<@6QD@~U?bc;lrqZA1k3udp8<6t?;6RkraD)UfooxIZhaEs1)%kLiXw{mCpN<5rj)!{6UITeVRks1@Yz|4&xjkq4%S$s9X_n*JJ}gK2ENRaNctfnD71@BbX` zX2-3pX*<@;VDs#?reE44y2r8dvO>4l+`mI*P2WmA-Zxkk#D3oN_h`MWf_jxTp&GF0 zfBSFY)!@Cw=k))uIL_jDi}T#?|7gdcJ+>>*zC=F?{VDY8>JKmuh4CniOJRH*r@(j( z#?AdpEaqV`AB%Ze`hQ@a7V|Zjx0^rWAQ2CVxX}MYAx;YMQivPC)V88|a zKMXiA;KhI&_xnFMGT=#rD?$Gca3;Z<1b43f1RP56D8Z!!pXAg7uNvHP{~8014R|)- z+R*<4oEz}2!M)=jIuOuhLw|*9gD0Ae?S`8B|5SAK zSH17;_v`;yEw23x(4Rrh%(hilopC_s*tFl(|81N#T5idoOfKzF$fLhQh8Yt~mI;SU z#?V*f&-RM<#oXV0%@i-al>QLr;M&&S*Habb=WhGx|0VmiOR1hc&7c}qOr_{Aaq`7Z znWat+dEtI_`hOem%X9N4GQHg%w>bSN?C>20?5c%{Y^!YtxPOHiFz$$WyzVdgc6vfZ ze~Z<_YO6D=>#2Tu%ed=bkpV|#*OSp?s`F{+k73H6$ZiL(t!?-I(}Dh3cGZ9ycI>u{ zc6QW*hW;AcTGy8w=6;nY$A`J=|JMBj)T1Q5Rl-Yk>Cd4~yxJwhK35QT9*;Au|2t5> zvP~20X`g-=Zt3r_Hl&Ufol@IfbCx^(;Z@?j!sqn=P&iKEc!l%m|E16l+tX;*pnZ#e zEc&zP*IoZH4vX;^jEmzF7^lQ|6~^uA|1b}Q`6$dw(fgAZMJ(1(Cd1oR@H z8(04a9SP`3Kv&dP06O!bHy^rl*MI0xLytamN&gQYI;CDCp<7q~2OS5X=Kypap#KMS z9uB>SLHADovrg3CH>u9?h^)01(ElUY?NHy~ymm{1r@yao_5W|mr;jW#VOn6ykwPB* z1%^#L?lr9Z+6znn+1>wN7W2G11s4TsO|0+3pFsb+vw>dUd9vQOWvQ$GpVM)YKK)(j z5}k)Te}ir-Mu;s5&WLTVL)`t(#SJOs`X5o{gt>bJ{1L=n^~C?4>yTdc68G__|8IS& zyUCrThuJczwxPd5pSKhA_lu9c*+rtc`~ON==E!<)*2~2`HqxI#?p)ha4vKkShX>tGnK?ZdnY?9kIsS+5D@+Eqhj=@kd1y% zqxSa?Qzd12SO0&$Zwj?(#(tS*`#a}vk$UzGv#?!uJA0|y|JpV?Q_I#Yo6lA+|AhV+ z=1r5Bvi9N|GFF>>uKvIA-(A(!DQ(rEa-|jhHA;=|D$As`deztq+<()4+}P6QsXNea zPSl6~9Co9R^{yRene>w?3fBMEUYAFmo6<@>tN6R3zsLJZzhOV`EULhO&E!7{UJc$` zd`|xli{mVgw>XdfpKM2?J&AS|{Xfu;LVpVVy7~i*gX0kxm%;cf#%VELi*dX9f6T*T zKAe~H|G+#Y=BqGo_xuBKP>6>@T@}7hW;Pm%z!ro?%e%9I5gnV2bThTN^mN{s|2^M{vRAm@Jz0qzYRD?jeJxC z?%ne*=)gb^8oJQ%|L~y`4|);MjjR8Mjs)~1pesTD59o|~gTvrFSAPQ?`p}~fUDE%< zhfaOyH3;2u|DFJJ9Dtq!&~1j)93q2Bqq^sx3onlp&0~ak z@z1rOKZ2gzDX)2Ru)5j%w4Pi4cRpnt6LzY%j#2ifM}LL>tsBVT*NL)4iT|y?DuM6Y zn7NZkb>^%Ge+C`>dk3>6Y^|C2>9AY>*SF?Q(<9?(Gx@K7oxek&@(pD5R=Z@v?@!(L zf5F}V$u&QY%7`ojCHx`8y$Wee(tCfIB4vLVuK#Om)7WwYW83AUjv4w(ba_!h{HQle zcFOWy^7rQy7mBKl@$#u;BjYRhQ^bbN!-qvJ{VhTc zj5RmD^CEhE1PX7;u;}nipI8Sl^542;@o<+Ns{vYVa zqCbm%x&If(;bS}!;J%!1WyuNN&0_)GatMeaOa-? zgF^!z4Y)MmlbrhCRe)Q!{tp~W@GQZ#r2hvvC+|MEchA3|0|Px6=t4su8amO?ix1s+ zT>l3h3Ft{cSAzZ@(3ybVJm@Zx>u;e$AA0nmOZtEK(5Vl-2BBN$-wz!JpyvQ|9iaaQ zbRG`9he7vF{{{E--q)(q-H37tSJVF^n0#~FVB!-)g1!DM<$m9<(s)7O(}Mh7spJzq z`U`ydX}tb5H+Z!Z*LA;NRvtXgzZfT;eiExH{Rwo&bN%(}ST%LbLhs%0lcApyilW1( ziSpiYL4Sh*+aHT6vw|XFhQ@-|pFVZ^>J%4V>9+~9(I3Hdk6Oa~)-tKd9=_Jy9~COK zN8Eo_P&U8YQ_^2yUcS+?vZ^K1CVA%0&w2H$u9>u#Ib3%o{Ta-X9$QREoQWn+)HIIo zlRdM@y8Rc)i0S7f{T;$X|CZ^pZk8D`De6B;0#n(X{70Kn&wd#AL)cNl5IbkiIn%O7 zdw2e?TRr6cDEDRJ(b6FIhrf_YutO#QZ=lfPmLTObmz}*q0NZMg0|!24)o`+I=qve zUbBeZHT8fy|K_lRGEdxMYR9s!ivAvr3U^a+pA}ORo*Z)LK7nCyRU; z}J8OYO`hiFF9p#(9<;ts!VAW$KRhxV_t`Q3dGvU zS=!3_|M}K}w%z<`VZM58nCOXFZ@L(HLBXl$RJZ+e*Z2t%X^GpDNMJ-uvfq(6!qg#ro-wXZO)Jn+?#nH#g8+|L>e%9enfA0sH(#Q~CX^ zcWRX@H)MgEI-!T-`X8LFth&~yqbCknCBNU>GX0=y4BDcP4)36;?^OSL^l}-w$~CNi zlm7LI5C85?wf)A8?pxAv{olKMn%?vMef^!vDC@_QqW|i{b64rJhn6a?|F_ruJ|16sZ z_{&3k_}YV!i-YyIW21e+v`^0HyiWpI|Feu3VUE>nZFVimAnSLXogLjr8?*UEw>!xC z|H2RS2{V;HI_L+%H(oXVZ}4|n|M5A4&l`MCo*!@>kL!6{SJr>r$K!syZ^-8ljKg3& z2IG?TALBF_ug19L`33Xvn2*Q2JlB8Blk>Hhw>%(F1a*hTY})3w|*0hk;)-*MIoQ!e0)4ljk@1(Zin(ex-jc{H)<`4ZoBB z1~|~bg9a{$4-1?);Kczq^85%KIpE0wSEBy~oN3@q19y^t0vu}Kk+=-G{sX5Dcy++7 zJih|R#B&H-E3W^*xdz@fa4*ll-~ss%1uta%2Tv^cV!<1Eeg=<1@F@VVWc>%v6!@mV zJ9+*F4->%05WJN2A3P1g*ATpw=XdZp4t$P)*RuYD=W*bBEO;;czmjay?l9|<`07MC>!7C%lR`_~&o>iO^USMaLYUyk~g zS=KkyDZ=EYKb`}a|2}?v9W%9KTGMM$Th0A{gZ3%>r0Mnj^^Uz{|6FcP9=|B<6!&^m z8qNLxn?E%+Vlj?m;JUK^$9)X$ zr*L06f513A#^W(A>VJBS(_y?C|)ICH?81@08<|A9jd zJZj)lbN>&VD&W-uw{m_396R9I0oTMgajt-O1>DQ|7kHq+2L)aP-2a0o7JRYbjhvr> zM;3ev!K;A#fACC!ZwkDV`hW0{e2jvZvi}E9L+~{OZ$s*LfXA`ma|FDW{Xcjf2foLG z_rm}5ucz&fE_)T<^66$d|4;T&`Dlq}4-@WJdOwc!!~M&a3Yt_L5`Tsl6RlB_@tD8`1N67lW?Zt-cDjUAi8~bgL^Z)#Xvg=ue=7(7_){^sEz3NAo zY{PMv{N6&x^Z#$ltW?F`n5li*tMdE*r1m}ZvRI}+|0Ak+{{LbAgKok*sr-b!ndSUA z*O>+G#K{+7Z13@!=l_S&ziryTE@YCNNMd;Ye0W!LJL!7V)!vVu^Em%+U9Y@9Q8=-0 zv7{-_|8;}1&-Lb2Rm}4(jpY3Qe_Q|5JBlF3VB;h?{~q>5Q=jsK_I}sR%AV){1-{!6 zHt%>qpYByz&d*!V?Pj)@Eo+iD*eLqiZgnER486C0ZaY}c-%Bpe@86m-z%Ae2R`dLS z?6Dpu?(#@eGi7@@zfXGUxww2F5<30}e)3~o;{sG2eFdl<(8J_=RoDSpl7`MbPFb|LUa9#n= z|1nR4`5Md{zkfLl>_B^1*v0YuA9nJvmxtXXegZpc*wetSa{doH8`zt6XZ+v64<7#T z@C)_79sERp1@N21Z{SA*e;W8z^ZXxvw(z%u-#LE|95~>CxUf9`2TnBbqJbNU9|1?i zQvh7a`9E;xfHw!+N&E>o41h-sT*~=BaH@e<4czkl-vY-Dcy_?Goc{yo#Cr(bOZ*Ew z(BOjxFR1@boR4Z-%T_4JS^Q`2YB15A=tAddyqq4?Aes!@w>Q|A(Cn?4@Bh$)A87J?!aWSI_uA?5tpK z4ZBPJ1^i&(5Bi1q84iAO@Rx_*B!2^bq(2q>su}->pAG!2;dhxoaNvLk2V6+}A2@Nq ziv?~J^&@~I4LoV!N;CcsoLS(_0e6n||G=RG9vyJW{1gS8YT#7^x01gC923tLxVDV{ z1LqEScfh^iA3RXtg90xk{tuog@Ff6mLh5ILM;3gt;FV?kA3TeIZvl8G`8VKU06vnJ z5yt<)(-3?O!P^k=|0sA&KF5LA68{I!Vm$?_+&@VMdenI-a#(tkY9AR8~vUeCCpV@rLC8h4F9si&u}j zzkw01|BsKQHK%(@lqzbZre>Q!@EyI-^Al>EQ-tvmTAZoWbW6zUP=fi0gP<&*QqD{l9P@jr$qgSJr=w z!(cob<8sXZ!#F+0>oIOm{Q}HGV?GA+lKel+(_p?D^Ooly*uldd9(M7}|AU=0>}6m# z$)AKB4eUv~I_Ceu&K~ymu)F8_4?igQL&GnU{|7%A_=|qC)NgT zHT+Kg8{j|#55z^l{6FBt0WS`?k^E8MC?EmF} zQwzK*;8yZifnyCkYv5Y?e*xzXcz3|PJpY0RxXQQQ(ULZ>0YRcx1sR3tmb7 zA9zN-MZi1BzXcB!_!xkfX7;WO|zDFEfO_y83&e@{OQtRYW3*H+gZae3?cNr_|PqySvaJS;R2^KYfRF?)HP~{;eV( zN&bGP&e?pPLVh2Ru38O8UzJXBv3Z zz@6lu0EY^Aw7{k0{{yEEcy+)n>;DyStbu0@Tx;h41LpzoZh?D=|APk>e6Zj}g!%vA zi2`2~c%xW910IFolLfCN{~tWF;9CgZN&XFZsKCbnyk!5+2zVL=UqkSg{XatRI0`-| zfY))%{|C?G!1p-tUijbk>DRk;e7b~$V5`*s#VlNyP`~ZQxOca2j;JM`+YzoS^m|yn$2F-xs@w2UWI&oXRQtWnr2g;N;Zmx6k`lq~eKAtMv^q?% zBQ9*Tm2Xy;{>G)B&Q~Apd!g#=O)2M}g&L<;>lSsjJ6<7o7xjOAo|SQ>&!4fQXRME~ ze(ImKZFGgKLv_6cH8t!17B`)1Hx+LK9h~`l+^!?sT9=*zh0!b z+QRJSuWYl)9zX`kWV^7~(4-W6SYO%Hu(=0wZ-zw>=k z_@`ac`9V8QNd4GXt2%2v=U-iFM}EWlzef94>w2w|*(yU0JI0?=#Fq1ox+nLopVV@! z|I4#Iy~(@Nn6H<;BlT-1doB$&C;rim*;qyD|5l$W>^l|v!qxjs$@zEvR;^6@N%RHi zlFG3D@8P-QF7=CAe#@7=q<*enH}9H!ky;;VlS}IV9#89S#;-4Es!T6J{au&o-FN+s z%ENuqylvS3+YNml|KMi@e>?b{{P)0t10IMA z#ri+sL<27xxRLr%;K%__4!Dx~Kj4gb3xGR0{|62=@Th@H#ri+s)B&#!xRv@<;5Z6A zE8tq{|A2E1yer^d;$Pr_10O7SL4Jhbi2`2~c%!JF0UnW0A$TSAf8dz~-z<0+W&JI9 z7=Vufc**|XAyxJhiCpT%KHE1`@Rp?RJ;;SA30y*`}HbGq}zN;}s74~xEKzxiOP`fyGKsh`g9w3cqx%c)|E-?gm&FIR4gOVNFjD^j|c z{C-!Biv{@;|1>w=-ScJkQ20Us=}w&%6J& zpOZb0pWXYv`1*>=hjiOhMNOf9DjL@R@6MA&$GrEYd(fev)UTi2S;Y5hzS!MtnP0R1 zzwVUAXntGE+^;Y7M=^6EPhFzx4gHw~?LF)N=dCF3mag5Z%M7R{_45T<*EBC*@6-p5 z#yQsi7v9v*A1KpIr|<31ku z^SH14eqbC1<1rYQ)c<3g8sl{sx9AsO9v<^?n3rb#KjvvLUxRsz{b2_OdwAHzv;H4; zaY=qC;S5s1Mm?VHQ!79KX@7eU!&kH`+tPsaTI)xg4c1Z{|C?G!1p-t zUikn0g`K>J~OjlL=t-T@hp9e3=ZQ2y}xO#%e2G0!-v0cT>q0KDXBBH zkLt^5uZjLoe9~8{XtKB6yTy;uf4*%0b8hUP6O zZ@2+invt=+bQRs8OC!$kildx{&b zP)ueW-?_A`|4W*^|Z+Z)`+;C=@8mFEwP!(%)iYcOunFTgxB=HoCg(f`3b zJ?85$Z+ZTK9SrPYU>6PhSlG$KULJPyT>oLm0QS_dtLXp0&a}6J-R1cUe(>-I{bH&A z13ww~%fN5+pMoD9{ORCVPyHYGnf})BJNa*b0}VWA;KEY>2RL!Sivw}nCf_IkrH{f9edo?Z^{0edT)|^ zdU)36(m!!x#Rl%um&4rF&Q)E{cbePW&mXBrYMhQ+JXiK#YuZ*-lTzn%1ci@N$b3IHHB)C%DGkDgIn}N&Sf$<~M`U4j=_5Thf%5Dn3w?c1ke#}yT?u!TI{PM#2 z{fPBT-JRzd_3^oBO{J?<&2H$`a{pgCRZW-am)ySS*hZrN_u=g6?%0RJ_0Ky>$^N%R zt#T$==W)90=kpx(|NdOj-B<5h-dE4lmG%Gn^QrHe-@ba^>}_Apbp1P`msLUD&hIV# zgAM~_|9!G@2A8-YE~5We>_kyhDtbWOOPpBt|B1#9^$REF_q${3TI&Dx-`U^P zJ~P-{9g$tuf4qA9-{bF|`hWPG!siXXC;NX~hu5>XuIT^aJ|6dTxUZZ)U>pYHF&LM| z_#DRRF=gOykY&n0*@549 z<;n!=|8|^EH11jV@sWh-kL3Kn?w%2m?tNBAGw%FI^nZ89&k5I0`aGJY?j$*X9Q9r? zSYkQLD>uLrqRH_2|#?Heuo~c4OW& za{jqw-Jnpwc z>a!oNl=IijUru+i_p#|D`LV87BC|<>qahISt^6s^7i|9{^(}b-1$@2zMR1gPC$+k^nb^6XyJ?BUgvtOU82{}*<0u$O|}@S}o1HT-I*{|i6U->Bt)jw7D`fCJ*e0vDS4zrcwGUNmsS_>lvS9Ps3TE8

x36xR4O(SnNzd{qfAFlB=o%-U_0{PlVL}f4XqA{pwnNd%Ez82=&X4 z+>BSJr>#}>zJ3`{|Nmw6pX{nEiCw1xJ0$*DWb+ZFAHJ=pEy|^-|NqQ&w`+5kbbl0V zE&Az|wkCwPDy7mV2M-th{~yo2p*Mfq-9GEySK_aOT8(l`hkt5Etu7?`|Gif2&`;lM zr4Q`QWvSm@rP67)aoJ9{^@GIJch|PqDSdX|LtVG;Qu06MUbi)_`Hm!hV3)_D|G)iI zVZAf!6Wz2}7DN5`HM<9^_`_RWtD-qY|G&g%OWmN!Np<1r$t3=KFjZ=EeqK5~?)S}( z`v2!ISMt?bpLazwEL5yt9}ul;4xKJ$zCyf``u{tZ#`!WAoBA{5{@Xt{Op?a5oYB_A zc7TpA^#3>B`qT}(Yy6o>{}cWEBgNzG$((PP_UU_w{=XT1Q*SP<-Q%80;_thw8~^HI zHMgP0eNFxU5>v3gXHR2(X>ia|zrV%JkA1^$n)|#NMBiW6AJ)aBc=(ZN)un)}|9JKI zzsKJ__5blXjn5l=Px=SoItthGxUT5`<30}e)3~qXA7C5?*kZF_;(o8#v6^#6e~;!Oc}l79jm5|0YF6#akT)B&#!xDD990yx&dvj(me_5Xo$ z2fRDrUhoedDDXjp7oz_Uo`m3w1#d(@13Zd?PYS$J)c*(10`M&a@1*`8JR~2Z;HBvQ zgQo%b8i2P6jQ@kjQSdnmUX$N(;CUSQ9tYkF|EJYCvAbExTnRrVotuFEAPEf;4#o9u zv^-L2#2u+0{{F$fgfw?5hB;e&DgA#|cA6ILP5&Hk83N-uw4JtC-m5cdI@~^fpI<8JG zoC#gJP1678O5aRj-$I|boV^Y@_HTLF_l8}2Bu>xic3k@ZEdOqlE_{8uouAdp?|;38 z2i>)0OYE%_vo-twTyB-bv`Icv7rmWV`p0Cwn!^{}cGitwH#%hhpBEbone7KNnn(X@ z%ldOyZGAqktCsTzHlKCu|FgD7D${OOHFN!D4#WJv_2&+{R*kFr_P45f_W!v)C{{1L zRKonUv6ZZUHBjGG*uUZ59@0+w|788{EBDv_996s;yJ?S5W>nL2$;JVWP2lvsqpTm7U z*ME$|VLZs$tS$Y2FiwtFVce4chk1C+$6;QY{eLh|gZUcFTb_Sl2M>FA*oFO(H0)$x zF9W-=|Br(mJ?!aWSI_=Gu(O7}4eV~X{=*N*waDn<7tj7b@KXSPY4}b0H^Gk@{&euG z^#6gM>2C$Ulm7-dARZKOA^m@V69>EyH;VnEfFlh&Y2Yeg{~zGY0dEetqyCfv4mI$o zflJ~u1Wq0B>VR9v{6FAW0nZw^*1)#{&MolnfO~oV1rI{-L4g<2{|7uFUo3bd`G4RM z`4j=Kr2h|iroguVyp#M}@X&&fA$S>K{~z!)0AB;}mifC;@Hh%SN5O0II}SXL1K;Do zd*OfbtY>x?%bPo4%kt?7PpkhGzog5nxXAW(kuGU3N&m1`xhF<{8Q(gL`)x+Z{(sLl z42-198XxRUpHlLVvph-}(Ia1kjT^U?{(o!gj|)?^O{r?knIrlC(-ZQl!~fh3pWlj? z{(s4Gd}(VXY7*p$Jtg~}PSfwJwU@^SrN20B+5fNZi=ytUcKz-7Z{ro}|MiPvopqVd z@2T;vKep`u_j9MIZshN=E=$G_1Lj|M+ptQPh#jwwsz!?a|HfzE<$k-n-X+*GO6k0FKhPyo3wkjOFJ}; ze|vOt&;0+d>NL|Unxrwi>f|=;|Cg^T^mXdI;XC|PO7hP)R7z`yoWHH@l*-coZ)1F{ z{`uQoZu09YlK(&Dqm6Dvv3~mSd*!76-{748=rjk{+EOZ??0?TrD(KVM&34Q`NzuQi zqiNTwrs*CtQJ4ASpkx2MPAxn7b!D!(R%?1`_W#?x^F!ko|A+f%+|S^?Qh$JPD2&HrT+;s!<8&CW#<(T_ zAM?(o8s|9W){~tKEz_S9b zrT-srPP~V}y_|o62joKtUP%8x@PvE`z#GZ`2ahcHWWlR|{r|u-1-=E~U6lHN;GqQ{ z$;&AF|AD6g_!@w>VG|GdGBwjKbrgSzA*M7!#iVX@wn}qbO| zT)u9LWG^TEe>dOX6P8={m&*0(J*l5Qy|#(Ea`azYEb@``|84XAR{PHKzg7Ko)8+hs z^AFe$?7e9p{k~ZG{}xCW>t41ERk~Z~;eh_FANC%s=T{hOzsRQ$@_6s*Cl~lfB%0^#4^Qs`yW89ddcfm(=WEdma5bzG?NR{%qLy zmi>RbrD*QMEpPfsXV(SX|K?uR-t^2}$lUGtsbc@%vt_#ZN!?=o8*k-h{hVp|zn-Sg z)B0w1r!nlW>(b=t=}$Lq?{~J}O8s5kqI_2~;Z<)_tNS(f=XGjlTi* zZ=U)M@FV@H;8)H5zwk5t9m4PAzXuM8hY+}s{=dKp@uGkmss96xh$jnNN&jEqjCfPP zot*yzhYonOz@>VP{=dMf23{3#YuUdVICj9Z1+D}3{{_x9@UDRSDC1w?fdd~bcoDMy zFL-F$6Ek&j@%LfUf~~Oa3N+$5HS( z3SLLq{}()u1K;Dod*S~-jj!%Ld_8wUv3w&FxE_8}wR9x$d)p${kblGf&-7`+H^vPK zFP>>C@y7Y3X9c4_{5?3AabLjqmydWJ)>u)~?pU5f_A@OD1Zv)vnJUAk&Jy1&ndMXa zZ2S>>x9WfWR<<46qSCE=LoZ%`NZx;Z^qTEgtf+e@|4aFPhK8y2*qFxp_N=$a&zMGS zin@u1hPz_(D$DP6M%4E1nL0~%Xx>WRf7|`f&E31s)g3Wh-jB1N>a@r9>Ur&^$@{%C z&UIHmyyTjr&X(7^h2Q&z{r}WkXK$7FD-Vr#7waVRF)jbAcb{GAs7`-4qxtyRX?efV z=F9HITY3G)2Djw<)sO$CE9Na>P8a`6-mlX6wab@K$(N~+MEF!JZ*r68L^ZSQVJcZ) zW0$A%*GvPyrCdgN|M>DOX7$te%#i#4oxd-CGnXHAzN7DuI^Ym1C zdH?j5cYI5(?=36H_e&f^?f-=_=EbWD@;+WY{_pX3c^{uM_`JdQ;-iMzx{B7WO zc^^1%z=H!W@Dn@@z}Eo0mG{BpDEJ%&uSE|4JdXq4;J0f|Ks`}d!kl#S^rDl zoFcy;tBMy5x&EiFnNfaU=6$_e)_*;)qx}BddQi}E{hwWSviv^Pt~6G0{ZAZBmEW&a zsdrnh|2=dI`F%V3$1}zCzx|#L5&r(wyOYOp{V$NDsr)`>n@~e@{og(zv;2PkT)&s& z`k#Bu6#0F1Mp2M-AI3Ucj+6)^*?3Kld?W^KeSbI{hyoVsnn0JezwMO{jZTJt*kHe zD$LVd{|gq#E9+0e;o}_F|6XOv%K9|_N`1}sfAu#;)~|}cr*vHZe=gTh*0<^zMkucT zWy`mg^>1~vO##>c3Qao8`naa}HOuw?P;3ubKW9B@q`Cg<9sjMbmy^$TT>pPq&|TKw zDxV$JT>rD&>L}}T@}tij*Z*~E-;?#bYqN~9{vS(MPuBO={}h(>KX;c{;S*kE{m0+s z`2e4j^&j7p=LcLz)_+`Ao-c48&-EYomFEwP!*Kn_xa9c+ZN&!8{Dtf6Pms zZ!k~K^&j&N`TPSr7_R@Yi##8}PM+&O>?Y4ou%qGn54+0q73}P}{=@F_`~^Q4uK)0h zJfFc&p6fsSCeLs1BmJr1S9!jJpXu)qekVT-a6mkSz=b>?0w=_a0&e8_5jY~AEN~^y zm%thErhq$n{sayc*MHzro=<^O%k>|)mFHLBSaJOauI2d_I1jo01NZX$3m!zd{(~3t zd<>ohT>rrvd42|uLazVdl{{aAX93rL@J=!R4?L9hAH0<3bMREwfABV-eg}9g>pytS z^*`x(qZ!R*fADk1<`M4yv(;!M`-c_1BO&+y|5o@y_80M^j|JTS zFBow?j{A?LAD6M*|1WGEBm0wvsmCeq|I24R7ovZ;z4O!8mizy87dp!RrqH%Siu?cP z%dPBxei?n%a{pg@MLO9Zotyr>;{Jc!do^YMl)le$%l-dvmqyC|>Pq)Qiu?bfndZy> ztJs>c0r&sWqnl)Z)@0Bw%l&`X*iiOwJ4aTO{r}rL_Q?M3hdR?_|6eD0y!;+-#CpK} z|F&;e$^J0?kiTUAzq^tvMJb%DAJooR8hO3s&nGspcua2N9Y z2{_c;{{xqDJ_VdQ?*D;XIllsqHTVC(wVZDO=Z^b-;9kzZzytCj1TW-#3_KxU0`Nx8 z&%mRA`+x9C&ey=Rko$k|PR`%J!vyaC!Am)x15YE||AV&y^*g|0+5dyrQJ(LC=d%9? z?}h)%3;ZtU|083xoDZgbw@ZZQ|7kYF@cciTds?lK=l}gu-Hqk>VwbH)1D^liE>lv@ zAB#T9WqJPp%bAw}`;#BtR#ox*ztX6WpP|Eo?RIe#ANRydyj|Fa{T zoKK(IpG408f86(noL}DP)g3%$4^dec>dq=r?ztb-ZOTQlk@*8L*#sZQqKbc z&;K9&^O2n2t7(%o&;L6V?Jei~IS;0g^Z#cjtI7J0S2_R3-}%17=RD8<@jdDX8(hcm z{2$j18DCg^Wr*kbKkh5>2aJQ`(HNJ+CooQqS7F=|zrZ{+&;KzmiEm(@j_3cFH-7(e z&<>X8|FDb1M_?z-^MBY);wP}9155HK(XW%Ep^MClw zQvVlz^gREEUnRZ+Khxg|ekcDua6mjL;6mag7q7c9!v5ktn(Yc0|38y^ zv(*2Oe(-b1_@&6O)`YOhc3)j!-8UN2;Gm!Z5kM%Pf#{UOiy6n(@-tVb=(=q;^?5lzj zpU!-vgJ%4H!Dlrjetn=AVmpZcU%F6B;@h!f4>`vFGnV`>{#F+Hos9oiONV?J#K$YA zZRZ*P&-cMD%lLVQM12k8|KC2JBJuS*-@fM=|F76Tr^Mga|CP%y{+~2cdx_6y_=I`f6Pnr8!%7D_&???zdx{p z#Q$Lz$&Y}YJmdecn`Qn4>}VMOhg~JV0(SO{|HJMY_BZf@X8a$1k^Bt!$ua&9ze)ZE z{Ad~fhhIJ7{|TAA3TuwKX^fYSn$L${tw=; z{$GJdit&H&O7d&KGt2ltcqjQc;34@K1urE(2Rw~3{tw;;;4gWc!1zCS9c6wGcrNjO z@Lu?z{P}aq|Lb}GP00@$a(rNf`F{_dq)lM`@bDNFGXJmgzC4m&^xNmt1LpsgJn>N0 z|4joTA@l#*FK#RONmEPp4w?U#{?32-OBLT3Ect&==8cg2rqNGtOa9-{>Qm(R@6&y` zHS_=4tQ;fxQDOT0j`@Ex2EQ%&QsMuKiBHFW}f+fkt0nV^Xo=eA845WmvqM`j`8;|>$LLB|7($lARoIOgsm`wdA(~=Zg7%z`ex(!GnPLf8d4W z$ATx4{|DYk{w#PT`G4S5!2DY9%rgHEyp#M}@Q{3rfR~b=3!aj%5%5;}|A5EL=Z%8b zQRer8=aT;i-V6UfUH3}z|BJr+yW|J!0_YQf{QtuJ?jVwwNnyM1Zq|Eqd#v}XQ)#f0(- z`!9Db+e*j$|79wxv-xu*Q_IDq2EU)DMmzjN-{Es=e z{zu9GuTUyhGe7*&=r=v{|2J*SAo=5YFC;b0|F2d1kz;@PZAWG}=KqJKOG^IvgMz0m z^Z#pyMI=AHY>ODl{~wq1d&ys4@^uZ*{Qsj(3Ml5cPYvoA=Kn7{9V7eStRs?m=KnW2 z*j)1CYwvnTG5C} z|M5MC`hSn>@Or2kjFb8T+($G2ANQ5|1B^p6{~zO$`UH$q^8Ybzsb9c64D>}`0Y5v*|6l*3_#Zfs{D0tr_;A39WBxyIqgX!z91%|n zxRUx3;EZ_Fz@5~e0Ed?O|G=fxrvRst{}0?s{R(jGnEwx42dr-a&NcJ@fqOas0uRUs z1zt#f40sY@{y%s_{#fux^8a&fD$o4?5InQY{|E0F{|~@J#r%KpQtETSQ}Q(qyp{fc z;Bg%D|H11h^8XXS^H}EpgZIM!Ki*0d&-%a52iSPl2Q}C~B*OZ?mSbv2|KAry(}%48 zJ2UB1sV}NJ=v~$ug+p&8mHML`|3(AW|Mi)ijP-xvTPr`dtpEFG;)^)eFQ2KsS+V|a z$QRS3zDZ>rVp;#!DQ9Xq|9su^V#xZxS>tj@ebm_!S^lg4Yq6O9Q*HmmA2`a(^SFDmtai!Mx-`mG(wP|Mmrs`poZL$SVV z%Iuqt^?#YZpCP~h)sxNBtpBUt{|%`RtCORcV*OvkWGM~n$9^h*-m(5~$+4M^^<}Sb z6gI5?`*d1%tiJ{QL#%JC|0`H0qtvIh{q94}`oFb(YfAmv+ht~I*8h#1mW%a&c17+g zp7nqGe#u1r8`ETP8^ij)P6=0B)k|G`olmoP*8hF?W*e!Wt2!_~VEtd=ce_b_T_jr; zssCG;5xjX!*!*;5cjdH|HFNy{t)Ak`ag_|;HgTsb9_3 zVzFiYA8<{42f(>z{U318{8tMeIM)Ax7g8S!o{%pgcw@mI@+g7zf8dqW*MetK{|DYt ze;L~AcFwXse9)aV zhV}oSPg&zo|L^N}+vHgPpEX%tsW1PxauSDnb6+@`Uihrq`tm)PUTqte;GXl2m5*0(Xsv?b`^aE*x9lEA9k1f!w&}jFz}0}J_G#ZS^p2eiGBn8s9FCH zzly#C{H$3255J55fdi@k2QDo2A%GL&MFTgY9|0T@Pa3!qeF@;qvi={q6Z`>(QvVNJ zD(X`Jr^G9?ir*0Z3gB3={vWs&eGA}RvHl;pm-~YUQvVNLgw)3XPskSq-iUq%ctk!0 z;FaiWfM+4=|G_&sKL8J<{vW)IP@e-l4O#yW-im$)cuYP=!RsjaO`gZH{vW&-{#Waj zG@klDk8YNVr#?v0*S#au|0&jdjjaEdYt4vK|7XSX*`hCU_Go?4|M@iKQu+N^n5&ec z{?D@dy+igVzdp2{rT)(hHB)i@kKL9rO8uYz&D$&bChz{cU-W<04}T`Vf5)@sbkzSz zKK7DgfArr9ZBx|$d64Hn{gg*f_bBTBw4Pgx`agF4(MgW_KgD$u`Tbq`VuGgrPqnM_ zMW3bRlglCXfA)?~(5&Cyv~z*z|GfSq4fTKUoP1wX|EI`;3G|;&-|TZo{hvf#|I>## zR-=NW{?EA_7aiAsi<&;_|6Dzo@S>g|}0|G)nJJS?5){~US!)KQ=3>&+h->i=X) zzRO|#_E}=fc+fx7Mm1!;f!K>*1;O~n1K=>R#@9;g*55RRa^?z_( z(HFvfH1&UQUwQt(I6U=#FfKiCd{2XMa=Z@X_FVrlkAV6=n3w1qVV<7)KbW^X|G*Bk zhlX859|?AH)c=9qL_Z03bkzTWT}59Bb~e=if!!^izu*V@L%}bi&jddy>i@uRp85^& zqv-#@ubTQ!@Uy4>5ByI48Q_3;aKHue;eZp-{{e1@9}66b{ts{!oQo{iz!~ut0C)2I z2^><7N&}aoPX(Nc{ts|#sb2*gYwG_1*OvNLz`3RV4{$Hfzu-Yg{U7i`^s&Gb(f#*{ItqT1=dslP z0q=$XyZR@Or~cpmUQ>5dAFS?yjuGnrz2){w{qT2d?j}(Gugs3AqA#|$)Pj)ue@iwmd=T&|EF?~>#H9@|L=`Qn=SjRuhhy>|L^6t*|Puo zx5hF{{lB}VKcW7g8t=Di>i->D*T-W2=G?IL?jrR6zRPx0^xZ0yPY9|1H?QnD`Tbt{ z?3(ERmH6&_Py_mKe_c)FssC3CwXm!oFHrJZMg6}z>#}?5%cU&yLR0_mSgB&v|93Ax zD($KNSEKR^&HnVK_l(ul|Lfkiy6D#xZTv`6|F8Vft(y9F_uDi_^3f6ZzxF>v|DvsN zzunN(|GT`Vv*_d9v->sm|5D6LWmrG|)12O(`hU~wuF$_!d*3Xx1q}87Qb7lZ@%Mcr z`fKX{O}$lx`hV`j4exvE|5fUjS!4fhCgyBlsQ;H~T2ImU`*>$vMg6~3Q`^bf4fAEXwGr~`X`hW17rG5ka=&1h(zly#i{2WsM4}KT_0|%P=f51hM_qBJx3Grfq z8_|ydj;JT;fGg3L1kObN54e-_C*Y8Hw7{k4Qv#>dt8~Dv=vM;AqW=e6E9zSU=Z^Y+ zz`dM*fd}M+1usM&6Fd?9Kk$b9vEY%V{vUW1gr)i^@Qi#5!8DQ2+Oz2BJ@z^Kr$1`oI0>_ox1E z_*n<^K85~og~v8vfAhs}exs=W8<#PKoPXZ*i+v%~Ah%eTkv+``@h2I8FWE=bch|>cdWmUm*Iw=Fmj;k9Ref<@D75 zy|Ft%v%mbZx}Rz4|327T(zE_AQ}ZjD`oC+ZPteq-%~B`u)c-yCUX0YQm(4PYdba*r zd_B>(t#UVm=>PuqZBOt&haa)Cg{S^+qhAY%KJKw4b*Y!@=iX^A`nh*clo$QqvD*r2 z>g%fPT|M=GZx*d4=kL0~WAzdAe>dmvF8aKOK4~cWzk|+v$@6>P|7BNC{onk%n&W^JF;}v`Lb_RbB2gG&p_#8j4@IBEF#&s<9e{o%2U*SFm_cORJ*57U( z>$=p_v1EO;FSzoXze^}gf4d*T1a>Z#+Y z|9?QGj%9!FrlWO)`v193{~BfdzeC>tMX3Luq*_4z|8PfmJf!}A>n`IY{VW$H zYnQbVee$hGii-Y!i{ZNi>X-lRw_ED}kDk0%^v%2eSv{cs|NF^b$o^$nnKYXE|84Zt zkoxGZZgxlg|CwhSi+*}c>=aA=|9rdNrvAU0Tjg_2{r^UvzbWz8T%&V1>i<8#xLNes zcb57<^#5n&y~Fx{-6H!@P5u9^>oD zPqPyFyompA%s$ys|Nr%+Y}EhPgNhF@)c>CzbK7mHHq@W3dDl_@|Ff3EMW27p(7dAm z|M=7_hxoneQF4%>{{MtRwM5^4-mt@#`u{h>F0%gP)l>f;e^>LN8H&&G^A6vW{sFj- zrv5*!%j-Mb$5a0w_tm&R$DyhJk8w$V0*q7i|1oZj@q5gJ^KqD$^f$mf74`oyZ<#;r zV5t8OyV#s{s(ILn_R_GM^iO~t9rgcVSI7Peu(P55KkP2~7x06l{y+R;*q;G@a@7Ba z-yHQD;73FKfB4nGzaD7|t(mw(?Qq=zku81!O zoDpvhxRd-7;E;H9z@_x308T~!AGlS>Uva=O@oa%>>2Cp?2h{%u?&bLdJP`eV@FE=P z&ROt;d7M}}h1CBCugI?eJX6&F2k#{R20SDm1MpJ%bAYF!{}0}hzY*}5e2xRJ zqu@6pL&Ens@Lu>oCw1C*_Wv1kWne7(gHL!+EW-XjU-$Su%KX1Cs(cq=|DVL4Jc_Wt z$l{$xLiYd3efkH9KYn(+QH1?}e)m-@`;%Xc3|H*`Gk4Uwux0gicJ}!mmi>PcZMY!) zO_CR#A^m?U6)q>gf8RdLs@ebNr_vduKguUN7e?6s=UC+un)TDK2KR96|5N5hf?|L5 zWc#yf_Wv1uVV-0BHG77Z(*LL5%LR)4+3zjc;Mo7?{YRTL>$kg{Yi!y7C*Q7>?Ej+^ zZMv)3|EJ=#&hq=e>tbKm68(SHVo%BbFx_*Ul>R@}56xo!m_BhJxncjG?Qxl{sItw^yF^>v@ypHSGV>q{GU9{cR>D zD&^V#XF=oX7PqFcd*#AfWa<02UzZ~7Vz?)J(Kj^oS?5AU{x9BAOby|cC zr2o%?@?R*%-_N&+820~pG-8nS=h+v3RI~q2tp+bN^7nij==YsAt6~2i{N1JPHrV5H{Jh5Zq<;{uP) zE{@M)oSyxEFm8?fMT2>8J`VGe{zjOm^#8%U<@pD8pgk zc{Ka~wf>}dm?N&4%iOE1WBrT<@(QpYXxueaAj-6s0~_1H02`m<$h z*Iu#zU;C;PHS4!~{C(Q7|KHDNCP;s`)SvvSbm`DNwAbbLcmG?zN&mlt)00YnxRu2> zIQIX$yd#TY{dncMr=CaF_W#SCzOZM1yM!7I4g3GK`E9rCf6v8-?1yKTlx{2i@w#8GEdBom zt*N9?|8L%UUfQt#-@ZfdOMks*#b0Rl|NA!UYU=O#ZBKi7_WzrbvZeIryD%w}WB6V0Y^OYxsfwQ1FZNXM~>=`~Sgj z?EmNBN6-F$@T*4uKLbD0-wu8k{{sio{|~sZ6NcX)PKXx`+z>y+k@Wuqu56HDo(9f{ zHw)ZJ{RwcW*#8f>Bt9K*O1xU&Rs+Apalrn6z%}u$fOF0Mf55$*e}M<&g90z4KPGr0 z{r|w52wW{eMT5O)2$9y&FE3{=ZkZjg7KD`M18QV*lSqlNL+=(xN}tk^aAztK1IQ-@J3i zpDp|UE{RVf=bxp|bhqsP`{w3lmi}6S^B4L`JsSf|KD*T>d4Vwb;_ro zJNEybF}1yB{58wgn1KC%i=~>t{=ceG;{?tAzotr0ssGy+lVI8Z_x_0e(%*Gt`RmgE zw`TWu<@dko>=x_?>r#$P?AaeSZ{okD|8GLOBvSuZ;hPXASij~U_A2h#|95TmI?~_vk2=n=|L<4p z7X2SrUmovM^?q+?LJEa47L}n4WxV%&_TC|(Br-)RnVJlt2pKD)q!iJlh>RZ+aqs)= zy+uVK8dQoVi4sYZ68+YCJiT7O@9iJ2bGz?z_I{qV?s@OMpJy%bzk+M><8_Yyza{s# z7JuC0jqkPe{~hx4QH%cnSbOmuk^aBsS101HyYGd^J^g>%|5}s%e>T%?xTF8?xhJZL zKX1vJe|Y-;wpriKv48)^!^0!}e{=3SW^b=C#$D0-CHnowxrOeM_dou1^#8@r1O7jM zFVO!NpX28(?j!!cxUc!}^+68L;qwBX%jXA-L;Qa+F4JOgr-*TKycXjY|6j2jrGYa`|6kxPW&bH~NIV+gQv9ibQ}O==ZrQ(Tfn(x11+K;48aOxf{{`;p zf91i0K>uIxLj1A8lk{2m|AIH3toypH+V|F z?i9RD+5ZO~XXyV6UW>mscuv0OfcL`xcfT#22S4z-*wQEj92nH+{dkSp3cNTU+{_o7{Vfkbi}Wd{HLA58apgVUnRgdh?Al4gAufU)fsz zK6m~7CJR4xJ8{iBp8o3pEc=vx>-L-_a(+{2NuOr|{Mf^JBTf^4_M*$qw(x5YH@~)4 zK7Y=+Z&~=c+jD-sRQ%m9dAJe%-tDl}-^=q`bvP2>2Oo-dyTQ^QzWjlk=ocS4jVLbs zSYEr7`=-!0w#Mc62l~rTUOA3_^Y)AnE|B-w8V$1^74 z9fkiM?w0E+4JhSWnim88?LYYKW%}K_7q+yL&$r)qZCpIPay)VIQd{ImFSq}S<+e_v z>hbvDF7o*YYj=0|UR2W^Y`7+D`SzaJU_@T%(&;i+_m*Dr`Rz0N#IgDH;?>84J$3X* z_gt@ac3QhD;--0b%IBA$ZlHGYhHk_a8$y#_W8;NOHiY6oG;~*v>@T0kzY*8`xyAqI z?^*nQ#OLJmxR1mAc;A5g^Em;}b9keK44Tvw}91w4ZxXb5}hlqRx%Lqz$0;KfKTGo0IvbKmCpmm7I-GEJ@6fXa}T^5;9fot9t7~ggBRx4LHo%Q z^2LKU!XNO+fKTLA3VxAiDfni(b8_VCXi<`Y+8b8)Q zS@={c{^p(ks%UDCIK_7T;^g1IhdY!GH=lY+^275rE#Lno8m{+;*S8HHb+z*MbK8RE zHfQr-Klamcf$x7;s;SNXJ=s2d(a#zF{q6eCZQ-<9rS0;j%PrskU5-B$mgOu6%~n4m zf4{ev>um>Coe*xA_*tO8d!f%hLapE`J3cgEe&WaPCSm^ZckIdsez$!8e>tppEc5mM z!q!`H)(icgqWyQ67Q@eo@4xadG-I7Dx3Y#i-f_CUrsQF%|C`oqYO=V*W$v*)M=bs6 z`=X!rc#kAZo_B$~zpA`bKO8Q0O}u#f=0Jb@k_TJ6oqyFZEmyac_us8wue9$>zs2QO zoNDoYj89zJDy|!Tx*hRvFL{6NJbHS}F6tNO-}$4*`_-L4wuvj<=#}vEFZas(x7Za8 z+*J#Ex|Lr{_jo_Y$L3dvz2+5mD{7CB_xHLLUE)O(+QzCS9+CI|oIQK(yW1~~cWxUf z{J_5s*A73I_dk9w;P)LqC*L1%AKs7mb$tKhIR?**c&>c^z&JP_i*ZH1|1nO3@j8r~ z+{tF&>@F9Q~spmUAqkwfAI$nZpw6NeJJ_rwYy~f(f#8pzC*odGmlj5WVrsn zbW9b$@Xkkl96BP)^~;=ZN184F7+=5lC!Xv7Ms9~$R&uKu*UZZLXHJ7Ie&O-L_O0vB zvt0jA__BHUr{)HK-{+-e{q*?{xoNG^14Hx06$1U$uU+S&yjk10-&0YuxUs;D<)&~vNclMSqhT5kGJsZ|kIUs+Z zyZ`!!ec{%{cJnn;W&Qv6D+~RFLkqiAmA;hqW1lZ7#*2N^&@5BLas6L-VD-?VZS6Sw zv!`YK`RnXzZg}fyzT|p)hbMYR#?!FwCcVz{`_3N^GPmfEUSZB|Cu&v|zzt*@$ zadw}JW6w99l=bf`tDd&)n&bWX)0GkHV|(?$UatLfJM9IglB}P9>z!jhd91hF{mfYo z>+4vk%-ykBh3Kb`xmniVzfAuq)V^VO?D@!$fc3e1VQ(8(s^9eR@r(y#{XVfx;SfG{C>peWd8v7;r%S`8@c|+b1a_c z@Lbt{z&JP_gK=?u9B0IMBgXBye}Q>$J^}OM`~v3bFkgpxga6$bhk$rE#D(z*h!f)# z5I5OBK^#5e84*|1f_`8TXU5wg?y~=aJXqv|d9lb(M4p&0i@eGH4e}U}&xpJluK$r| z<~tzol7HZUcpxqU*Z;tY2VN|2Bl}0d5%J`KE6epiaOQ!x0NfFO7C0mxQ{a;LBu*{x zYJuB?`&Ym*@oa!=;@be{0eBCO zZ(6d>d&!9&oelT@$0b93&!sJVu@@@I{^i)88Yf3e{%$qBoOCD(Y zkNBT0{P}S+s_P|o+?PiZ?2m>q%gzb|io9kfPwguEr|T}cKHS*3X~-S;q3r*6K03@S z?lUS}IHRBJzh2pYp6zt}6?5%9Pm4c$ta7@&=7~3LldE^g{%!mAuZCrH&apjbeQmk_ z|M0C|k6vWIS^a4^u=4A`{r_`bI@|rdxuyNM!%w3BTYTgt_6O{H z&$#nWOMm&grOt}gI$UDg&Z;B(&ovvI5fA5AiYH#ECj0-%*U#E{v(Jv5f2%F~*X!%G zc6(p_pWTz9UKRWQAFe88x4zQRJvw|n_z#cV>Mi5l?-jA*pTF60|9{A*mE(v7?c;YJ z?=jpzfB4<~_MsJ3<5xSnN9?bg_XqcPi)Q?7YZSjg_TN8z{z>y)>A`OExKkbW=i{Xh z-xYI?wlvG~hsyr_DP1eY^Rt6utu~ty?C-ncjm~lAj`QOF;zQ;AkAHd1pGWTh4l;CKSY#qoKJ(_y?Ex9AsO9v<^?m>1_4Fi*}m zVBT{6fj9)jgK-Ink3*aouYkD8`3d6a5Ko7=%Kks%91w4ZxHJ9%d0;-67svg7ydA2{{Es|9Z5{0cZGo;`4Fx&IHGr@(sv?&bUoJRl!Z@PhmxPYn2C zz#BO~1CPij1749|S@6t*Zz*^u=WpO)7JMWx$b;Bf|gCa>3W{~tWh z2j6qRd*Odlv3%Z+0n786U3Xh9&;OezZ|1G}X<2s4oxSD!@cu{ZC5NAO+4=Zl!t?*3 z@6SoPmfe_?xUs67Kh7!AHr+S6x+z_}mZ3lS!QKz~GCg~zH&=R0&MzORSl_RC~Je#yQ?OI!S!xlL|Eq=5^ zXjQ$r>38{f%k%%fJGzBCR}KyTKyMNL>vn0&U>03GHGH>yQlLM3yASeh$ILUPOuH3w ze!HrCYunp=VqdCVpXa-w;(aqiJ2%Px39oMCzt9E8{|~$k zjCtME=-JDS>iWgW^YiBIV7oUK> zIL_y7P5AW=+<29}>-1aY{J#9tKcg;fg!}v0MxO7-tLs&Z2dkguo;`f8y#MhpulaMw z^MCvv>MTb@d`{{Ia39_;;J&saM92rlGxH7&LagK<0MBJtR0(r2= zM?_wjAB#LOUj})T`VHjKBA*U-eX#GMEJh(ixNTHuoS^uQ_c>VaFSUjdFi@Jw8@zQqFP26*?tz2F}_u;2rE z;d%ZKo+RLl0dL434<3<|10-b*ZhuEUd!fnEYJGCWX9TZ$&N!G zWV_a%p3+~u^*8I1fIGdO=ZlGd4kzfw}V}9PY z$_~GEoO!GM@^IHv6Qq9Yg@@m@+0jeVq~RBV^?%dfT4MKa-EJ2&JeBc}4)@EUoM4Z~ys}j`5XWuMgvE zC-VM#>B*g8XRRCKuDL5x)W^BDhkmo6P{r72+x1dE*JIq>ZdH?)?0c(PMArYEb;nzF zewo2;{4YQA{6GHQ^t||b@pIkNAKc+kpXV3A2k`BeJ`InLc2d7*`_BmGJalV7 zeV?1qy1x5$QqlPEiebV({L5?pJhJ`|zi09L4xgicP{e(BKa2bF{szzC^Y~n;Kg2jZ z#=~(1jL%`59B;t5rG63faF`G0CG~%pXM*`U%v-+yAP$U&MO+vki#SEZi*XbE1jNxG zo)K{kh_6MQ8E=ocGyVa2aL5PqBK3dBlSjTB@+S40$RqQaAg_+~f5n=W+IT0$RYcH6X(qH_&QST?MiY=}EcHR=xg8JL;4#rT)KNa&y`xdCZQVT8Z`l zVg6L?zgBwN^n75sW&Qt~D;I?dd+rPME*mKI+vP7D;h*ibGdyu?`GERvyDopZz3joh z=oLC5e}60XKVe@*57*`MHj6*}dCxYp7o1bZjXb>Euzvgw^rO78`(1ng^fHe1|6d)c z5$(#WL#yk`I-Wo0|FSlG{YBkad1-0G`u|?H&$F5BWn<6nm0AC98$8^~?XLNf`D0P@ z$ol_k70+@dRwk}}{TpQcJAZta(09^R?!hz5JJiRAegQixVq&Z9 zO=7zhTcrN~hAXWZ)a1@s^w2S>zu(-nldIbLiEz0Y5n2ELQEqSd!qKX3*!*%*zkkcc zW$pdFN4xhvSz=M&AL|b=aaE&VY`<&nm-j#Z<#oW%9qa$`djY>6@j3SY^FF*^#C>^x zi|6op7SEOb1B}CBJPzaX=uhA{1IFtxZs}jZJUAcpv3BMBEan+8--vmG|J@k}i+DuD zh4Hb76XWF(H|d{193A4xxJvy$;_MM`hqznTUmy?6heckPALc0{UjccO{te{OBcBm@ zWqz4w<~tzol7HZUcpxr_58}iEFBZ6A|37g=JXzq1`0~IR@#cX$;*U5Cz+(U|6ZEGL zrv`Wpz^(MJ0LR300$c~y{{!d5y9MrL{|h`IAIJ;x!-FT}O9I}IKje`IpU5kz{|C=9 z;F|~Ur2hsyBp*}olKjkqrwRB<-b()tc$^D9XTWRnI}4uYgYP-uz3_iw=?ZxZ3s1_c zdi+uG2cJG`cm6}CEX|G|U~=Feo-{>Y;nw;s)8AJ1OzAH^*ltXU|DDa>)#!BTKRP!5 zY%}z=(x&Y6Po@9w@YBy{eyaEcK=xh2{-yU@Px5CpfM)sTt%m;Qv*RDWV)hFE!?Z&@ z|1=+;yVxJI|C?I>K6~!R zSJ{uc)(hPKUs0Z3*2qgg4$H6m*uT7VlV$(k z>K~pAd+;uq`1$8NKXEVb-fOnJb0i!ryC~2f{tW1M{I>9{F!7VJ(m!_l!n54msor+p z1|Ko>{|)Zbz~1v?ZTDm8LwNsIk9S|REllZ;p18pmI`;qh={Dw!-Q(|W-$eS?E-PCi zzF)syEWUcY^#2vh*=Dv5#a>#!ec*ou*JW6)8+`H1aCzp|$o{`w-MhK-Z#ZacjjbvD zb6*}^Wa~D$+r9DCV+Q?o@wD#_g>Ro~=yu=G+VTATy^TX-&x$Slx#R9}?EibEvyE=b zHF5MGTcm$~$Fz;f&&P(v-JSOa^!K@QA8q5-z4Lka$B&TrKmO&l#m^)A|L}Vjzwhw5 zl>LLaPr&^g?#ufJJcrLScrKrBF^-7wa9q;=hjDt0H)7oMFLsy*=Myk5&d*?;oUg^a z<@^J2u!x64Ts-a+k2&F@4hHSe{s_O zyCun#W=+y!vrd!q$tgEnW=4#enf&j=MxOou`?sHC=FXaEUi)=;n!y=nwYQ#3OV!CY z4L`icpugE4So6Mr@w97Ap%KOT{j1RY?<)}7o20+|37%|=YF|$;p0)Y4Eq1= zx$ote*`M|eg|KG6F$98zh2F`RmU;5X#_NyFLzMi-n^Y>c%+yC#EdhzEs=h<^Bc9Qq+m|-`@ z=8rE94Nu89_Wuv)b|R#vbF@<%S@zFQy1J>oX2nf$%Ri??^w+!7$Fy;EC*_A3*WV-j zwM&M$VvT}5`+@5t`~UkbDB&s`y~7Q@v1Pb*%IJ9QbytViGk3dRR+Mz;?~k`W*(rX# zeSNg;d9{F_0EAz`d2jtr#@A7=$fOsG-h!5f<058Oi0e*-h z13VE|#20Z!yanJ+@CO_cj|R9TK8aHcyb`yfUjZBw&&0I>z5{Shyc^(N@CP0Q@PWJ_ zKgbggzK}Nw_(L8g;1hX8ei`tLd`rPQ;U9Qtz(?|u{3K5k@Rht3{SNRrAAHV$*BSQz zgXj6+dk%On{P#~+%)9x`PI-sMJ)2AYpC*4?kZoUKR<_KXI?_LUy#4ceZ+|ue86R)?T4+xxch%F)c-l}STR5Cmg(WSdmfg*zfHQ-vwNqF3d<)<3G`=g;8xl# z5A^m=?%WvIzulzhJGScVp7xu{iv#t4#%;ONUf*c1-T2mG`TIY*$LoIGu7B+J!zNk! z!~Z*dXZZ2JOk3pB5{~`jBmb=!Us|8)K`!#h-9=tk?tKTkC|L5z&*Sc}PzhOVwR$tzK zBWjPOuGtuXNhg$z>ka#g`Y9bo;h-cF@-eFHg89HtXzs zD1|+Gynovi>ktopcS*c{;`xsHKRGL32yF(9i2Y~3!}quQY5yB`Z*QEl&A22&-^aau z&n+(LwKNR6`~l$){^hmB&-wrPdk(+P&xw8j?vvntysyRm`5Zpa;kokt1LNR$493Or zS&Wn8<+w$^2=fS-PsF?o^o=-A&NpJ-^8E*KU_1ii!uS}(iSc6G7{7oxI>eK475yK? z*&yByacBG^@(_>@=7sqQ$P@ErkT>SfAdeCGWL}wH<~bnW0eLt4{s$Zw;DNXxK8O?I zB>*?Xj{%N|Cj(p&U&I;lW`R5T{s|l!;E}i_K8aHgyjtLv_$7{sX9HXl-wAL|ynEnY z&i}y!@`1b%{U7io1HOC+m;vtClpc+?JQV``vY({^Z|%`H)#N z;=9Zj6`%E7|G(AbB~#^pW6jLRp7hlJn>wqLDf-!Qvn_vqTH%kfVa3e+G(B*EO+S0a zKp!o%YkNv4cSBJ-piQnt|G!U;^b70G*^u;IG~QDGZ{4DY!gIBXhf|)pSJq$WWLkvF z-k1?uZTQL5zhb2w+w-Zk=I(Xj=(X$F|8Lti?QZ9PzA$_;Y(b#@->kl$*k+wehFJ7Z z`TM;LeX4M5@>y|5{l5-J zR)tEjZS4NVap+%mceN%Lwk2HWII#1&0DU~SChvT=rhl1OZECB?{`m*s`}^#D`MyEf zL6Q1@Y3)94`&)Z$$*ot(`g>#VbKEtT-Q>npTPXT}?Yg!!7yUZY{qgR7?EjBBuM~-& ze{hw%?P%hl?-yrOygjy>{Iva{{%Cps;a^?{{G9)vzsKL_=R`jc_X)UP#C<*V1^FC{ z=S4i1&vzIH$HQ@Pd=}&6cn!wQ@dwO<^WnTA_5UzW&X@C+{SU;!BOZ*4MSK`1#>*jY zj9)+;8Bc?_GQNy6;~fxp*?&PEm=ESf^#72j6!~J_m_LU+GM~&V^UFM266PWGRGL*mf_m&B(BPKnnPxFvoKa7;WC z*OvN!z_|zBiTecjx8OknK9CpW2YEuikT>Ly0guS1EO$^C!7Y~}`& zmz1*q9+)Qjzh|yJ%`92h&MufcmiwpS%$sNUPrvJFpWj#9LSHq^DBm_To>kX&9r=*# zzjiwGLb&UyR;I}O<(B^J#cHhyvz{svCO)y!vVZ%rRWF6_cD@|G=z%_e=>Pt?x^{Tw zqMyQ`NAH!t|7rhmW$^!EF83FkMc5~=^Y z{`{KmgD*Fk-Ro;a?mvG%u9EBf`c8XuuhSy+fA1W=#m>E=p1W$&FzH|KdFKG=6t#78 zdX=QUZG3OslJL_*P290FPv!o9Tzb4teDs37w%<$FIqLsznS5KE*|3qZr{3Y%KYw~o z&v|$5xcE{H*cib-{^d1)&i^0qd;EQVPV|Fu zAKs7m4Y)s_lj3=NE}zeF1dNB{;`k!Q$?cBk$z= z4LnT1NAfZs{3K7wSMrwpO~GUGIRjp2sQ(L|=Y#J#;Jxs_>BW`vj@~&DKDp`r>EB7)tA_X?)7w!0-^}Urgc+dEc)S~*;Qy;I%NFG z{^!~CtJsRUMa`E7YX$nF_w;pa(pW=jPWB z5B~OT=zi3jPaixg>#qqDio{w^ec<06Th!4Xe%>9&L!0yFgD_x+f4+Rtg>mpTe+BB-XAV?! zb$i?hpO&ixdQ^*baw1Md7 z4|%_=`{|9A?%rkJi2nb#D;~3zPaouVU$D;e{C#xM^}bXX>WY4iJ^8zDk2{Y26qYUS z;KmKSfcpROyg^sR?e~^+Eq?0hpzj~b&c8SQzMz$T4m!Wwf5E@J=Fj>6Eq;%`&(Dc} z0PYiUKi*gL|M8rF=kd9Q{r?z;!FVFZ#qn{R7UPW=H^uG0A2=i4h&!o20S*)3F#wmuCvj?k z*8toSzZN(qo{4MXn>Z)lJ#a7IKfwbFJ|y4;`9YqLFXRpRLmnCMiM$g1fAA~;-^jZx z_~*ex@-YD~>CZu)rr>J=-jcuMG5MSUuQSyD2ha1t_om>z@W1QG%6YXq<*hxl`LbO4 zgBL!~H#>M<`Rx9$KFF|t*c_;oe)#1@Y2O#yCiMS#;hcf#_qS|KuirXM>W?bj+aq0@ zTL0pdvf}?U`IqhaizhtkGf!7!{gT<*YGcwh^?v5UdLI5J=9wZ7n|7sk`0oa-mA`-E z^A4NSyKV9#Pb(MbkG|pjhW6?akNTH8bO`L99(YZEd+hoa>D?R02l}fgA5F1c20m`K zO$QEf{<;EduTGEFweO-Hh5kQ3|2D~1oHfn%K6an@w^VD|!TveyZTsHp3&sCu`{&!t z#;u3#=s!e1F;2ayg5UJfDX#PG!-oDpQ$B1LdaO9bm3#9kOaGX|h1Z2o-acSweDR~D zzkIim#p3oO%WdIN6&>IIU%yv7zC7!4JLQAMj{fwIpW))=HO}*o6oU3Y`q$_5Z5|(d zaWdAE#?jw?^*dKY_rr;B<(u@suHd@YEEWIy=Zg5m;=|(qvu0vm7~P>;tkdv*>7PH~ z;FmCNK%8|fn|_fu$Q^|iO`SXX$E()N4t)QY82zQKUaNE51y4cv^SI_6>$q)QYsJ1d zx1#@#YgyrDmy@?MynbXrgujpd=bjO+Tdi_o=2c^bfB2Wz{5k(We~-U!@i~5;_u>6` zU*4b3ad;k|%ja_(91q78Fg}hm!FV0U&H6>ogY$8i7w5-$2F#c9mhV4^1LMKCFg}bE z5Ui+N-IEb_>FGOyzQgFG|e%)5O5 z0}hCX09^PJf9xVoh?fA|5I@8b@kCq^U&I;l7JxhAk2oYAJ#a~UCcr82ngF-NFL6vf z6W7Eyac+Tk1Ki8^U+{o@ATP)d^2C5IlW-TO?sy~k$O|0f?GJCNr7Ti*ZGqKKhC z`KV22_;*I3R$}Mr;$K!|&9U^kPuBT&=6{&XKDx*BJOF*t6GcOd<-0Rn|C}-Nugrzr zYlKUNY)?;})xSU zzkAO<-Thm6r=9v&A*nxqVCFCOm@Daqm)b4<^kqlAW#fU`?v$bn1MB~9+&9VIc5e%p z{?c0f|3>#YYW5!N?`^XSjR$npR=ww-3Y?FK#joUmYv&Km5yUkDv4Z^Y{4s{2V{e z`|y4N_vQWh96pcFua9*4r=NT|x&Rh0B5C_I1A}-$7 zy^e8Wycjpek8xx?BjU>VGR};5MBD@GFOUc3gLz?om?!2dAaBec^T>P#)95l_Sw@kN{wZ^Rw(M;sE5#3k`boLbG?v=Y#J}!F%EV$}cMCJ^%fmYxUd#VtXLuGKRWBB3;h1-3)6QywlMT3 zZ!-3F|H$UDesj}_hW*PItexd|l)cCI-nH1!-+WxN)L(beN=#O6e_9K|%CE7));Cx#{eLT~J?ZC^`7CrS(!;FYyw|RNs)SE2{x!_4 zcoqAXUHt31WN?+!V&`z7r$78PuRUgZTwXdpd14Fu$K2)X&#>J(L#OZW%jhrb_8hyx z-c{woc=?Qxc>h&*%{D!057xaH+V>0SPwVdMncAV5OX8@^hXMWn?)TRF?I~wn6hG^G zB3!=aLRY;>aX0IcD)E;pWh3AJXMI-Hy}6)lys~}m_|MU^-NgGEy53`o#hk{L{=Y6~ zd@EOM>~EnAdT-9ExW`t$??%_W-}bQJ-&-U1|IhlYpKCJY)$rXf{o|1@Ud1AhpH_>lE9+^+(mHB0!4f4&rvp+Th z2PyDCTo50`3Grfq8{&sJBA$pV;)^&V-YjrO{1J!5BXLQ55~su~aZCIX$HX&nO?(I7 zoOmbhiGT8dd>}8#5AuY3A#cbZ@`!vg;1&5ro{?_}ct`$`haP-Pz)SLzJSAT<;4S@s z$z$?47rf5U{}(*Z2j823_rm|L_EpZ~I&jwX*K+x9GH{sm{g-I`ONQ5-&TJ)p#E;$j zH2G3!O7?xZE|V$7?@xuctgOd17kw?)U)4UT`?6%sUvhovMMdR3@Wfrkr0J?v)~T7u60p=xh{I^Ai1v7`Q*9#N2lB; z*Vp$SF8}|cDI?_il$%G%^|n0^$o12ePww+gFLv^M-vsY_KBw9rC$I6ZT;u2R`}jS% z#^>Z3_mOMdSFZ6KxyEzl8sm^_j7zRDPPxXo zM%?5Yag=MsRjv_dxklXO8hMaw-#^W@Bgg6{}X-xr~3X+^!=ae``_sM-|PF|==ia+F``_yOKj{14>ia+F``_yOKj{14>ia+F``_yOKkED6>H9zG``_vN zKkED6>H9zG``_vNKkEA*XW#PvkNW<1`u>ml{&)KRkNW<1`u>ml{&)KRkNW<1`u>ml z{XPsxqLs+_dh=;-yih-&-=>v z3w{6dx$^x(-~Sw!d_U3mf6(_o=ON!`^!?9y%J&_8|1%EqeMsN`jFWs{()T~(DBq{_ z{m(ed_bq+@GY|58OyB>^lYC#(_doL}-{yKi2m@c_ZJS z_5JVl{ZF3B_icUulZSl&r~3XUPv!f%zW>Q%`981j{~Ue)uleu&uj~J&y8h48^?$Ce z|FgRO&*=I;)%Aa(>;F{O|3=sUUf2Id*Z*GE|3=sUUf2It*Z)D+|5n%kLD&CQ*Z)D+ z|5n%kLD&CQ*Z)D+|5n%kLD&CQ*Z)D+|3=sUUf2Jo!1~|o`rqjKKj`}3>iR$E`rqpM zKj`}3>iR$G`rqmLKkEA5>H0tF`rqmLKkEA5>H0tF`rqmLKkEA5>H0tF`rqmLKkEA5 z>H0tF`rqmLKj`}3>iR$E`rqpM-xpZ_8(shN_hi37*Z;ha>?i2@pU;u~23`Mi9I_vw z>wk_@_A7M#&w0pxhOYlPPpQTB6m{m(qheouk*KXD=ZL%RO=y8b7QWIsvQ|HPT>H|hGHIF$V; zUH=oOT>lfdvVW!Pf8v_!f8w0$f8w6&fAWCq|DfxC@wof=>;H_d|MPYIpQG#lwg0XEb^pJq?*HfO{(naI|FgRPpXmO7s{8+m z?*Dt;|2Mk-?{)v*=>EUg{ePqT|6ce1jqd+@-Tybb|L=AG-{}6o*ZqI)tIGbW?*Dt; z|2Mk-A9VlU>i&Pw{eP?b|3UZvt?vH^-T!yG{~vY#-|7B;)ct>}`~N}r|E=!-2i^a- zy8j<^|DXHRvR|$H|3UZvt?vH^-T$|`{~vY#-|7B;)ct>_`~Ok*|DEptN8SH-y8j<_ z|KI8Uf7Jbdr~Cg=_y4W#{|DXww*~h9`ExlR(Eb0Q`~SR;oG0l1KcB<>e?C{vA9Vkp zuo|4&?S|DQOK^CI2 z|C3kT|0mDnyiNE2jqd-GmvTO*`~Ru#|C7gZo~Qf&xw`+q_P_mqJ^yd2=l}V7{-4qF z|E!+>Cwl&$>iK`7=l@>M|Basidp-X*dj9YA{NL#Lzt{8sq`>*V*Ykg)=l@>M|E-?? z2R;9{dj22u{NL*Nf6()PtLOhg&;PBS{|7z)w|f5X3!MKOJ^v4S{%`gCKj`_t)ARqR z=l@R6|D&G&J3ar8dj9Y9{6FgXzt!{qpy&U#!1;gB^M9-7|54BXou2ADbN2?J^v?Hf9-$g|62c-qxFCJTK|{P`oC1`{}QeLOSS$l z(fU8H^?yd||Gd`!C0hTNYW-gpbxl&=r1gJZ>;H__{{^l8vs(WbwEoX({a?`fKdbeB zLF@lar<3)6tjm)6EUo{uTK^Zc{?BUtU(otLtMz|T>;IhA{{^l8vs(WbwEoYcu1xC7 zwEoX){h!tPzo7MhPV4`o*8e%J|BG7x=d}JWYW<(n`oEy{e^%@Nyw?8(t^c!H{};9X z&uRT1wCtt+&uRT%)cQZC^?y<8|D4wU1+D+H1?vC!bEyy1`agb-^?$sN)Dvp`AD@%5 z-calRI1bkTaa>ZLsP%swx706c{h!hLKh9I?9ku?CabW!)<0AEuTK~tmiGG6C|1qwt z|BG7x$GEfpFKGQA>oTQ26M2$)O|Ac99;KdB>;J6Q|1s~}H*;G5M_fpKsMh}xH&Q>U z^?yO@|5#@#^`^j`)SqhoA8{%5sapR>+_L_UIA;AHaV_<&TK{LY{*OG6dRVRh^Wcfp z%WC}}c_j6;TK`9$vHp*|lloh&|06G1|3{umy{^{(C0hTN)%w3&t^dpWul`T#|8und zKVR$rGg|+jYW;tr_5Z2X|0i1ipKASoqV@l&*8gX<{@-Z*zt{SIqxJt@>;J9R{|BxA zw_5)nwEo{{{eP;I$H|2wV!k6QolwEjO7sQHI&v~)_pYxP{2d)2S99aL)xUl}8agu%s zt^c=L|L?W_pK+Fc3$6bTTK~_ySoUXV{Xg?2{To{U&%8>1ht~hw0`>pIh4hDL{XcQT z`hVhx_5Z{b>;H)}*8dZCmh~rE{~xse-)Q}RqV@k?>;H*s*8dadtp6wOS^poj{-3;% z{ur(QCvQCaXSDu5qxJvfne^Le{Xcmq{Wx0xPoA>=pS+d+9j*V*YW;t%*8k`ISO2g5 ze>vL!m#_VQ8SVc|wf`^C{=ZcF{}S#0OSS(mqy2x0_Wyb9|1;YE=e7UOX#bzr{y(Gr ze_s3l67Byp+W+UZ|IcdwU(o(PtNnjL`~R%=|Ahu8`~TRtCH-64{};6X&uaf)(EdNC z{eMCG|E%`^1?~Sc+W%*?|1W6&pVj`qsQrIV`~RZ$|2ggd3)=r@wg1m(|6kDlKd1eF z@u8Fbe@^@VqW1qe?f;9~|7W%T&uIT&(EdNC{eMyW|D5*!MeYA{+W!}||IZfa{|nmx z$KPZBA3w+bKi-G^f4ndI|M(o~H`M+=tNnjo`~QOW|8d;x|KmK^|HpZ;|Bv&Oen;*9 zi`xHZwg1m+{~zNf{gc}N$GEcpk8x)IALDLWf1&+<%!~AAYX6_t{y(q%f6S}&cWVEi z)&9Sz{eQ%T^oMHyANFgc|Brp7(oYIpNq?#K{}FfW|053B|3_R(f2#KX1?~SMj-{Vf z`~Ony|0C|%|3@B3Kdkouktgi`BX6XCR{Q^q_Wz~Y|CiPNKk`ueakc-CJZ1kMc`N!I z+W(i;{=Z!9|I7QY|4;k>bF}|IU;FCk6WdQ|xqd{{Nu;|5p3|gZBSh?f(zj|8ENP{|D{=x7z<7wEy2~|9{Z_f2;lf zp+Nt?)&BpW{r^t;|D*Q*JMI4u+W&92{onrop#A?&`~Rak+5hjf|37N~ztjHzP@wvTx{(p{>{r?;{`~Nu)(KFEgf2aNbp+Nt?)&76RN%Ru5 z|DSObJq7LmkJ|rl3-tdpFYN!f+W*hIvHzcWWdDEE{(t6~{r{od|Ly-LE<_(f`~Qg> z_Wu({?EfdOL|;Pt|80T(f3N-j#3}p#iCgyn6UU-wq5c0>`~Q7`{(tg9^f9#mpS)rJ zKY7IdfAWg`|6cq5lLGz!;|4CH;CsqBQT-Ei;CF|6^4D$E*I2RsEl!`af3n zf4u7dP*+9tRaE~6{s1Tc{;K{@Q2igP`aePSf2iXkdM>K}6IB1ls{T(@{U59PKSA|> ztm^+5)&B{q|Kn8uC#wFBQ~jTy`af3ne~jw?1l9j>s{a#J|HrBRPgMOMtNK4i^?!ou z|2WnEiK_qORR1Tc{*P7tAEWv|LG^!}>ii=-uf$x9S|FNq7<5mABsQwS*K>Z)ah5A2?6ZLi<~P|M9B-!#Gp_$EyAh^FaL{=0)_GRR71S{*PDvALf<%Kg=`re}d}&IMx3lE<_(n z^?$tT|9I8^A+9X-rBwgNs{RjgD0)TzbJf;2*c}xADMD>5Ns{fO#`agO9 z>Hk0njQW2$s{fZ&{lARr|D~$`mq1rc^u<*FFID}&MD_o?>i-$l|MRNi>mNC-wiV>i-4R|Ff$9M_o42XH)$@tNMRI z_5ZBu{{_|mLoWZ1{$Ei2KdbtGQT6|v>i-4k%89<5>i=2Q{|nHeqyC>${lBRCe-65J zqF<-_e_r+ftm^+o)&Fy<{})yN&#L~Phi;ze=c)dmQ~kfF`hQOK|Dx*uQI}8j`93^~JW>D8s{SAINc}&j`hU!`=sgzD|06C$A5!)Ih#Ttv5l5mYsrrA^nH0TA z)&C<7ssBe@QvZ)QrT(8){Xehzf2r#K8P)$I?mf@{!2{95RQ*4r`hO{SW4QiT{Xg=G z`hVmZ_5Y0O|B;6Y^*B}kF9V)Z|Bt+-{$HZ{f8@33d#e6l9(XVHf2#kRqx!#D)&I?? z{%@-Kztj~KeNol_O;!KbsQ#~4{a>T{zp3i~rmFvIRR7nj{;yU2U$6SV)I}A2RMr0t zs{daNQEtLpz+)&C8u|7%tMH>mz^0$o?pcUAr0p!&Z~^?!rv|60}m zO;rCksQ#~0{oknizfSdkgX;f!)&I4s{~J~R*Qx$*RQ+G8`oC87f1~REI@SM;s{iX$ z|Cc(tj(WPP|Lau$H>&=xQ~lql`oBi?f352OM%Djys{b2R|JN1J|K-oA|I6Q_{x3gA z{a>g0zd`kXz3Tt+xzzvVIH>>2aRurVtNyQ5{a>s4znmBKe>u;DddI5&>s0?YsQzzI z{a?n7`oD}L^?#k}{|43nHLCw>RsWZHq5d!PME&2W`oC87e^b@}Wu8UvS@nOT>i=5R z{|&&2=tZmkFL6ZuU*d}Tzr-2!e}n4(Qiodfs8#=$IHmqCaVz>2s{d@+s{fx+{r{}$|7TSHKT-Yv6uRTo|2L}t?^XYwI_08QuKNF8_5Y3P z|9jQ{HwEi>Jy|F^3DA5{O} zs{Vf{p#N`G|39k!zf=AHp!)wt_5ZEv|3}sTcdGv%RsWwl^`cj=`u|b&|DEdpN7etg z1@!-e>i;{{|BtHw@1UbEditvWA5{O}L3f|}|55e-o$CJw)&CEw|L;`)KSI}^`u|S# z|6>9DfBu~M|NK4b|MPRy|BtHwZ&m-_s{TKpOZ|V2gZlqb_5bNpAbtg^|Ic|)|DW@s z{(n^ce_KHRKdAmc<3#;`#*O;_PWAukt04Xgs{hZpQ~#fNp#Hy8{r{l)|6cX~t?K_X zuhjo{s{bDf=>HQJ)c+?=sQ*vgh<}9Y{~Oi+C(fwi?&z|4-gg|KEd$;>V%-|EcQ# zleg6WCy%NBPhM01Kco8pdH?DEtN%}q`u}9r|0kpVKUwwv$yfiMME!qK_5U&I|C6f! zPgebZjQan0_5U&I|Ks6vB7P?iob>-O>i-ke|HrETk5~U6ul_$){eOb`|5)|^p%07r zv8ex#RsWx${y$dzf9UHX{x0hOW7YpBs{fBw{~!9qIQqq?|BqGwpQ!#nR{ekIJ0taH z>i^@^|0k;dk5m62`q()7*{J`IQ~#f+{y$Frf9Q)N{y6IYi=WZ|A*tI{}1Ou|DUM-KlC{gza#bkVI1iH!?@7@C#wICRsSEW{y&T>{eKu| z`u{}r|Dg|)_%W&fPf-6Kr~W_8BmIBq>qP$_=2`rn)c?n+|4&f=ANoXzUzGa)5J#SV zQtJN`)c?n*|Bq4sAL5e!Kg22he}ek|(8o&rtknO9IH&)QRsSCk9*_?Scp?5+>iN1rtDOH=>9p#FbW{r`gc|E22xXVw2NsQ;f;|39z(e?k5Ktor{2_5ZU4 z{QrXb|2g&li|YSJA35=pQ~$rH{(nyW|APAe8TJ3O>i-w>PWt~j_5Y)i_4||1YZlpHu%oqyB$U{r{Z$|3&rxv+Dn6)&DQ5|DT(6(*G~Q z_fPuY@Nc9aAbw8&KmH#5|D5{&(MM4H1l9kK&!PVxpG*Hgr~ZFl{r@;l`u}m<^#6Hk;%zeN52 zh*SFi5w{8TE7bpwzLu8$mg@gU+#8<%tN))-|GyMG5x-3J|09nw^wR{d4E;6L|1YEd zf8-(k|H#WM{Qpw*|I4WVA9+mwKk}OXe;M`v%LDIa{jdJNIqLtLRsY|N`v2yu|8MrD zlm5Sn`v0ct|4ScI@gr6LU$6eZM*V-i`v0ct|7+C$H^BE)`k&PQH&y>%U*e?yFLc$# z|2L@rFMUi=uh z|JSPjZ&d$Zr~be6nWg`4Q2$@2{=ZTEf9X>zezofV8{uP1|6iy6zft{vz54$;_5Y3P z|LdMO>Hizl|2L}tuT%fusQ$lJ{eP|c|3>xyb?W~c)&DoB|1b2i#Q!&{|F0|H|I44# z|Chf<|KF(ozgGQ!d0+bf@;Qcn!|MM_A7b$%R{vj)lm5RPxA+&U|F6Zo=>N-k(*Kw9 z2LCHW_5U^M|I0Yh|Ce#2|F2X3-=O}#LH&Ojcl!TE_5Ym%wQU71!&a(es{eLZRNqo|$+S0FD{eOvL z`u_&tn*P5={eKhn|MlPj{eP|c|9bWRP1OIFJfiHnL8 zr{dSG{=d2E|4Uxe|2L!lzj^=p|H216kAC3r1<$2FIDEo$=@$;)aOoR{k9a~q@s(Bf zWa%#spKYo1U@LBitTZiwud>%gR;>QkO zc1wSD__T{(`^~SdmCwV+{iL7!ua^e;yTj*Q{NCaFE}w@Fy!gSx7v9nz9zOAwe(~^) zmp*a$$UFMU!&g4gUmia5fqwJwotO6~eCQ+n=;2Fm^SdMwKJ}J<_3*8i&%?*w(a#>f z_JRKP@VO84yNB<+e7^m@YvbbSmEDPpm)asndd2-$EVp$URd>e^cahIOSi8Hs_oABd zV8b87eTUD<=W!p0`|-X3 z_vdp0o)__4c|OJwF&>V~VtgE@#dsaYEuY6c9OlD$1)(rhkOR)H6XtZ zd1k%?@-F!Y4u}Wh!U7-RoL?^`UMz4U_yLZHC*mpqUluqc-U4tZp9c;D@JL)5;FCBt zz^esr<@3O?1)hm(4}4qT+yn0(xR=j^2LXH_FAVtM!4vYufH%S)@W_Bq?w+aRz)Quk*q040xUozUP7W^8Ww+rc!wg{`?{5 zg7?47!QY2$y+cQGe{R_^v!L67EcJh?`f5qPr*25owxzT57jJsTq_kgXn~ttuO!Pa}rM`jfAT9n4L$rY46cJx~8~Q}fGK=Go30{jR3_68f9>Ec2xw-E4dI zg}kCt|5W$mK7RV|HSF2{o8#$^K7O~cKmKzheR^~g`ls9F+p3xGZWtWKr&TTe)u%l4 zSXedkZ8PoB9`g6M?21Ck<@e3DwTeF+=+EBn`h44~MXTVN_LINguNBJoEru=+2S#kL z^miY1#W!L7sCo9PKG!h*vBOiH><8Uf*8UJsjQ z&I_XtT;S+0zh=RS;9jfX=C6Dt;rr*-mPK5)QWXQ}lN--G;lV6Fv^-o~Rb_es(2m z{^7T@xiPj`-_BA0=f}gtafknLb><;OJ|gmB`Tj?q zBJyRCH;ep5z{U6|%cus)p!1q6JZh-dy+{^c0@F0K>8Suh@ zALL02zK}QMj|Y#)rxd*MeE)-I8Su@6cM1JBz(Wr{l9vhJ|KMo`d`-aHl=?s5aRz)Q zujTy@o|Er+;JxrahO_e0a=+zVGIMDT{lN!pDU&H&zeZ-!fx}t$57%9KYO?;&UFo{o zbu;uAKjVhi(lYBZ*`bXJ(|R4>;JVd4L2^=FOZ zf=$8FpMLwPCVmB-!rz`QP5=7%Z1*bWy$c(<^GaP3>2IIk;yQOmdV1`3aILI=KgmnO zqqmfdFVyYsus#lbb~TBU9>3NNUC`KY{e1q>y6(A>Q|$VU{iFH#RQG4?zwFq_L*klp z^JV@0+V6M7MqjNrQ;KzQg`pAl*(7*Zw;Swce_Sh4|F7w`(Qe9_hr@3_m5*58yYVCL z598l%84vclUEZJgH{zNo+aR$2k%6G6Fl_b zV+OoTxc&!Ev*2q2-lo+51CPmP@;b})KX^{Q=YjXa{~0Ap=4Iy`&l$UWNDlqMAO5LU z=F&e8?Wn-+vq4QQQAYR_2}? z=`Y{omUC>66Boy-efC)D&(`bJAWr%wYhR!Ij>Z0Tob%{p`~D?G+@>Ce{`IzM(W>r$ z^P0x?H_uJzZ$A-!Ag|Xr=4an{9sA#7m0?ptv4K5Ytp^Lo{(tNUdp_yoI^ObjxUt&V zk^ARE4~_~e>(`Ipbb=?)p44|r+r~NY-kE*H6XO5-X}63!f68Ecc*M{+YJU~CK5w(l z-8CwMd&j5A`q95?lgBj&;RSj>y_vzVvD zd^vCMzk)*?7!QNEIPU)=PATH$5I4pzAdU|4WL#zcA8`(dcR<|b`~`Uk$cIB-0`e1( zC*~_f-XisXkw=4kM U{~viq@8TSbyjy<%0}hA>3tSK%#EAu7h#N!wU*L#%N`Wg2 zd=Y0Jc(cGA@#ld<;*q!v-2VqoJ@6WUTjJLP#{qaIuCu^*0M3c`1h^0E{|65Y_z=Jg z^22~9Tkhm#v`8!zXNYv<2T-X8UN^6H#!p8n)3-mPi={PuC*>Hf6|_5c5l zEB%$tUP#7Fe%0W7)A#zdc`|9*F4OkJHU zmkD-y)%~9O|DDd;Y**d4*soZ;EYRQm-J>~v(4Fsv%QCx||3as>-xrRw{mRZA-&OqK zyHx(tZY#Ujd_CZ7`p4T@^&8onpaIx*?N&>F`N3Ul#6PMByQ|_Wa{m0*(~E4GVw-KX zg-s*<>8sy+#BM&<#&4_lk@M?UPiYnh^{#3^{-CO(zx_)G=bJg-U+z}qSy`Vhd8N5) z)+Q&ucgqT%kGqeK)Q`_rZWzv-dy9j9eq4Iqt^@7_Wf1Ih_A9jsfv> zh-*N61LEuu?|`@m_WvUf0r?2Xi$i__@)VFShr9*kFCdQ&`Si$Z;Q2rD?2+$)yi5Lp zg8)1b7l!BmzzOkUfE%9w6GsMkBCd!p3!D*e#GR%81aL?^THuoSG{C6^UWr>n{eR$? zcs9Vb<@rBwo&fI_xaa$)5O`p~2l682`9F9G9D zZlvyg&dksu-QCDb2qGOyNJt~yE!`l>z0a8$N__kP+z?2 ze_@!Q*@2*KkI50%AOG=_R4Vh?pCg%)HMGT+w+U7ck>l;Iqy7C)JK0-xtd#)IJK@=eTw8y=lCR- z?zC#7YJ7IAqrQ6DOW&xyPd{_{+F>mP_16ckUF({dcXjJt=`{7(@0Mw+zebJxrk#&D z>i@idMe7NruDR|#25RcNFU(@QgY zb8Is8<8`f7x%`SWQ}pfq@fz`EepS6G`s$A-^}~auJjee`Exy<1eMP@<)+9}R`Yd$= z|7!jx`fRHNhVg6VvV5$2mPl!C#?|-Kx3BsjgDEnjiT~}ZUNZiT+}F~tThLZF{<)w* ze4IbEqMm+|q@-DRzoV!A&x11+%+jB__;I@nX~fqVmA$)9lIk@$-rK;8}*Y6>_~e$*ww(k4t931w}IUq z^Z(%o1AjR9MdJV9CkKBy_|3q74t{j-r-5G`{OjOn1AjaCo%}Pv0rB8~3*v(~ali|4 zL;N`4hP1#TVk|A}J@JUif81K$=nx4^pw z?&bRzJka0+d11j1@+1UbEOFa`hMzz*ZaD2WOUlp@j2W< zi61_);X(Z4qbe-BcX~j5@q?w8gaz{74OVtdO8vj^@_-U*TGO84?rRw>;*(Y9T6@F7 zSE|}iimXtKU!F0&vz;~lINq%>mip!knmt!7vW>ETl$ay)pN0e1+5OX2+PNLeYwDxN z4&7v1CTy&Cc1=kAbem^4L%~iJ9ptbrz znNJ+`*(dm2dhMA7?%3wOqW|ZHZ*f=am9$5)oz&EKuUH{IT)O*`UR3Uqynk0dyQvpk zedtOaxg1a*{_h_X`nlzMsoK!WqW)jOQeUYaFP`eUo3nfB%cm^+Lf<}6$e$`*T;k7P zjw<8tlx(SMR(YWjpYG2e7^mazKGi+j*I@j=F4p9c&R(m5uW)jgroR2J?OOO?{|WuS zjz7r!*FkGALH6(TjSXFW+LEvIFZQs0x#vBfVo@r_|Lf}u`uJ?uvYJ`-)@a1n`&G7} z+5YiNooai3=HHt`BM0hK=lc8UcdMG6BWmgow!ZK0J*;6W_s^^uzdt!wLz8RcF_md% zFaKYgmgb{<_0);A-Tb=g9c28+ugCxScZ=g5=ka`t>pZUKeH`xRabMow;W-}9<8vML z2ha|-$Dv)G@&9P2Lwh~iE%^)Rhev-5`sL6+hkhFL*P-8z`~R?mgFPJVVqhN!J2}|P zz;2HEf3Ty0Jss>S@&B;1gS{Q>ZaDvk9~}H);1>t~IQYrHUk-k=)c=DY9sFtGR|Egj z&msJ+;dk*raG-$);vxV(G;l(^DBwm@{|`7)z>@~9h%W`4Y2b~xQ=I<;hs2`-E;Zx- zfl~#%YT%amRluHO^~Bg~0^pSq339=c6C zMwug(v-(WQ-{kLSi7D%|4Il36ml$MH_pJ?`j(=>4djB)8&6~R0_%--H|E_S{;5?qM zah*Z_KkuV)KZE;v++X848qf21E}yT_4v+S*U6TKYcCx)1?e=It`w^f&9{pnfEc)ru zUxR*w|2aMEKzlgY#WVj8c5<+ngWU}Ee_=-ldm7l)!M+Z5Hn2DCj_;2`27aJFEc{~N z9}hn%_)EiYp8CJ=qlP~{{HmG%2S0oGTf^@f}Gdfvt5ZgQ@viu&wL z^Xzy1T4dJe@^{wE-){0=tCtYl=kQ>@TmImBq9_ zSIl2JnO;+$zFEJBPta<fSxcmjbZ-&#nNfb+8+<;G=)a_ZVM`! zk>l#>d!66+ufJ<4<3D~q{?ETV9QQbn=Q~{IalOHPct3~x8r+}Had@7=bLIJHhe3PT zE{*mXw3F@CXtzQ8J^I1^X!OgYf9$75e?9sw&xaj6>_NLY*vG?82KI8Wn}huf?C4-m z2fG^Bmv(lrw}IW|`S62*KRo=Rng0(zdH74iZyNsd@S}!5HT>$~U;0_W-wu8k{{si` z`Ay=&0v`@IAzp|Z2mBC6#FGQAH1I{7S>R0rcY;6QPy>&|r2;-Ra7w%?;8r95-vP%8 zcvir*1HOrK1-v`pUY-vgSnz?o2*D2vo{%r(jRk)cctk#h;FSWu$g>c9Q{bJfpMi$~ z_()zxz|R0Y4Z+t4cpE|fe+V9v&k^uC3VxI4G2nYVcrX0_Ge^R>d>b>z&iK&AQ6IeF z;h~Wsttv-bkF6==|BGVj!(rLdM=yLjF`&M9wZZR3p7q`x47;0D-ak42iw0|Y*0O!4 zCR5ZW&$0F+TOmbXxaXkpUt%IH@l}))}i*73*Bv(T&d;#_iwMO zVN8pCPt|kTS}s@2pB|WKfLl=^v%YzIE$gc|SG2SKGe@uB{5$w%wATr)$`ChZcSI)5Tn-y>2ZHm)HMbs@zjT}o3pqoaO$ONlq{v;_d6cGaA&V@$HX%pv(XKv)GFViw<}Wmk9Pt#(pBr`n*nVC=uz z6nVD?G=`?@NVY8I>%N2i+AN7>{H=rWcXy$x=4$6B3iWw>uE||Z;RKo8%A!>~>-U^| za@yU$o5*izJI0JlT+mnPGR6J)(?CYo;7eye22if2HqWTFW8 zA&=t0CktMYUmW3O2#3&(xK6g)Ha)&&%&qDUU9*O^a@c zQs3NX`Neilm{T>Xv`OYask&L!zD7;;cln}@`sfQb=L`=f&hPqdZ%+Mm`_suM_S*d6 zx=+V4j{55L-5C8yjdzveE6DuoX12BN)71I(DwS1JpM86_>3ZYe+0@^|w@UpsUFVD~ zKX01r*Yl>PzWd-)`P|tj_jTEM$L0NfY0Gzd-Pi=aB0h_#4}WdUTRveBueWc@AoKrx zSCX2qCycbU>pXI(FK2e2nC*(RTI0eprDXp3u+VwCx<~<2CoJlzPhYNO0#o_NYJPmu zZ#3usD>l{inSRP+PBty5sBb?#sB2DrFv6`mp8)u8Z?cX|?2~mJ@0uQMVNf5>*ZJ}t zRij@86Suva=ltKCeyo4{{Cz*-Kz`HxpNM{(zJpKjM{6_p%v&=5_HKwt)aVz?Yc4v} z=QE>BtS=q?+LnFL)^Ps+@SkCN>Er_DH|YG9zn#`3s=iIvxiG|MS=30zU;KLfpMQ5a z?s1;M`Mi$#{|5Kr{S@wNSpN^t(RiN5b7lPj?a*kCN4wZQhjx0j*Pz`F?RV&hL4VjU z%ld!lC;O|>Z^Qk6*n#%Is(4+``hT#Kg}prNW;p+c9UbgxU{~7L!OjNu_OQER{002r z;SUYJNc}(fNyA?Xe)F9F!;cRBbnvTze;xen;BN!Ji~oTG4LlGR#D@k>9Ppxn8|MEz z;D~s#z?EbDKj4gbbHJUfKLLjpc+|ip@u`4Q4ZJ$wR&o9h96R8dxDHtV4>;Gry9MrL z{R=!GA1rvGzz^~y0=_8lhWsIq6!>JpEAlG<&n)<+z`H2d-@ro!K9ZLq_!)qw5 z8*u&)9>;>u5%4++ev{`h;CnoHUzOj#$)7*pKcPsD*j~TB6;FNep{EB$p7op%efT6T z*AIgc2~^m#@A^oULwN)0i~lxbRJcXX^@8Fb4GrHraK($5{0%#^sdS=Y`#Q0n*Qnz_K1-4yr^ z^+uawSPQ%O&bMx7=@F*EiTX1B>n4>(Oqu-=QBK{W0hl`{&S4gZ{GL(ErG3U>R@026p${e}Nw~{Ndpj4gVXYjPU3ICL-H{SUWTmy3!aj%QSdh4`agIa3qD7{>nQk5p2vdk@!-Ai zzexTk`%7HS8JnSR(Rk{EA3oPF5*aivI__;1%l-eqv(^byzn3B?QE!{*i@(?W%V5ow z_~?Z^J7oWH%)=kTY9HnZlV7iX)nCBQgf(XKu91dVQ;? zZ(i%YzII)fM0#PJYchYCrk_4<=XxE){hRCmi%m;Ki<51QzeBPOaDe=T*?XCMFks(sq3jhp%SDD~Ujihf1x zwpIId>DQMW_1zaP>7p+l`rRE&aghE`P{)7cTI@}1^359Ws1HA6bV{=?>l1e-T|dSB z{~`@?`MBe|bb(rd=*xfCAhQ`fHK`kP?S||>AEt zUNWU7_3O>o#aF6h=ZpJmS85yT+sBMM=E{Nt8A}xv{*_x+!nB^<-d9g|LBG3ayRMS9 zgCG9DnEV62wA}yCkg%UQn=6U`>iIO**EjdSYUOv7(Yn&WT!#DaTmH^%UjJTQC(YE+ zpX~QPli`m!u1@weKEt-rQosMV8pmv-FIt$GbVGdeVTX04| zH~725afkB^&iA-ZasMCp@wgxFEA{{J96rzCxt{s|Xb0Ql&@O}av7H+2HE1{M|Fa(o z{qg9RLH`{3>Cj(;eoOyh2LpR}*hRxW8g}xq7wu-b{|`GF*wewT4)!&$vxmJk>@M*a z@PmdwH2mVXF34`+CkKBy_|0(tAAYp(r-olW{Hx(-4S#$1UHlImIN*V}AU+&$qJbCU zMsfciIC8)faixGS2b>Xa7Pyo66X1||w7{j#n0gd(s(@Dw+_L^ZaU1~84!G99w*}5E z@UDS-!9RGQzy}9jkRJ*>vEU1N6LS9_JW}8jc_sD#!7~fK1>l{;-++hYV+6bmS^pnA zje@TscpGs4A3Tl+pCjOP6#OR7W5M@$@Lu@8y5JxCo0rNRJ34`mr#^Vvce_RUG+rG| zvo%44@qc+{)(+F$uN3r8^&p1&;@x(g3_6t?7TzmcO2+?Uk8;}!xlHiWg_i;K$xrUC zrm7$48L9m7D2weNho^yeCS#`A#s>1x%;jQZPABiy3o?`Z0)CwZ@z8(egj{_jBw$Nkqeim7Wul8p1)Th66II-z4x4QrC(4U&|f49e$^=+C|Gq29hcht9kIIOW* zdaa~?IDL$af2neH^hJCUvnXF}>f`uZb6T0dCoFT@+TNA?d0jl#m)aSt3U?}Pps(X6 zOigXx`r&=u`g(iM{r6rm%iOcc|GD+w4>e8JRQI3u`Z{QLIo3RSHOeD?�N7>PX36 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�oZC=JQ*p;=sQ;0vx{RvzcN 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 z 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%0D01?0OEG167#M>Aw(ib`RO_;RfT+9EZIIBWRV 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
EM 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%0DS4~ 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 &59jZr-o+IsVws^ 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 literal 0 HcmV?d00001 diff --git a/src/python/larynx_train/norm_audio/trim.py b/src/python/larynx_train/norm_audio/trim.py new file mode 100644 index 0000000..b076e86 --- /dev/null +++ b/src/python/larynx_train/norm_audio/trim.py @@ -0,0 +1,54 @@ +from typing import Optional, Tuple + +import numpy as np + +from .vad import SileroVoiceActivityDetector + + +def trim_silence( + audio_array: np.ndarray, + detector: SileroVoiceActivityDetector, + threshold: float = 0.2, + samples_per_chunk=480, + sample_rate=16000, + keep_chunks_before: int = 2, + keep_chunks_after: int = 2, +) -> Tuple[float, Optional[float]]: + """Returns the offset/duration of trimmed audio in seconds""" + offset_sec: float = 0.0 + duration_sec: Optional[float] = None + first_chunk: Optional[int] = None + last_chunk: Optional[int] = None + seconds_per_chunk: float = samples_per_chunk / sample_rate + + chunk = audio_array[:samples_per_chunk] + audio_array = audio_array[samples_per_chunk:] + chunk_idx: int = 0 + + # Determine main block of speech + while len(audio_array) > 0: + prob = detector(chunk, sample_rate=sample_rate) + is_speech = prob >= threshold + + if is_speech: + if first_chunk is None: + # First speech + first_chunk = chunk_idx + else: + # Last speech so far + last_chunk = chunk_idx + + chunk = audio_array[:samples_per_chunk] + audio_array = audio_array[samples_per_chunk:] + chunk_idx += 1 + + if (first_chunk is not None) and (last_chunk is not None): + first_chunk = max(0, first_chunk - keep_chunks_before) + last_chunk = min(chunk_idx, last_chunk + keep_chunks_after) + + # Compute offset/duration + offset_sec = first_chunk * seconds_per_chunk + last_sec = (last_chunk + 1) * seconds_per_chunk + duration_sec = last_sec - offset_sec + + return offset_sec, duration_sec diff --git a/src/python/larynx_train/norm_audio/vad.py b/src/python/larynx_train/norm_audio/vad.py new file mode 100644 index 0000000..c9de88f --- /dev/null +++ b/src/python/larynx_train/norm_audio/vad.py @@ -0,0 +1,54 @@ +import typing +from pathlib import Path + +import numpy as np +import onnxruntime + + +class SileroVoiceActivityDetector: + """Detects speech/silence using Silero VAD. + + https://github.com/snakers4/silero-vad + """ + + def __init__(self, onnx_path: typing.Union[str, Path]): + onnx_path = str(onnx_path) + + self.session = onnxruntime.InferenceSession(onnx_path) + self.session.intra_op_num_threads = 1 + self.session.inter_op_num_threads = 1 + + self._h = np.zeros((2, 1, 64)).astype("float32") + self._c = np.zeros((2, 1, 64)).astype("float32") + + def __call__(self, audio_array: np.ndarray, sample_rate: int = 16000): + """Return probability of speech in audio [0-1]. + + Audio must be 16Khz 16-bit mono PCM. + """ + if len(audio_array.shape) == 1: + # Add batch dimension + audio_array = np.expand_dims(audio_array, 0) + + if len(audio_array.shape) > 2: + raise ValueError( + f"Too many dimensions for input audio chunk {audio_array.shape}" + ) + + if audio_array.shape[0] > 1: + raise ValueError("Onnx model does not support batching") + + if sample_rate != 16000: + raise ValueError("Only 16Khz audio is supported") + + ort_inputs = { + "input": audio_array.astype(np.float32), + "h0": self._h, + "c0": self._c, + } + ort_outs = self.session.run(None, ort_inputs) + out, self._h, self._c = ort_outs + + out = out.squeeze(2)[:, 1] # make output type match JIT analog + + return out diff --git a/src/python/larynx_train/phonemize.py b/src/python/larynx_train/phonemize.py new file mode 100644 index 0000000..f61dc05 --- /dev/null +++ b/src/python/larynx_train/phonemize.py @@ -0,0 +1,166 @@ +import unicodedata +from collections import Counter +from typing import Dict, Iterable, List, Mapping, Optional + +from espeak_phonemizer import Phonemizer + +DEFAULT_PHONEME_ID_MAP: Dict[str, List[int]] = { + "_": [0], + "^": [1], + "$": [2], + " ": [3], + "!": [4], + "'": [5], + "(": [6], + ")": [7], + ",": [8], + "-": [9], + ".": [10], + ":": [11], + ";": [12], + "?": [13], + "a": [14], + "b": [15], + "c": [16], + "d": [17], + "e": [18], + "f": [19], + "h": [20], + "i": [21], + "j": [22], + "k": [23], + "l": [24], + "m": [25], + "n": [26], + "o": [27], + "p": [28], + "q": [29], + "r": [30], + "s": [31], + "t": [32], + "u": [33], + "v": [34], + "w": [35], + "x": [36], + "y": [37], + "z": [38], + "æ": [39], + "ç": [40], + "ð": [41], + "ø": [42], + "ħ": [43], + "ŋ": [44], + "œ": [45], + "ǀ": [46], + "ǁ": [47], + "ǂ": [48], + "ǃ": [49], + "ɐ": [50], + "ɑ": [51], + "ɒ": [52], + "ɓ": [53], + "ɔ": [54], + "ɕ": [55], + "ɖ": [56], + "ɗ": [57], + "ɘ": [58], + "ə": [59], + "ɚ": [60], + "ɛ": [61], + "ɜ": [62], + "ɞ": [63], + "ɟ": [64], + "ɠ": [65], + "ɡ": [66], + "ɢ": [67], + "ɣ": [68], + "ɤ": [69], + "ɥ": [70], + "ɦ": [71], + "ɧ": [72], + "ɨ": [73], + "ɪ": [74], + "ɫ": [75], + "ɬ": [76], + "ɭ": [77], + "ɮ": [78], + "ɯ": [79], + "ɰ": [80], + "ɱ": [81], + "ɲ": [82], + "ɳ": [83], + "ɴ": [84], + "ɵ": [85], + "ɶ": [86], + "ɸ": [87], + "ɹ": [88], + "ɺ": [89], + "ɻ": [90], + "ɽ": [91], + "ɾ": [92], + "ʀ": [93], + "ʁ": [94], + "ʂ": [95], + "ʃ": [96], + "ʄ": [97], + "ʈ": [98], + "ʉ": [99], + "ʊ": [100], + "ʋ": [101], + "ʌ": [102], + "ʍ": [103], + "ʎ": [104], + "ʏ": [105], + "ʐ": [106], + "ʑ": [107], + "ʒ": [108], + "ʔ": [109], + "ʕ": [110], + "ʘ": [111], + "ʙ": [112], + "ʛ": [113], + "ʜ": [114], + "ʝ": [115], + "ʟ": [116], + "ʡ": [117], + "ʢ": [118], + "ʲ": [119], + "ˈ": [120], + "ˌ": [121], + "ː": [122], + "ˑ": [123], + "˞": [124], + "β": [125], + "θ": [126], + "χ": [127], + "ᵻ": [128], + "ⱱ": [129], +} + + +def phonemize(text: str, phonemizer: Phonemizer) -> List[str]: + phonemes_str = phonemizer.phonemize(text=text, keep_clause_breakers=True) + + # Phonemes are decomposed into unicode codepoints + return list(unicodedata.normalize("NFD", phonemes_str)) + + +def phonemes_to_ids( + phonemes: Iterable[str], + phoneme_id_map: Optional[Mapping[str, Iterable[int]]] = None, + missing_phonemes: Optional[Counter[str]] = None, +) -> List[int]: + if phoneme_id_map is None: + phoneme_id_map = DEFAULT_PHONEME_ID_MAP + + phoneme_ids: List[int] = [] + + for phoneme in phonemes: + mapped_phoneme_ids = phoneme_id_map.get(phoneme) + if mapped_phoneme_ids: + phoneme_ids.extend(mapped_phoneme_ids) + elif missing_phonemes is not None: + # Make note of missing phonemes + missing_phonemes[phoneme] += 1 + + return phoneme_ids diff --git a/src/python/larynx_train/preprocess.py b/src/python/larynx_train/preprocess.py new file mode 100644 index 0000000..7dd0f40 --- /dev/null +++ b/src/python/larynx_train/preprocess.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python3 +import argparse +import dataclasses +import itertools +import json +import logging +from dataclasses import dataclass +from pathlib import Path +from typing import Dict, Iterable, List, Optional, Set + +from espeak_phonemizer import Phonemizer + +from .norm_audio import cache_norm_audio, make_silence_detector +from .phonemize import DEFAULT_PHONEME_ID_MAP, phonemes_to_ids, phonemize + +_LOGGER = logging.getLogger("preprocess") + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--input-dir", required=True, help="Directory with audio dataset" + ) + parser.add_argument( + "--output-dir", + required=True, + help="Directory to write output files for training", + ) + parser.add_argument("--language", required=True, help="eSpeak-ng voice") + parser.add_argument( + "--sample-rate", + type=int, + required=True, + help="Target sample rate for voice (hertz)", + ) + parser.add_argument("--cache-dir", help="Directory to cache processed audio files") + args = parser.parse_args() + + logging.basicConfig(level=logging.INFO) + logging.getLogger("numba").setLevel(logging.WARNING) + + # Convert to paths and create output directories + args.input_dir = Path(args.input_dir) + args.output_dir = Path(args.output_dir) + args.output_dir.mkdir(parents=True, exist_ok=True) + + args.cache_dir = ( + Path(args.cache_dir) + if args.cache_dir + else args.output_dir / "cache" / str(args.sample_rate) + ) + args.cache_dir.mkdir(parents=True, exist_ok=True) + + # Count speakers + _LOGGER.info("Counting number of speakers in the dataset") + speakers: Set[str] = set() + for utt in mycroft_dataset(args.input_dir): + speakers.add(utt.speaker or "") + + is_multispeaker = len(speakers) > 1 + speaker_ids: Dict[str, int] = {} + + if is_multispeaker: + _LOGGER.info("%s speaker(s) detected", len(speakers)) + + # Assign speaker ids in sorted order + for speaker_id, speaker in enumerate(sorted(speakers)): + speaker_ids[speaker] = speaker_id + else: + _LOGGER.info("Single speaker dataset") + + # Write config + with open(args.output_dir / "config.json", "w", encoding="utf-8") as config_file: + json.dump( + { + "audio": { + "sample_rate": args.sample_rate, + }, + "espeak": { + "voice": args.language, + }, + "inference": {"noise_scale": 0.667, "length_scale": 1, "noise_w": 0.8}, + "phoneme_map": {}, + "phoneme_id_map": DEFAULT_PHONEME_ID_MAP, + "num_symbols": len( + set(itertools.chain.from_iterable(DEFAULT_PHONEME_ID_MAP.values())) + ), + "num_speakers": len(speakers), + "speaker_id_map": speaker_ids, + }, + config_file, + ensure_ascii=False, + indent=4, + ) + _LOGGER.info("Wrote dataset config") + + # Used to trim silence + silence_detector = make_silence_detector() + + with open(args.output_dir / "dataset.jsonl", "w", encoding="utf-8") as dataset_file: + phonemizer = Phonemizer(default_voice=args.language) + for utt in mycroft_dataset(args.input_dir): + try: + utt.audio_path = utt.audio_path.absolute() + _LOGGER.debug(utt) + + utt.phonemes = phonemize(utt.text, phonemizer) + utt.phoneme_ids = phonemes_to_ids(utt.phonemes) + utt.audio_norm_path, utt.audio_spec_path = cache_norm_audio( + utt.audio_path, args.cache_dir, silence_detector, args.sample_rate + ) + + # JSONL + json.dump( + dataclasses.asdict(utt), + dataset_file, + ensure_ascii=False, + cls=PathEncoder, + ) + print("", file=dataset_file) + except Exception: + _LOGGER.exception("Failed to process utterance: %s", utt) + + +# ----------------------------------------------------------------------------- + + +@dataclass +class Utterance: + text: str + audio_path: Path + speaker: Optional[str] = None + phonemes: Optional[List[str]] = None + phoneme_ids: Optional[List[int]] = None + audio_norm_path: Optional[Path] = None + audio_spec_path: Optional[Path] = None + + +class PathEncoder(json.JSONEncoder): + def default(self, o): + if isinstance(o, Path): + return str(o) + return super().default(o) + + +def mycroft_dataset(dataset_dir: Path) -> Iterable[Utterance]: + for info_path in dataset_dir.glob("*.info"): + wav_path = info_path.with_suffix(".wav") + if wav_path.exists(): + text = info_path.read_text(encoding="utf-8").strip() + yield Utterance(text=text, audio_path=wav_path) + + +# ----------------------------------------------------------------------------- + +if __name__ == "__main__": + main() diff --git a/src/python/larynx_train/py.typed b/src/python/larynx_train/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/src/python/larynx_train/pylintrc b/src/python/larynx_train/pylintrc new file mode 100644 index 0000000..ea7eeab --- /dev/null +++ b/src/python/larynx_train/pylintrc @@ -0,0 +1,40 @@ +[MESSAGES CONTROL] +disable= + format, + abstract-class-little-used, + abstract-method, + cyclic-import, + duplicate-code, + global-statement, + import-outside-toplevel, + inconsistent-return-statements, + locally-disabled, + not-context-manager, + redefined-variable-type, + too-few-public-methods, + too-many-arguments, + too-many-branches, + too-many-instance-attributes, + too-many-lines, + too-many-locals, + too-many-public-methods, + too-many-return-statements, + too-many-statements, + too-many-boolean-expressions, + unnecessary-pass, + unused-argument, + broad-except, + too-many-nested-blocks, + invalid-name, + unused-import, + no-self-use, + fixme, + useless-super-delegation, + missing-module-docstring, + missing-class-docstring, + missing-function-docstring, + import-error, + relative-beyond-top-level + +[FORMAT] +expected-line-ending-format=LF diff --git a/src/python/larynx_train/setup.cfg b/src/python/larynx_train/setup.cfg new file mode 100644 index 0000000..0076bbf --- /dev/null +++ b/src/python/larynx_train/setup.cfg @@ -0,0 +1,22 @@ +[flake8] +# To work with Black +max-line-length = 88 +# E501: line too long +# W503: Line break occurred before a binary operator +# E203: Whitespace before ':' +# D202 No blank lines allowed after function docstring +# W504 line break after binary operator +ignore = + E501, + W503, + E203, + D202, + W504 + +[isort] +multi_line_output = 3 +include_trailing_comma=True +force_grid_wrap=0 +use_parentheses=True +line_length=88 +indent = " " diff --git a/src/python/larynx_train/vits/__init__.py b/src/python/larynx_train/vits/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/python/larynx_train/vits/attentions.py b/src/python/larynx_train/vits/attentions.py new file mode 100644 index 0000000..4f0e4af --- /dev/null +++ b/src/python/larynx_train/vits/attentions.py @@ -0,0 +1,417 @@ +import math +import typing + +import torch +from torch import nn +from torch.nn import functional as F + +from .commons import subsequent_mask +from .modules import LayerNorm + + +class Encoder(nn.Module): + def __init__( + self, + hidden_channels: int, + filter_channels: int, + n_heads: int, + n_layers: int, + kernel_size: int = 1, + p_dropout: float = 0.0, + window_size: int = 4, + **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 + + 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): + attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1) + x = x * x_mask + for i in range(self.n_layers): + 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: int, + filter_channels: int, + n_heads: int, + n_layers: int, + kernel_size: int = 1, + p_dropout: float = 0.0, + proximal_bias: bool = False, + proximal_init: bool = 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 = subsequent_mask(x_mask.size(2)).type_as(x) + 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: int, + out_channels: int, + n_heads: int, + p_dropout: float = 0.0, + window_size: typing.Optional[int] = None, + heads_share: bool = True, + block_length: typing.Optional[int] = None, + proximal_bias: bool = False, + proximal_init: bool = 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).type_as(scores) + 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, + # convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]), + (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, convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 1]])) + x = F.pad(x, (0, 1, 0, 0, 0, 0, 0, 0)) + + # 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, convert_pad_shape([[0, 0], [0, 0], [0, length - 1]])) + x_flat = F.pad(x_flat, (0, length - 1, 0, 0, 0, 0)) + + # 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, convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length - 1]])) + x = F.pad(x, (0, length - 1, 0, 0, 0, 0, 0, 0)) + x_flat = x.view([batch, heads, (length * length) + (length * (length - 1))]) + # add 0's in the beginning that will skew the elements after reshape + # x_flat = F.pad(x_flat, convert_pad_shape([[0, 0], [0, 0], [length, 0]])) + x_flat = F.pad(x_flat, (length, 0, 0, 0, 0, 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: int, + out_channels: int, + filter_channels: int, + kernel_size: int, + p_dropout: float = 0.0, + activation: typing.Optional[str] = None, + causal: bool = 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, convert_pad_shape(padding)) + x = F.pad(x, (pad_l, pad_r, 0, 0, 0, 0)) + 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, convert_pad_shape(padding)) + x = F.pad(x, (pad_l, pad_r, 0, 0, 0, 0)) + return x diff --git a/src/python/larynx_train/vits/commons.py b/src/python/larynx_train/vits/commons.py new file mode 100644 index 0000000..615af25 --- /dev/null +++ b/src/python/larynx_train/vits/commons.py @@ -0,0 +1,146 @@ +import logging +import math + +import torch +from torch.nn import functional as F + +_LOGGER = logging.getLogger("vits.commons") + + +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 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.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * 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 = max(0, 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 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] + """ + 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).type_as(mask) + path = path.view(b, t_x, t_y) + path = path - F.pad(path, (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.0 / norm_type) + return total_norm diff --git a/src/python/larynx_train/vits/config.py b/src/python/larynx_train/vits/config.py new file mode 100644 index 0000000..e878f02 --- /dev/null +++ b/src/python/larynx_train/vits/config.py @@ -0,0 +1,330 @@ +"""Configuration classes""" +from dataclasses import dataclass, field +from typing import Optional, Tuple + + +@dataclass +class MelAudioConfig: + filter_length: int = 1024 + hop_length: int = 256 + win_length: int = 1024 + mel_channels: int = 80 + sample_rate: int = 22050 + sample_bytes: int = 2 + channels: int = 1 + mel_fmin: float = 0.0 + mel_fmax: Optional[float] = None + + +@dataclass +class ModelAudioConfig: + resblock: str + resblock_kernel_sizes: Tuple[int, ...] + resblock_dilation_sizes: Tuple[Tuple[int, ...], ...] + upsample_rates: Tuple[int, ...] + upsample_initial_channel: int + upsample_kernel_sizes: Tuple[int, ...] + + @staticmethod + def low_quality() -> "ModelAudioConfig": + return ModelAudioConfig( + resblock="2", + resblock_kernel_sizes=(3, 5, 7), + resblock_dilation_sizes=( + (1, 2), + (2, 6), + (3, 12), + ), + upsample_rates=(8, 8, 4), + upsample_initial_channel=256, + upsample_kernel_sizes=(16, 16, 8), + ) + + @staticmethod + def high_quality() -> "ModelAudioConfig": + return ModelAudioConfig( + 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), + upsample_initial_channel=512, + upsample_kernel_sizes=(16, 16, 4, 4), + ) + + +@dataclass +class ModelConfig: + num_symbols: int + n_speakers: int + audio: ModelAudioConfig + mel: MelAudioConfig = field(default_factory=MelAudioConfig) + + inter_channels: int = 192 + hidden_channels: int = 192 + filter_channels: int = 768 + n_heads: int = 2 + n_layers: int = 6 + kernel_size: int = 3 + p_dropout: float = 0.1 + n_layers_q: int = 3 + use_spectral_norm: bool = False + gin_channels: int = 0 # single speaker + use_sdp: bool = True # StochasticDurationPredictor + segment_size: int = 8192 + + @property + def is_multispeaker(self) -> bool: + return self.n_speakers > 1 + + @property + def resblock(self) -> str: + return self.audio.resblock + + @property + def resblock_kernel_sizes(self) -> Tuple[int, ...]: + return self.audio.resblock_kernel_sizes + + @property + def resblock_dilation_sizes(self) -> Tuple[Tuple[int, ...], ...]: + return self.audio.resblock_dilation_sizes + + @property + def upsample_rates(self) -> Tuple[int, ...]: + return self.audio.upsample_rates + + @property + def upsample_initial_channel(self) -> int: + return self.audio.upsample_initial_channel + + @property + def upsample_kernel_sizes(self) -> Tuple[int, ...]: + return self.audio.upsample_kernel_sizes + + def __post_init__(self): + if self.is_multispeaker and (self.gin_channels == 0): + self.gin_channels = 512 + + +@dataclass +class TrainingConfig: + learning_rate: float = 2e-4 + betas: Tuple[float, float] = field(default=(0.8, 0.99)) + eps: float = 1e-9 + # batch_size: int = 32 + fp16_run: bool = False + lr_decay: float = 0.999875 + init_lr_ratio: float = 1.0 + warmup_epochs: int = 0 + c_mel: int = 45 + c_kl: float = 1.0 + grad_clip: Optional[float] = None + + +# @dataclass +# class PhonemesConfig(DataClassJsonMixin): +# phoneme_separator: str = " " +# """Separator between individual phonemes in CSV input""" + +# word_separator: str = "#" +# """Separator between word phonemes in CSV input (must not match phoneme_separator)""" + +# phoneme_to_id: typing.Optional[typing.Dict[str, int]] = None +# pad: typing.Optional[str] = "_" +# bos: typing.Optional[str] = None +# eos: typing.Optional[str] = None +# blank: typing.Optional[str] = "#" +# blank_word: typing.Optional[str] = None +# blank_between: typing.Union[str, BlankBetween] = BlankBetween.WORDS +# blank_at_start: bool = True +# blank_at_end: bool = True +# simple_punctuation: bool = True +# punctuation_map: typing.Optional[typing.Dict[str, str]] = None +# separate: typing.Optional[typing.List[str]] = None +# separate_graphemes: bool = False +# separate_tones: bool = False +# tone_before: bool = False +# phoneme_map: typing.Optional[typing.Dict[str, typing.List[str]]] = None +# auto_bos_eos: bool = False +# minor_break: typing.Optional[str] = IPA.BREAK_MINOR.value +# major_break: typing.Optional[str] = IPA.BREAK_MAJOR.value +# break_phonemes_into_graphemes: bool = False +# break_phonemes_into_codepoints: bool = False +# drop_stress: bool = False +# symbols: typing.Optional[typing.List[str]] = None + +# def split_word_phonemes(self, phonemes_str: str) -> typing.List[typing.List[str]]: +# """Split phonemes string into a list of lists (outer is words, inner is individual phonemes in each word)""" +# return [ +# word_phonemes_str.split(self.phoneme_separator) +# if self.phoneme_separator +# else list(word_phonemes_str) +# for word_phonemes_str in phonemes_str.split(self.word_separator) +# ] + +# def join_word_phonemes(self, word_phonemes: typing.List[typing.List[str]]) -> str: +# """Split phonemes string into a list of lists (outer is words, inner is individual phonemes in each word)""" +# return self.word_separator.join( +# self.phoneme_separator.join(wp) for wp in word_phonemes +# ) + + +# class Phonemizer(str, Enum): +# SYMBOLS = "symbols" +# GRUUT = "gruut" +# ESPEAK = "espeak" +# EPITRAN = "epitran" + + +# class Aligner(str, Enum): +# KALDI_ALIGN = "kaldi_align" + + +# class TextCasing(str, Enum): +# LOWER = "lower" +# UPPER = "upper" + + +# class MetadataFormat(str, Enum): +# TEXT = "text" +# PHONEMES = "phonemes" +# PHONEME_IDS = "ids" + + +# @dataclass +# class DatasetConfig: +# name: str +# metadata_format: MetadataFormat = MetadataFormat.TEXT +# multispeaker: bool = False +# text_language: typing.Optional[str] = None +# audio_dir: typing.Optional[typing.Union[str, Path]] = None +# cache_dir: typing.Optional[typing.Union[str, Path]] = None + +# def get_cache_dir(self, output_dir: typing.Union[str, Path]) -> Path: +# if self.cache_dir is not None: +# cache_dir = Path(self.cache_dir) +# else: +# cache_dir = Path("cache") / self.name + +# if not cache_dir.is_absolute(): +# cache_dir = Path(output_dir) / str(cache_dir) + +# return cache_dir + + +# @dataclass +# class AlignerConfig: +# aligner: typing.Optional[Aligner] = None +# casing: typing.Optional[TextCasing] = None + + +# @dataclass +# class InferenceConfig: +# length_scale: float = 1.0 +# noise_scale: float = 0.667 +# noise_w: float = 0.8 + + +# @dataclass +# class TrainingConfig(DataClassJsonMixin): +# seed: int = 1234 +# epochs: int = 10000 +# learning_rate: float = 2e-4 +# betas: typing.Tuple[float, float] = field(default=(0.8, 0.99)) +# eps: float = 1e-9 +# batch_size: int = 32 +# fp16_run: bool = False +# lr_decay: float = 0.999875 +# segment_size: int = 8192 +# init_lr_ratio: float = 1.0 +# warmup_epochs: int = 0 +# c_mel: int = 45 +# c_kl: float = 1.0 +# grad_clip: typing.Optional[float] = None + +# min_seq_length: typing.Optional[int] = None +# max_seq_length: typing.Optional[int] = None + +# min_spec_length: typing.Optional[int] = None +# max_spec_length: typing.Optional[int] = None + +# min_speaker_utterances: typing.Optional[int] = None + +# last_epoch: int = 1 +# global_step: int = 1 +# best_loss: typing.Optional[float] = None +# audio: AudioConfig = field(default_factory=AudioConfig) +# model: ModelConfig = field(default_factory=ModelConfig) +# phonemes: PhonemesConfig = field(default_factory=PhonemesConfig) +# text_aligner: AlignerConfig = field(default_factory=AlignerConfig) +# text_language: typing.Optional[str] = None +# phonemizer: typing.Optional[Phonemizer] = None +# datasets: typing.List[DatasetConfig] = field(default_factory=list) +# inference: InferenceConfig = field(default_factory=InferenceConfig) + +# version: int = 1 +# git_commit: str = "" + +# @property +# def is_multispeaker(self): +# return self.model.is_multispeaker or any(d.multispeaker for d in self.datasets) + +# def save(self, config_file: typing.TextIO): +# """Save config as JSON to a file""" +# json.dump(self.to_dict(), config_file, indent=4) + +# def get_speaker_id(self, dataset_name: str, speaker_name: str) -> int: +# if self.speaker_id_map is None: +# self.speaker_id_map = {} + +# full_speaker_name = f"{dataset_name}_{speaker_name}" +# speaker_id = self.speaker_id_map.get(full_speaker_name) +# if speaker_id is None: +# speaker_id = len(self.speaker_id_map) +# self.speaker_id_map[full_speaker_name] = speaker_id + +# return speaker_id + +# @staticmethod +# def load(config_file: typing.TextIO) -> "TrainingConfig": +# """Load config from a JSON file""" +# return TrainingConfig.from_json(config_file.read()) + +# @staticmethod +# def load_and_merge( +# config: "TrainingConfig", +# config_files: typing.Iterable[typing.Union[str, Path, typing.TextIO]], +# ) -> "TrainingConfig": +# """Loads one or more JSON configuration files and overlays them on top of an existing config""" +# base_dict = config.to_dict() +# for maybe_config_file in config_files: +# if isinstance(maybe_config_file, (str, Path)): +# # File path +# config_file = open(maybe_config_file, "r", encoding="utf-8") +# else: +# # File object +# config_file = maybe_config_file + +# with config_file: +# # Load new config and overlay on existing config +# new_dict = json.load(config_file) +# TrainingConfig.recursive_update(base_dict, new_dict) + +# return TrainingConfig.from_dict(base_dict) + +# @staticmethod +# def recursive_update( +# base_dict: typing.Dict[typing.Any, typing.Any], +# new_dict: typing.Mapping[typing.Any, typing.Any], +# ) -> None: +# """Recursively overwrites values in base dictionary with values from new dictionary""" +# for key, value in new_dict.items(): +# if isinstance(value, collections.Mapping) and ( +# base_dict.get(key) is not None +# ): +# TrainingConfig.recursive_update(base_dict[key], value) +# else: +# base_dict[key] = value diff --git a/src/python/larynx_train/vits/dataset.py b/src/python/larynx_train/vits/dataset.py new file mode 100644 index 0000000..c30b517 --- /dev/null +++ b/src/python/larynx_train/vits/dataset.py @@ -0,0 +1,208 @@ +import json +import logging +from dataclasses import dataclass +from pathlib import Path +from typing import Iterable, List, Optional, Sequence, Union + +import torch +from torch import FloatTensor, LongTensor +from torch.utils.data import Dataset + + +_LOGGER = logging.getLogger("vits.dataset") + + +@dataclass +class Utterance: + phoneme_ids: List[int] + audio_norm_path: Path + audio_spec_path: Path + speaker_id: Optional[int] = None + text: Optional[str] = None + + +@dataclass +class UtteranceTensors: + phoneme_ids: LongTensor + spectrogram: FloatTensor + audio_norm: FloatTensor + speaker_id: Optional[LongTensor] = None + text: Optional[str] = None + + @property + def spec_length(self) -> int: + return self.spectrogram.size(1) + + +@dataclass +class Batch: + phoneme_ids: LongTensor + phoneme_lengths: LongTensor + spectrograms: FloatTensor + spectrogram_lengths: LongTensor + audios: FloatTensor + audio_lengths: LongTensor + speaker_ids: Optional[LongTensor] = None + + +# @dataclass +# class LarynxDatasetSettings: +# sample_rate: int +# is_multispeaker: bool +# espeak_voice: Optional[str] = None +# phoneme_map: Dict[str, Optional[List[str]]] = field(default_factory=dict) +# phoneme_id_map: Dict[str, List[int]] = DEFAULT_PHONEME_ID_MAP + + +class LarynxDataset(Dataset): + """ + Dataset format: + + * phoneme_ids (required) + * audio_norm_path (required) + * audio_spec_path (required) + * text (optional) + * phonemes (optional) + * audio_path (optional) + """ + + def __init__( + self, + dataset_paths: List[Union[str, Path]], # settings: LarynxDatasetSettings + ): + # self.settings = settings + self.utterances: List[Utterance] = [] + + for dataset_path in dataset_paths: + dataset_path = Path(dataset_path) + _LOGGER.debug("Loading dataset: %s", dataset_path) + self.utterances.extend(LarynxDataset.load_dataset(dataset_path)) + + def __len__(self): + return len(self.utterances) + + def __getitem__(self, idx) -> UtteranceTensors: + utt = self.utterances[idx] + return UtteranceTensors( + phoneme_ids=LongTensor(utt.phoneme_ids), + audio_norm=torch.load(utt.audio_norm_path), + spectrogram=torch.load(utt.audio_spec_path), + speaker_id=LongTensor([utt.speaker_id]) + if utt.speaker_id is not None + else None, + text=utt.text, + ) + + @staticmethod + def load_dataset(dataset_path: Path) -> Iterable[Utterance]: + with open(dataset_path, "r", encoding="utf-8") as dataset_file: + for line_idx, line in enumerate(dataset_file): + line = line.strip() + if not line: + continue + + try: + yield LarynxDataset.load_utterance(line) + except Exception: + _LOGGER.exception( + "Error on line %s of %s: %s", + line_idx + 1, + dataset_path, + line, + ) + + @staticmethod + def load_utterance(line: str) -> Utterance: + utt_dict = json.loads(line) + return Utterance( + phoneme_ids=utt_dict["phoneme_ids"], + audio_norm_path=Path(utt_dict["audio_norm_path"]), + audio_spec_path=Path(utt_dict["audio_spec_path"]), + speaker_id=utt_dict.get("speaker_id"), + text=utt_dict.get("text"), + ) + + +class UtteranceCollate: + def __init__(self, is_multispeaker: bool, segment_size: int): + self.is_multispeaker = is_multispeaker + self.segment_size = segment_size + + def __call__(self, utterances: Sequence[UtteranceTensors]) -> Batch: + num_utterances = len(utterances) + assert num_utterances > 0, "No utterances" + + max_phonemes_length = 0 + max_spec_length = 0 + max_audio_length = 0 + + num_mels = 0 + + # Determine lengths + for utt_idx, utt in enumerate(utterances): + assert utt.spectrogram is not None + assert utt.audio_norm is not None + + phoneme_length = utt.phoneme_ids.size(0) + spec_length = utt.spectrogram.size(1) + audio_length = utt.audio_norm.size(1) + + max_phonemes_length = max(max_phonemes_length, phoneme_length) + max_spec_length = max(max_spec_length, spec_length) + max_audio_length = max(max_audio_length, audio_length) + + num_mels = utt.spectrogram.size(0) + if self.is_multispeaker: + assert utt.speaker_id is not None, "Missing speaker id" + + # Audio cannot be smaller than segment size (8192) + max_audio_length = max(max_audio_length, self.segment_size) + + # Create padded tensors + phonemes_padded = LongTensor(num_utterances, max_phonemes_length) + spec_padded = FloatTensor(num_utterances, num_mels, max_spec_length) + audio_padded = FloatTensor(num_utterances, 1, max_audio_length) + + phonemes_padded.zero_() + spec_padded.zero_() + audio_padded.zero_() + + phoneme_lengths = LongTensor(num_utterances) + spec_lengths = LongTensor(num_utterances) + audio_lengths = LongTensor(num_utterances) + + speaker_ids: Optional[LongTensor] = None + if self.is_multispeaker: + speaker_ids = LongTensor(num_utterances) + + # Sort by decreasing spectrogram length + sorted_utterances = sorted( + utterances, key=lambda u: u.spectrogram.size(1), reverse=True + ) + for utt_idx, utt in enumerate(sorted_utterances): + phoneme_length = utt.phoneme_ids.size(0) + spec_length = utt.spectrogram.size(1) + audio_length = utt.audio_norm.size(1) + + phonemes_padded[utt_idx, :phoneme_length] = utt.phoneme_ids + phoneme_lengths[utt_idx] = phoneme_length + + spec_padded[utt_idx, :, :spec_length] = utt.spectrogram + spec_lengths[utt_idx] = spec_length + + audio_padded[utt_idx, :, :audio_length] = utt.audio_norm + audio_lengths[utt_idx] = audio_length + + if utt.speaker_id is not None: + assert speaker_ids is not None + speaker_ids[utt_idx] = utt.speaker_id + + return Batch( + phoneme_ids=phonemes_padded, + phoneme_lengths=phoneme_lengths, + spectrograms=spec_padded, + spectrogram_lengths=spec_lengths, + audios=audio_padded, + audio_lengths=audio_lengths, + speaker_ids=speaker_ids, + ) diff --git a/src/python/larynx_train/vits/lightning.py b/src/python/larynx_train/vits/lightning.py new file mode 100644 index 0000000..cb5b549 --- /dev/null +++ b/src/python/larynx_train/vits/lightning.py @@ -0,0 +1,330 @@ +import logging +from pathlib import Path +from typing import List, Optional, Tuple, Union + +import pytorch_lightning as pl +import torch +from torch import autocast +from torch.nn import functional as F +from torch.utils.data import DataLoader, Dataset, random_split + +from .commons import slice_segments +from .dataset import Batch, LarynxDataset, UtteranceCollate +from .losses import discriminator_loss, feature_loss, generator_loss, kl_loss +from .mel_processing import mel_spectrogram_torch, spec_to_mel_torch +from .models import MultiPeriodDiscriminator, SynthesizerTrn + +_LOGGER = logging.getLogger("vits.lightning") + + +class VitsModel(pl.LightningModule): + def __init__( + self, + num_symbols: int, + num_speakers: int, + # audio + resblock="2", + resblock_kernel_sizes=(3, 5, 7), + resblock_dilation_sizes=( + (1, 2), + (2, 6), + (3, 12), + ), + upsample_rates=(8, 8, 4), + upsample_initial_channel=256, + upsample_kernel_sizes=(16, 16, 8), + # mel + filter_length: int = 1024, + hop_length: int = 256, + win_length: int = 1024, + mel_channels: int = 80, + sample_rate: int = 22050, + sample_bytes: int = 2, + channels: int = 1, + mel_fmin: float = 0.0, + mel_fmax: Optional[float] = None, + # model + inter_channels: int = 192, + hidden_channels: int = 192, + filter_channels: int = 768, + n_heads: int = 2, + n_layers: int = 6, + kernel_size: int = 3, + p_dropout: float = 0.1, + n_layers_q: int = 3, + use_spectral_norm: bool = False, + gin_channels: int = 0, + use_sdp: bool = True, + segment_size: int = 8192, + # training + dataset: Optional[List[Union[str, Path]]] = None, + learning_rate: float = 2e-4, + betas: Tuple[float, float] = (0.8, 0.99), + eps: float = 1e-9, + batch_size: int = 1, + lr_decay: float = 0.999875, + init_lr_ratio: float = 1.0, + warmup_epochs: int = 0, + c_mel: int = 45, + c_kl: float = 1.0, + grad_clip: Optional[float] = None, + num_workers: int = 1, + seed: int = 1234, + num_test_examples: int = 5, + validation_split: float = 0.1, + **kwargs + ): + super().__init__() + self.save_hyperparameters() + + if (self.hparams.num_speakers > 1) and (self.hparams.gin_channels <= 0): + # Default gin_channels for multi-speaker model + self.hparams.gin_channels = 512 + + # Set up models + self.model_g = SynthesizerTrn( + n_vocab=self.hparams.num_symbols, + spec_channels=self.hparams.filter_length // 2 + 1, + segment_size=self.hparams.segment_size // self.hparams.hop_length, + inter_channels=self.hparams.inter_channels, + hidden_channels=self.hparams.hidden_channels, + filter_channels=self.hparams.filter_channels, + n_heads=self.hparams.n_heads, + n_layers=self.hparams.n_layers, + kernel_size=self.hparams.kernel_size, + p_dropout=self.hparams.p_dropout, + resblock=self.hparams.resblock, + resblock_kernel_sizes=self.hparams.resblock_kernel_sizes, + resblock_dilation_sizes=self.hparams.resblock_dilation_sizes, + upsample_rates=self.hparams.upsample_rates, + upsample_initial_channel=self.hparams.upsample_initial_channel, + upsample_kernel_sizes=self.hparams.upsample_kernel_sizes, + n_speakers=self.hparams.num_speakers, + gin_channels=self.hparams.gin_channels, + use_sdp=self.hparams.use_sdp, + ) + self.model_d = MultiPeriodDiscriminator( + use_spectral_norm=self.hparams.use_spectral_norm + ) + + # Dataset splits + self._train_dataset: Optional[Dataset] = None + self._val_dataset: Optional[Dataset] = None + self._test_dataset: Optional[Dataset] = None + self._load_datasets(validation_split, num_test_examples) + + # State kept between training optimizers + self._y = None + self._y_hat = None + + def _load_datasets(self, validation_split: float, num_test_examples: int): + full_dataset = LarynxDataset(self.hparams.dataset) + valid_set_size = int(len(full_dataset) * validation_split) + train_set_size = len(full_dataset) - valid_set_size - num_test_examples + + self._train_dataset, self._test_dataset, self._val_dataset = random_split( + full_dataset, [train_set_size, num_test_examples, valid_set_size] + ) + + def forward(self, text, text_lengths, scales, sid=None): + noise_scale = scales[0] + length_scale = scales[1] + noise_scale_w = scales[2] + audio, *_ = self.model_g.infer( + text, + text_lengths, + noise_scale=noise_scale, + length_scale=length_scale, + noise_scale_w=noise_scale_w, + sid=sid, + ) + + return audio + + def train_dataloader(self): + return DataLoader( + self._train_dataset, + collate_fn=UtteranceCollate( + is_multispeaker=self.hparams.num_speakers > 1, + segment_size=self.hparams.segment_size, + ), + num_workers=self.hparams.num_workers, + batch_size=self.hparams.batch_size, + ) + + def val_dataloader(self): + return DataLoader( + self._val_dataset, + collate_fn=UtteranceCollate( + is_multispeaker=self.hparams.num_speakers > 1, + segment_size=self.hparams.segment_size, + ), + num_workers=self.hparams.num_workers, + batch_size=self.hparams.batch_size, + ) + + def test_dataloader(self): + return DataLoader( + self._test_dataset, + collate_fn=UtteranceCollate( + is_multispeaker=self.hparams.num_speakers > 1, + segment_size=self.hparams.segment_size, + ), + num_workers=self.hparams.num_workers, + batch_size=self.hparams.batch_size, + ) + + def training_step(self, batch: Batch, batch_idx: int, optimizer_idx: int): + if optimizer_idx == 0: + return self.training_step_g(batch) + + if optimizer_idx == 1: + return self.training_step_d(batch) + + def training_step_g(self, batch: Batch): + x, x_lengths, y, _, spec, spec_lengths, speaker_ids = ( + batch.phoneme_ids, + batch.phoneme_lengths, + batch.audios, + batch.audio_lengths, + batch.spectrograms, + batch.spectrogram_lengths, + batch.speaker_ids if batch.speaker_ids is not None else None, + ) + ( + y_hat, + l_length, + _attn, + ids_slice, + _x_mask, + z_mask, + (_z, z_p, m_p, logs_p, _m_q, logs_q), + ) = self.model_g(x, x_lengths, spec, spec_lengths, speaker_ids) + self._y_hat = y_hat + + mel = spec_to_mel_torch( + spec, + self.hparams.filter_length, + self.hparams.mel_channels, + self.hparams.sample_rate, + self.hparams.mel_fmin, + self.hparams.mel_fmax, + ) + y_mel = slice_segments( + mel, + ids_slice, + self.hparams.segment_size // self.hparams.hop_length, + ) + y_hat_mel = mel_spectrogram_torch( + y_hat.squeeze(1), + self.hparams.filter_length, + self.hparams.mel_channels, + self.hparams.sample_rate, + self.hparams.hop_length, + self.hparams.win_length, + self.hparams.mel_fmin, + self.hparams.mel_fmax, + ) + y = slice_segments( + y, + ids_slice * self.hparams.hop_length, + self.hparams.segment_size, + ) # slice + + # Save for training_step_d + self._y = y + + _y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = self.model_d(y, y_hat) + + with autocast(self.device.type, enabled=False): + # Generator loss + loss_dur = torch.sum(l_length.float()) + loss_mel = F.l1_loss(y_mel, y_hat_mel) * self.hparams.c_mel + loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * self.hparams.c_kl + + loss_fm = feature_loss(fmap_r, fmap_g) + loss_gen, _losses_gen = generator_loss(y_d_hat_g) + loss_gen_all = loss_gen + loss_fm + loss_mel + loss_dur + loss_kl + + self.log("loss_gen_all", loss_gen_all) + + return loss_gen_all + + def training_step_d(self, batch: Batch): + # From training_step_g + y = self._y + y_hat = self._y_hat + y_d_hat_r, y_d_hat_g, _, _ = self.model_d(y, y_hat.detach()) + + with autocast(self.device.type, enabled=False): + # Discriminator + loss_disc, _losses_disc_r, _losses_disc_g = discriminator_loss( + y_d_hat_r, y_d_hat_g + ) + loss_disc_all = loss_disc + + self.log("loss_disc_all", loss_disc_all) + + return loss_disc_all + + def validation_step(self, batch: Batch, batch_idx: int): + val_loss = self.training_step_g(batch) + self.log("val_loss", val_loss) + + # Generate audio examples + for utt_idx, test_utt in enumerate(self._test_dataset): + text = test_utt.phoneme_ids.unsqueeze(0).to(self.device) + text_lengths = torch.LongTensor([len(test_utt.phoneme_ids)]).to(self.device) + scales = [0.667, 1.0, 0.8] + test_audio = self(text, text_lengths, scales).detach() + + # Scale to make louder in [-1, 1] + test_audio = test_audio * (1.0 / max(0.01, abs(test_audio.max()))) + + tag = test_utt.text or str(utt_idx) + self.logger.experiment.add_audio( + tag, test_audio, sample_rate=self.hparams.sample_rate + ) + + return val_loss + + def configure_optimizers(self): + optimizers = [ + torch.optim.AdamW( + self.model_g.parameters(), + lr=self.hparams.learning_rate, + betas=self.hparams.betas, + eps=self.hparams.eps, + ), + torch.optim.AdamW( + self.model_d.parameters(), + lr=self.hparams.learning_rate, + betas=self.hparams.betas, + eps=self.hparams.eps, + ), + ] + schedulers = [ + torch.optim.lr_scheduler.ExponentialLR( + optimizers[0], gamma=self.hparams.lr_decay + ), + torch.optim.lr_scheduler.ExponentialLR( + optimizers[1], gamma=self.hparams.lr_decay + ), + ] + + return optimizers, schedulers + + @staticmethod + def add_model_specific_args(parent_parser): + parser = parent_parser.add_argument_group("VitsModel") + parser.add_argument("--batch-size", type=int, required=True) + parser.add_argument("--validation-split", type=float, default=0.1) + parser.add_argument("--num-test-examples", type=int, default=5) + # + parser.add_argument("--hidden-channels", type=int, default=192) + parser.add_argument("--inter-channels", type=int, default=192) + parser.add_argument("--filter-channels", type=int, default=768) + parser.add_argument("--n-layers", type=int, default=6) + parser.add_argument("--n-heads", type=int, default=2) + # + return parent_parser diff --git a/src/python/larynx_train/vits/losses.py b/src/python/larynx_train/vits/losses.py new file mode 100644 index 0000000..ec327e5 --- /dev/null +++ b/src/python/larynx_train/vits/losses.py @@ -0,0 +1,58 @@ +import torch + + +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_dg = torch.mean((1 - dg) ** 2) + gen_losses.append(l_dg) + loss += l_dg + + 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.0 * logs_p) + kl = torch.sum(kl * z_mask) + l_kl = kl / torch.sum(z_mask) + return l_kl diff --git a/src/python/larynx_train/vits/mel_processing.py b/src/python/larynx_train/vits/mel_processing.py new file mode 100644 index 0000000..1776f50 --- /dev/null +++ b/src/python/larynx_train/vits/mel_processing.py @@ -0,0 +1,137 @@ +import torch +import torch.utils.data +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.0: + print("min value is ", torch.min(y)) + if torch.max(y) > 1.0: + 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).type_as(y) + + 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.view_as_real( + 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=True, + ) + ) + + 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( + sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax + ) + mel_basis[fmax_dtype_device] = torch.from_numpy(mel).type_as(spec) + 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.0: + print("min value is ", torch.min(y)) + if torch.max(y) > 1.0: + 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).type_as(y) + if wnsize_dtype_device not in hann_window: + hann_window[wnsize_dtype_device] = torch.hann_window(win_size).type_as(y) + + 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.view_as_real( + 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=True, + ) + ) + + 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/src/python/larynx_train/vits/models.py b/src/python/larynx_train/vits/models.py new file mode 100644 index 0000000..123bd06 --- /dev/null +++ b/src/python/larynx_train/vits/models.py @@ -0,0 +1,727 @@ +import math +import typing + +import torch +from torch import nn +from torch.nn import Conv1d, Conv2d, ConvTranspose1d +from torch.nn import functional as F +from torch.nn.utils import remove_weight_norm, spectral_norm, weight_norm + +from . import attentions, commons, modules, monotonic_align +from .commons import get_padding, init_weights + + +class StochasticDurationPredictor(nn.Module): + def __init__( + self, + in_channels: int, + filter_channels: int, + kernel_size: int, + p_dropout: float, + n_flows: int = 4, + gin_channels: int = 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)).type_as(x) * 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)).type_as(x) * 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: int, + filter_channels: int, + kernel_size: int, + p_dropout: float, + gin_channels: int = 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: int, + out_channels: int, + hidden_channels: int, + filter_channels: int, + n_heads: int, + n_layers: int, + kernel_size: int, + p_dropout: float, + ): + 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.emb = nn.Embedding(n_vocab, hidden_channels) + nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5) + + self.encoder = attentions.Encoder( + hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout + ) + self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1) + + def forward(self, x, x_lengths): + x = self.emb(x) * 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 + ).type_as(x) + + x = self.encoder(x * x_mask, x_mask) + 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: int, + hidden_channels: int, + kernel_size: int, + dilation_rate: int, + n_layers: int, + n_flows: int = 4, + gin_channels: int = 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: int, + out_channels: int, + hidden_channels: int, + kernel_size: int, + dilation_rate: int, + n_layers: int, + gin_channels: int = 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 + ).type_as(x) + 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: int, + resblock: typing.Optional[str], + resblock_kernel_sizes: typing.Tuple[int, ...], + resblock_dilation_sizes: typing.Tuple[typing.Tuple[int, ...], ...], + upsample_rates: typing.Tuple[int, ...], + upsample_initial_channel: int, + upsample_kernel_sizes: typing.Tuple[int, ...], + gin_channels: int = 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_module = 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_module(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: int, + kernel_size: int = 5, + stride: int = 3, + use_spectral_norm: bool = False, + ): + super(DiscriminatorP, self).__init__() + self.period = period + self.use_spectral_norm = use_spectral_norm + norm_f = weight_norm if not use_spectral_norm 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 = spectral_norm if use_spectral_norm else weight_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 SynthesizerTrn(nn.Module): + """ + Synthesizer for Training + """ + + def __init__( + self, + n_vocab: int, + spec_channels: int, + segment_size: int, + inter_channels: int, + hidden_channels: int, + filter_channels: int, + n_heads: int, + n_layers: int, + kernel_size: int, + p_dropout: float, + resblock: str, + resblock_kernel_sizes: typing.Tuple[int, ...], + resblock_dilation_sizes: typing.Tuple[typing.Tuple[int, ...], ...], + upsample_rates: typing.Tuple[int, ...], + upsample_initial_channel: int, + upsample_kernel_sizes: typing.Tuple[int, ...], + n_speakers: int = 1, + gin_channels: int = 0, + use_sdp: bool = True, + ): + + 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.use_sdp = use_sdp + + self.enc_p = TextEncoder( + n_vocab, + inter_channels, + hidden_channels, + filter_channels, + n_heads, + n_layers, + kernel_size, + p_dropout, + ) + 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, + ) + self.flow = ResidualCouplingBlock( + inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels + ) + + if use_sdp: + self.dp = StochasticDurationPredictor( + hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels + ) + else: + 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) + + def forward(self, x, x_lengths, y, y_lengths, sid=None): + + x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths) + if self.n_speakers > 1: + g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1] + else: + g = None + + 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 + + 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) + if self.use_sdp: + l_length = self.dp(x, x_mask, w, g=g) + l_length = l_length / torch.sum(x_mask) + else: + logw_ = torch.log(w + 1e-6) * x_mask + logw = self.dp(x, x_mask, g=g) + l_length = torch.sum((logw - logw_) ** 2, [1, 2]) / torch.sum( + x_mask + ) # for averaging + + # 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), + ) + + def infer( + self, + x, + x_lengths, + sid=None, + noise_scale=0.667, + length_scale=1, + noise_scale_w=0.8, + max_len=None, + ): + x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths) + if self.n_speakers > 1: + g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1] + else: + g = None + + if self.use_sdp: + logw = self.dp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w) + else: + logw = self.dp(x, x_mask, g=g) + 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, y_lengths.max()), 1 + ).type_as(x_mask) + 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) + + def voice_conversion(self, y, y_lengths, sid_src, sid_tgt): + assert self.n_speakers > 1, "n_speakers have to be larger than 1." + g_src = self.emb_g(sid_src).unsqueeze(-1) + g_tgt = self.emb_g(sid_tgt).unsqueeze(-1) + z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g_src) + z_p = self.flow(z, y_mask, g=g_src) + z_hat = self.flow(z_p, y_mask, g=g_tgt, reverse=True) + o_hat = self.dec(z_hat * y_mask, g=g_tgt) + return o_hat, y_mask, (z, z_p, z_hat) diff --git a/src/python/larynx_train/vits/modules.py b/src/python/larynx_train/vits/modules.py new file mode 100644 index 0000000..1ca701f --- /dev/null +++ b/src/python/larynx_train/vits/modules.py @@ -0,0 +1,527 @@ +import math +import typing + +import torch +from torch import nn +from torch.nn import Conv1d +from torch.nn import functional as F +from torch.nn.utils import remove_weight_norm, weight_norm + +from .commons import fused_add_tanh_sigmoid_multiply, get_padding, init_weights +from .transforms import piecewise_rational_quadratic_transform + +LRELU_SLOPE = 0.1 + + +class LayerNorm(nn.Module): + def __init__(self, channels: int, eps: float = 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: int, + hidden_channels: int, + out_channels: int, + kernel_size: int, + n_layers: int, + p_dropout: float, + ): + 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: int, kernel_size: int, n_layers: int, p_dropout: float = 0.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: int, + kernel_size: int, + dilation_rate: int, + n_layers: int, + gin_channels: int = 0, + p_dropout: float = 0, + ): + super().__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 = 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: int, + kernel_size: int = 3, + dilation: typing.Tuple[int] = (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: int, kernel_size: int = 3, dilation: typing.Tuple[int] = (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: torch.Tensor, x_mask: torch.Tensor, reverse: bool = 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: torch.Tensor, *args, reverse: bool = False, **kwargs): + x = torch.flip(x, [1]) + if not reverse: + logdet = torch.zeros(x.size(0)).type_as(x) + return x, logdet + else: + return x + + +class ElementwiseAffine(nn.Module): + def __init__(self, channels: int): + 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: int, + hidden_channels: int, + kernel_size: int, + dilation_rate: int, + n_layers: int, + p_dropout: float = 0, + gin_channels: int = 0, + mean_only: bool = 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: int, + filter_channels: int, + kernel_size: int, + n_layers: int, + num_bins: int = 10, + tail_bound: float = 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.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 diff --git a/src/python/larynx_train/vits/monotonic_align/Makefile b/src/python/larynx_train/vits/monotonic_align/Makefile new file mode 100644 index 0000000..017c6e7 --- /dev/null +++ b/src/python/larynx_train/vits/monotonic_align/Makefile @@ -0,0 +1,2 @@ +all: + python3 setup.py build_ext --inplace diff --git a/src/python/larynx_train/vits/monotonic_align/__init__.py b/src/python/larynx_train/vits/monotonic_align/__init__.py new file mode 100644 index 0000000..5dd2a43 --- /dev/null +++ b/src/python/larynx_train/vits/monotonic_align/__init__.py @@ -0,0 +1,20 @@ +import numpy as np +import torch + +from .monotonic_align.core import maximum_path_c + + +def maximum_path(neg_cent, mask): + """Cython 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(np.float32) + path = np.zeros(neg_cent.shape, dtype=np.int32) + + t_t_max = mask.sum(1)[:, 0].data.cpu().numpy().astype(np.int32) + t_s_max = mask.sum(2)[:, 0].data.cpu().numpy().astype(np.int32) + maximum_path_c(path, neg_cent, t_t_max, t_s_max) + return torch.from_numpy(path).to(device=device, dtype=dtype) diff --git a/src/python/larynx_train/vits/monotonic_align/core.c b/src/python/larynx_train/vits/monotonic_align/core.c new file mode 100644 index 0000000..f88960d --- /dev/null +++ b/src/python/larynx_train/vits/monotonic_align/core.c @@ -0,0 +1,21608 @@ +/* Generated by Cython 0.29.32 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "name": "larynx_train.vits.monotonic_align.core", + "sources": [ + "/home/hansenm/opt/larynx2/src/python/larynx_train/vits/monotonic_align/core.pyx" + ] + }, + "module_name": "larynx_train.vits.monotonic_align.core" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#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 < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_32" +#define CYTHON_HEX_VERSION 0x001D20F0 +#define CYTHON_FUTURE_DIVISION 0 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !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 + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 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_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 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 (PYPY_VERSION_HEX >= 0x07030900) + #endif +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #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 + #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 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 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(PY_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 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_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(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 + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(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 + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #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 (PY_VERSION_HEX >= 0x030700A3) + #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 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(__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_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#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 int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #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 + +#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 + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#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_PyCode_New(a, 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) + #define __Pyx_DefaultClassType PyClass_Type +#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 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, *call_result=NULL, *empty=NULL; + const char *fn_cstr=NULL; + const char *name_cstr=NULL; + PyCodeObject* co=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(0))) 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 cleanup_code_too; + if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here + if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; + Py_XDECREF((PyObject*)co); + co = (PyCodeObject*)call_result; + call_result = NULL; + if (0) { + cleanup_code_too: + Py_XDECREF((PyObject*)co); + co = NULL; + } + end: + Py_XDECREF(kwds); + Py_XDECREF(argcount); + Py_XDECREF(posonlyargcount); + Py_XDECREF(kwonlyargcount); + Py_XDECREF(nlocals); + Py_XDECREF(stacksize); + Py_XDECREF(replace); + Py_XDECREF(call_result); + Py_XDECREF(empty); + if (type) { + PyErr_Restore(type, value, traceback); + } + return co; + } +#else + #define __Pyx_PyCode_New(a, 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 + #define __Pyx_DefaultClassType PyType_Type +#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 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_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#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_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) 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_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #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 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 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 >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if defined(PyUnicode_IS_READY) + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #else + #define __Pyx_PyUnicode_READY(op) (0) + #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) 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, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #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 + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #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) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (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] = 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 && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#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 +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_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 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 +#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 PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#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; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__larynx_train__vits__monotonic_align__core +#define __PYX_HAVE_API__larynx_train__vits__monotonic_align__core +/* Early includes */ +#include "pythread.h" +#include +#include +#include +#include "pystate.h" +#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_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __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) +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); +} +#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 +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#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] = 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; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "core.pyx", + "stringsource", +}; +/* 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() + +/* 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]) + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __pyx_atomic_int_type int +#if 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) && CYTHON_COMPILING_IN_NOGIL + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_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 +typedef volatile __pyx_atomic_int_type __pyx_atomic_int; +#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 + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +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; + + +/*--- Type declarations ---*/ +struct __pyx_array_obj; +struct __pyx_MemviewEnum_obj; +struct __pyx_memoryview_obj; +struct __pyx_memoryviewslice_obj; +struct __pyx_opt_args_12larynx_train_4vits_15monotonic_align_4core_maximum_path_each; + +/* "larynx_train/vits/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_12larynx_train_4vits_15monotonic_align_4core_maximum_path_each { + int __pyx_n; + float max_neg_val; +}; + +/* "View.MemoryView":106 + * + * @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":280 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * 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 acquisition_count[2]; + __pyx_atomic_int *acquisition_count_aligned_p; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo *typeinfo; +}; + + +/* "View.MemoryView":967 + * + * @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":106 + * + * @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":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * 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 *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":967 + * + * @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; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, 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__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #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) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #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_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) + +/* 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 + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* 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 *acquisition_count, PyThread_type_lock lock); +static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( + __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); +#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p) +#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview)) +#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) +#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__) +static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int); + +/* 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 **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_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); + +/* 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 + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() 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 +#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 + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, 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_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #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()\ + ((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 // CYTHON_FAST_PYCALL +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* 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); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* 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 UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +static CYTHON_UNUSED 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); + +/* 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 + +/* decode_c_string_utf16.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_string.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* 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 + +/* 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) {\ + 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);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +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 + +/* 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 +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); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(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_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_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +static CYTHON_UNUSED 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 + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* ListExtend.proto */ +static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject* none = _PyList_Extend((PyListObject*)L, v); + if (unlikely(!none)) + return -1; + Py_DECREF(none); + return 0; +#else + return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); +#endif +} + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + 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_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* 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 *); + +/* 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 + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* 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 */ +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); + +/* 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); + +/* Capsule.proto */ +static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); + +/* 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); + +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* 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); + +/* 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 *); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +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_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*/ + +/* Module declarations from 'cython.view' */ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'larynx_train.vits.monotonic_align.core' */ +static PyTypeObject *__pyx_array_type = 0; +static PyTypeObject *__pyx_MemviewEnum_type = 0; +static PyTypeObject *__pyx_memoryview_type = 0; +static PyTypeObject *__pyx_memoryviewslice_type = 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_12larynx_train_4vits_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_12larynx_train_4vits_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/ +static void __pyx_f_12larynx_train_4vits_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/ +static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ +static void *__pyx_align_pointer(void *, size_t); /*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 PyObject *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 *, char *, int); /*proto*/ +static int __pyx_memoryview_err(PyObject *, char *); /*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*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, IS_UNSIGNED(int) ? 'U' : 'I', IS_UNSIGNED(int), 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; +#define __Pyx_MODULE_NAME "larynx_train.vits.monotonic_align.core" +extern int __pyx_module_is_main_larynx_train__vits__monotonic_align__core; +int __pyx_module_is_main_larynx_train__vits__monotonic_align__core = 0; + +/* Implementation of 'larynx_train.vits.monotonic_align.core' */ +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_MemoryError; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_Ellipsis; +static PyObject *__pyx_builtin_id; +static PyObject *__pyx_builtin_IndexError; +static const char __pyx_k_O[] = "O"; +static const char __pyx_k_c[] = "c"; +static const char __pyx_k_id[] = "id"; +static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_obj[] = "obj"; +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_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_error[] = "error"; +static const char __pyx_k_flags[] = "flags"; +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_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_fortran[] = "fortran"; +static const char __pyx_k_memview[] = "memview"; +static const char __pyx_k_Ellipsis[] = "Ellipsis"; +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_setstate[] = "__setstate__"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_enumerate[] = "enumerate"; +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_pyx_checksum[] = "__pyx_checksum"; +static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; +static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; +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_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_strided_and_direct[] = ""; +static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_contiguous_and_direct[] = ""; +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_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; +static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %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_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_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 (0xb068931, 0x82a3537, 0x6ae9995) = (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 %s"; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; +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 %d (got %d and %d)"; +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."; +static PyObject *__pyx_n_s_ASCII; +static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; +static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; +static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; +static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; +static PyObject *__pyx_kp_s_Cannot_index_with_type_s; +static PyObject *__pyx_n_s_Ellipsis; +static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; +static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; +static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; +static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; +static PyObject *__pyx_kp_s_MemoryView_of_r_object; +static PyObject *__pyx_n_b_O; +static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; +static PyObject *__pyx_n_s_PickleError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_View_MemoryView; +static PyObject *__pyx_n_s_allocate_buffer; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_c; +static PyObject *__pyx_n_u_c; +static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_kp_s_contiguous_and_direct; +static PyObject *__pyx_kp_s_contiguous_and_indirect; +static PyObject *__pyx_n_s_dict; +static PyObject *__pyx_n_s_dtype_is_object; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_enumerate; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_fortran; +static PyObject *__pyx_n_u_fortran; +static PyObject *__pyx_n_s_getstate; +static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; +static PyObject *__pyx_n_s_id; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_itemsize; +static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_memview; +static PyObject *__pyx_n_s_mode; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_new; +static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; +static PyObject *__pyx_n_s_obj; +static PyObject *__pyx_n_s_pack; +static PyObject *__pyx_n_s_paths; +static PyObject *__pyx_n_s_pickle; +static PyObject *__pyx_n_s_pyx_PickleError; +static PyObject *__pyx_n_s_pyx_checksum; +static PyObject *__pyx_n_s_pyx_getbuffer; +static PyObject *__pyx_n_s_pyx_result; +static PyObject *__pyx_n_s_pyx_state; +static PyObject *__pyx_n_s_pyx_type; +static PyObject *__pyx_n_s_pyx_unpickle_Enum; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_reduce; +static PyObject *__pyx_n_s_reduce_cython; +static PyObject *__pyx_n_s_reduce_ex; +static PyObject *__pyx_n_s_setstate; +static PyObject *__pyx_n_s_setstate_cython; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_size; +static PyObject *__pyx_n_s_start; +static PyObject *__pyx_n_s_step; +static PyObject *__pyx_n_s_stop; +static PyObject *__pyx_kp_s_strided_and_direct; +static PyObject *__pyx_kp_s_strided_and_direct_or_indirect; +static PyObject *__pyx_kp_s_strided_and_indirect; +static PyObject *__pyx_kp_s_stringsource; +static PyObject *__pyx_n_s_struct; +static PyObject *__pyx_n_s_t_xs; +static PyObject *__pyx_n_s_t_ys; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_s_unable_to_allocate_array_data; +static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; +static PyObject *__pyx_n_s_unpack; +static PyObject *__pyx_n_s_update; +static PyObject *__pyx_n_s_values; +static PyObject *__pyx_pf_12larynx_train_4vits_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 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_15View_dot_MemoryView_16_memoryviewslice_4base___get__(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_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*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_112105877; +static PyObject *__pyx_int_136983863; +static PyObject *__pyx_int_184977713; +static PyObject *__pyx_int_neg_1; +static float __pyx_k_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_slice__16; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_codeobj__27; +/* Late includes */ + +/* "larynx_train/vits/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 + */ + +static void __pyx_f_12larynx_train_4vits_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice __pyx_v_path, __Pyx_memviewslice __pyx_v_value, int __pyx_v_t_y, int __pyx_v_t_x, struct __pyx_opt_args_12larynx_train_4vits_15monotonic_align_4core_maximum_path_each *__pyx_optional_args) { + float __pyx_v_max_neg_val = __pyx_k_; + int __pyx_v_x; + int __pyx_v_y; + float __pyx_v_v_prev; + float __pyx_v_v_cur; + int __pyx_v_index; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + long __pyx_t_4; + int __pyx_t_5; + long __pyx_t_6; + long __pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + float __pyx_t_11; + float __pyx_t_12; + float __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_max_neg_val = __pyx_optional_args->max_neg_val; + } + } + + /* "larynx_train/vits/monotonic_align/core.pyx":13 + * cdef float v_cur + * cdef float tmp + * cdef int index = t_x - 1 # <<<<<<<<<<<<<< + * + * for y in range(t_y): + */ + __pyx_v_index = (__pyx_v_t_x - 1); + + /* "larynx_train/vits/monotonic_align/core.pyx":15 + * cdef int index = t_x - 1 + * + * for y in range(t_y): # <<<<<<<<<<<<<< + * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): + * if x == y: + */ + __pyx_t_1 = __pyx_v_t_y; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_y = __pyx_t_3; + + /* "larynx_train/vits/monotonic_align/core.pyx":16 + * + * for y in range(t_y): + * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): # <<<<<<<<<<<<<< + * if x == y: + * v_cur = max_neg_val + */ + __pyx_t_4 = (__pyx_v_y + 1); + __pyx_t_5 = __pyx_v_t_x; + if (((__pyx_t_4 < __pyx_t_5) != 0)) { + __pyx_t_6 = __pyx_t_4; + } else { + __pyx_t_6 = __pyx_t_5; + } + __pyx_t_4 = __pyx_t_6; + __pyx_t_5 = ((__pyx_v_t_x + __pyx_v_y) - __pyx_v_t_y); + __pyx_t_6 = 0; + if (((__pyx_t_5 > __pyx_t_6) != 0)) { + __pyx_t_7 = __pyx_t_5; + } else { + __pyx_t_7 = __pyx_t_6; + } + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_5 = __pyx_t_7; __pyx_t_5 < __pyx_t_6; __pyx_t_5+=1) { + __pyx_v_x = __pyx_t_5; + + /* "larynx_train/vits/monotonic_align/core.pyx":17 + * for y in range(t_y): + * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): + * if x == y: # <<<<<<<<<<<<<< + * v_cur = max_neg_val + * else: + */ + __pyx_t_8 = ((__pyx_v_x == __pyx_v_y) != 0); + if (__pyx_t_8) { + + /* "larynx_train/vits/monotonic_align/core.pyx":18 + * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): + * if x == y: + * v_cur = max_neg_val # <<<<<<<<<<<<<< + * else: + * v_cur = value[y-1, x] + */ + __pyx_v_v_cur = __pyx_v_max_neg_val; + + /* "larynx_train/vits/monotonic_align/core.pyx":17 + * for y in range(t_y): + * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): + * if x == y: # <<<<<<<<<<<<<< + * v_cur = max_neg_val + * else: + */ + goto __pyx_L7; + } + + /* "larynx_train/vits/monotonic_align/core.pyx":20 + * v_cur = max_neg_val + * else: + * v_cur = value[y-1, x] # <<<<<<<<<<<<<< + * if x == 0: + * if y == 0: + */ + /*else*/ { + __pyx_t_9 = (__pyx_v_y - 1); + __pyx_t_10 = __pyx_v_x; + __pyx_v_v_cur = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) ))); + } + __pyx_L7:; + + /* "larynx_train/vits/monotonic_align/core.pyx":21 + * else: + * v_cur = value[y-1, x] + * if x == 0: # <<<<<<<<<<<<<< + * if y == 0: + * v_prev = 0. + */ + __pyx_t_8 = ((__pyx_v_x == 0) != 0); + if (__pyx_t_8) { + + /* "larynx_train/vits/monotonic_align/core.pyx":22 + * v_cur = value[y-1, x] + * if x == 0: + * if y == 0: # <<<<<<<<<<<<<< + * v_prev = 0. + * else: + */ + __pyx_t_8 = ((__pyx_v_y == 0) != 0); + if (__pyx_t_8) { + + /* "larynx_train/vits/monotonic_align/core.pyx":23 + * if x == 0: + * if y == 0: + * v_prev = 0. # <<<<<<<<<<<<<< + * else: + * v_prev = max_neg_val + */ + __pyx_v_v_prev = 0.; + + /* "larynx_train/vits/monotonic_align/core.pyx":22 + * v_cur = value[y-1, x] + * if x == 0: + * if y == 0: # <<<<<<<<<<<<<< + * v_prev = 0. + * else: + */ + goto __pyx_L9; + } + + /* "larynx_train/vits/monotonic_align/core.pyx":25 + * v_prev = 0. + * else: + * v_prev = max_neg_val # <<<<<<<<<<<<<< + * else: + * v_prev = value[y-1, x-1] + */ + /*else*/ { + __pyx_v_v_prev = __pyx_v_max_neg_val; + } + __pyx_L9:; + + /* "larynx_train/vits/monotonic_align/core.pyx":21 + * else: + * v_cur = value[y-1, x] + * if x == 0: # <<<<<<<<<<<<<< + * if y == 0: + * v_prev = 0. + */ + goto __pyx_L8; + } + + /* "larynx_train/vits/monotonic_align/core.pyx":27 + * v_prev = max_neg_val + * else: + * v_prev = value[y-1, x-1] # <<<<<<<<<<<<<< + * value[y, x] += max(v_prev, v_cur) + * + */ + /*else*/ { + __pyx_t_10 = (__pyx_v_y - 1); + __pyx_t_9 = (__pyx_v_x - 1); + __pyx_v_v_prev = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_10 * __pyx_v_value.strides[0]) )) + __pyx_t_9)) ))); + } + __pyx_L8:; + + /* "larynx_train/vits/monotonic_align/core.pyx":28 + * else: + * v_prev = value[y-1, x-1] + * value[y, x] += max(v_prev, v_cur) # <<<<<<<<<<<<<< + * + * for y in range(t_y - 1, -1, -1): + */ + __pyx_t_11 = __pyx_v_v_cur; + __pyx_t_12 = __pyx_v_v_prev; + if (((__pyx_t_11 > __pyx_t_12) != 0)) { + __pyx_t_13 = __pyx_t_11; + } else { + __pyx_t_13 = __pyx_t_12; + } + __pyx_t_9 = __pyx_v_y; + __pyx_t_10 = __pyx_v_x; + *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) )) += __pyx_t_13; + } + } + + /* "larynx_train/vits/monotonic_align/core.pyx":30 + * value[y, x] += max(v_prev, v_cur) + * + * for y in range(t_y - 1, -1, -1): # <<<<<<<<<<<<<< + * path[y, index] = 1 + * if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]): + */ + for (__pyx_t_1 = (__pyx_v_t_y - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_y = __pyx_t_1; + + /* "larynx_train/vits/monotonic_align/core.pyx":31 + * + * for y in range(t_y - 1, -1, -1): + * path[y, index] = 1 # <<<<<<<<<<<<<< + * if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]): + * index = index - 1 + */ + __pyx_t_10 = __pyx_v_y; + __pyx_t_9 = __pyx_v_index; + *((int *) ( /* dim=1 */ ((char *) (((int *) ( /* dim=0 */ (__pyx_v_path.data + __pyx_t_10 * __pyx_v_path.strides[0]) )) + __pyx_t_9)) )) = 1; + + /* "larynx_train/vits/monotonic_align/core.pyx":32 + * for y in range(t_y - 1, -1, -1): + * path[y, index] = 1 + * if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]): # <<<<<<<<<<<<<< + * index = index - 1 + * + */ + __pyx_t_14 = ((__pyx_v_index != 0) != 0); + if (__pyx_t_14) { + } else { + __pyx_t_8 = __pyx_t_14; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_14 = ((__pyx_v_index == __pyx_v_y) != 0); + if (!__pyx_t_14) { + } else { + __pyx_t_8 = __pyx_t_14; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_y - 1); + __pyx_t_10 = __pyx_v_index; + __pyx_t_15 = (__pyx_v_y - 1); + __pyx_t_16 = (__pyx_v_index - 1); + __pyx_t_14 = (((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) ))) < (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_15 * __pyx_v_value.strides[0]) )) + __pyx_t_16)) )))) != 0); + __pyx_t_8 = __pyx_t_14; + __pyx_L13_bool_binop_done:; + if (__pyx_t_8) { + + /* "larynx_train/vits/monotonic_align/core.pyx":33 + * path[y, index] = 1 + * if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]): + * index = index - 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_index = (__pyx_v_index - 1); + + /* "larynx_train/vits/monotonic_align/core.pyx":32 + * for y in range(t_y - 1, -1, -1): + * path[y, index] = 1 + * if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]): # <<<<<<<<<<<<<< + * index = index - 1 + * + */ + } + } + + /* "larynx_train/vits/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 + */ + + /* function exit code */ +} + +/* "larynx_train/vits/monotonic_align/core.pyx":38 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) nogil: # <<<<<<<<<<<<<< + * cdef int b = paths.shape[0] + * cdef int i + */ + +static PyObject *__pyx_pw_12larynx_train_4vits_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static void __pyx_f_12larynx_train_4vits_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs, CYTHON_UNUSED int __pyx_skip_dispatch) { + CYTHON_UNUSED int __pyx_v_b; + int __pyx_v_i; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + __Pyx_memviewslice __pyx_t_4 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_5 = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + + /* "larynx_train/vits/monotonic_align/core.pyx":39 + * @cython.wraparound(False) + * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) nogil: + * cdef int b = paths.shape[0] # <<<<<<<<<<<<<< + * cdef int i + * for i in prange(b, nogil=True): + */ + __pyx_v_b = (__pyx_v_paths.shape[0]); + + /* "larynx_train/vits/monotonic_align/core.pyx":41 + * cdef int b = paths.shape[0] + * cdef int i + * for i in prange(b, nogil=True): # <<<<<<<<<<<<<< + * maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i]) + */ + { + #ifdef WITH_THREAD + PyThreadState *_save; + Py_UNBLOCK_THREADS + __Pyx_FastGIL_Remember(); + #endif + /*try:*/ { + __pyx_t_1 = __pyx_v_b; + if ((1 == 0)) abort(); + { + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) (x) + #define unlikely(x) (x) + #endif + __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; + if (__pyx_t_3 > 0) + { + #ifdef _OPENMP + #pragma omp parallel private(__pyx_t_6, __pyx_t_7) firstprivate(__pyx_t_4, __pyx_t_5) + #endif /* _OPENMP */ + { + #ifdef _OPENMP + #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) + #endif /* _OPENMP */ + for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ + { + __pyx_v_i = (int)(0 + 1 * __pyx_t_2); + + /* "larynx_train/vits/monotonic_align/core.pyx":42 + * cdef int i + * for i in prange(b, nogil=True): + * maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i]) # <<<<<<<<<<<<<< + */ + __pyx_t_4.data = __pyx_v_paths.data; + __pyx_t_4.memview = __pyx_v_paths.memview; + __PYX_INC_MEMVIEW(&__pyx_t_4, 0); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_i; + Py_ssize_t __pyx_tmp_stride = __pyx_v_paths.strides[0]; + __pyx_t_4.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_4.shape[0] = __pyx_v_paths.shape[1]; +__pyx_t_4.strides[0] = __pyx_v_paths.strides[1]; + __pyx_t_4.suboffsets[0] = -1; + +__pyx_t_4.shape[1] = __pyx_v_paths.shape[2]; +__pyx_t_4.strides[1] = __pyx_v_paths.strides[2]; + __pyx_t_4.suboffsets[1] = -1; + +__pyx_t_5.data = __pyx_v_values.data; + __pyx_t_5.memview = __pyx_v_values.memview; + __PYX_INC_MEMVIEW(&__pyx_t_5, 0); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_i; + Py_ssize_t __pyx_tmp_stride = __pyx_v_values.strides[0]; + __pyx_t_5.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_5.shape[0] = __pyx_v_values.shape[1]; +__pyx_t_5.strides[0] = __pyx_v_values.strides[1]; + __pyx_t_5.suboffsets[0] = -1; + +__pyx_t_5.shape[1] = __pyx_v_values.shape[2]; +__pyx_t_5.strides[1] = __pyx_v_values.strides[2]; + __pyx_t_5.suboffsets[1] = -1; + +__pyx_t_6 = __pyx_v_i; + __pyx_t_7 = __pyx_v_i; + __pyx_f_12larynx_train_4vits_15monotonic_align_4core_maximum_path_each(__pyx_t_4, __pyx_t_5, (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_t_ys.data) + __pyx_t_6)) ))), (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_t_xs.data) + __pyx_t_7)) ))), NULL); + __PYX_XDEC_MEMVIEW(&__pyx_t_4, 0); + __pyx_t_4.memview = NULL; + __pyx_t_4.data = NULL; + __PYX_XDEC_MEMVIEW(&__pyx_t_5, 0); + __pyx_t_5.memview = NULL; + __pyx_t_5.data = NULL; + } + } + } + } + } + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) + #endif + } + + /* "larynx_train/vits/monotonic_align/core.pyx":41 + * cdef int b = paths.shape[0] + * cdef int i + * for i in prange(b, nogil=True): # <<<<<<<<<<<<<< + * maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i]) + */ + /*finally:*/ { + /*normal exit:*/{ + #ifdef WITH_THREAD + __Pyx_FastGIL_Forget(); + Py_BLOCK_THREADS + #endif + goto __pyx_L5; + } + __pyx_L5:; + } + } + + /* "larynx_train/vits/monotonic_align/core.pyx":38 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) nogil: # <<<<<<<<<<<<<< + * cdef int b = paths.shape[0] + * cdef int i + */ + + /* function exit code */ +} + +/* Python wrapper */ +static PyObject *__pyx_pw_12larynx_train_4vits_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_12larynx_train_4vits_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __Pyx_memviewslice __pyx_v_paths = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_ys = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_xs = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("maximum_path_c (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_paths,&__pyx_n_s_values,&__pyx_n_s_t_ys,&__pyx_n_s_t_xs,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_paths)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_values)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, 1); __PYX_ERR(0, 38, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_ys)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, 2); __PYX_ERR(0, 38, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t_xs)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, 3); __PYX_ERR(0, 38, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "maximum_path_c") < 0)) __PYX_ERR(0, 38, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_paths = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_paths.memview)) __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_v_values = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_values.memview)) __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_v_t_ys = __Pyx_PyObject_to_MemoryviewSlice_dc_int(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_ys.memview)) __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_v_t_xs = __Pyx_PyObject_to_MemoryviewSlice_dc_int(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_xs.memview)) __PYX_ERR(0, 38, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("larynx_train.vits.monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12larynx_train_4vits_15monotonic_align_4core_maximum_path_c(__pyx_self, __pyx_v_paths, __pyx_v_values, __pyx_v_t_ys, __pyx_v_t_xs); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12larynx_train_4vits_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) { + 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("maximum_path_c", 0); + __Pyx_XDECREF(__pyx_r); + if (unlikely(!__pyx_v_paths.memview)) { __Pyx_RaiseUnboundLocalError("paths"); __PYX_ERR(0, 38, __pyx_L1_error) } + if (unlikely(!__pyx_v_values.memview)) { __Pyx_RaiseUnboundLocalError("values"); __PYX_ERR(0, 38, __pyx_L1_error) } + if (unlikely(!__pyx_v_t_ys.memview)) { __Pyx_RaiseUnboundLocalError("t_ys"); __PYX_ERR(0, 38, __pyx_L1_error) } + if (unlikely(!__pyx_v_t_xs.memview)) { __Pyx_RaiseUnboundLocalError("t_xs"); __PYX_ERR(0, 38, __pyx_L1_error) } + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_12larynx_train_4vits_15monotonic_align_4core_maximum_path_c(__pyx_v_paths, __pyx_v_values, __pyx_v_t_ys, __pyx_v_t_xs, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("larynx_train.vits.monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XDEC_MEMVIEW(&__pyx_v_paths, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_values, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_t_ys, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_t_xs, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":123 + * 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static 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 (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 123, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__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, 123, __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, 124, __pyx_L3_error) + } else { + + /* "View.MemoryView":124 + * + * 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, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 123, __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, 123, __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, 123, __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":123 + * 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_i; + Py_ssize_t __pyx_v_dim; + PyObject **__pyx_v_p; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":130 + * cdef PyObject **p + * + * 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, 130, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 130, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":131 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: + */ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 134, __pyx_L1_error) + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + } + + /* "View.MemoryView":136 + * 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) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 137, __pyx_L1_error) + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":139 + * 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_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":140 + * + * 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, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + 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_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":139 + * 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":141 + * 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)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_t_3 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":142 + * 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, 142, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 142, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":145 + * + * + * 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":146 + * + * 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":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 149, __pyx_L1_error) + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + __pyx_t_8 = 0; + __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 152, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 152, __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, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":154 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 154, __pyx_L1_error) + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + } + + /* "View.MemoryView":155 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 158, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":159 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":160 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' + */ + __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":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":162 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":163 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + */ + __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":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":165 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 165, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":167 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) + * + */ + __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":170 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":171 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * + */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 171, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":175 + * + * + * 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":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 177, __pyx_L1_error) + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":180 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None + */ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":181 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 181, __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(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); + __pyx_t_9 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "View.MemoryView":182 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":183 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":123 + * 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_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __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":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + 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; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + Py_ssize_t __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 (__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":187 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * 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, 188, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":189 + * cdef int bufmode = -1 + * 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":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + goto __pyx_L3; + } + + /* "View.MemoryView":190 + * 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_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 190, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":191 + * 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":190 + * 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_L3:; + + /* "View.MemoryView":192 + * 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)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":193 + * 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_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 193, __pyx_L1_error) + + /* "View.MemoryView":192 + * 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":194 + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; + + /* "View.MemoryView":195 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape + */ + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; + + /* "View.MemoryView":196 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides + */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":197 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; + + /* "View.MemoryView":198 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; + + /* "View.MemoryView":199 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 + */ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":200 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * + */ + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; + + /* "View.MemoryView":201 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":204 + * + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":206 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":208 + * info.format = NULL + * + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + */ + __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":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __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":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * 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) { + __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; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":214 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":217 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) + */ + __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":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + } + + /* "View.MemoryView":219 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * + */ + free(__pyx_v_self->data); + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + } + __pyx_L3:; + + /* "View.MemoryView":220 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":223 + * + * @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) { + 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":224 + * @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, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":223 + * + * @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":227 + * + * @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":228 + * @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":229 + * 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, 229, __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, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __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, 229, __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":227 + * + * @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":231 + * 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) { + 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":232 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":231 + * 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":234 + * 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) { + 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":235 + * + * 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, 235, __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, 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 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":237 + * 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) { + 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":238 + * + * 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, 238, __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, 238, __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":237 + * 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":240 + * 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) { + 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":241 + * + * 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, 241, __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, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":240 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __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 + PyObject *__pyx_t_1 = NULL; + 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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_XDECREF(__pyx_t_1); + __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, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__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 + 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)":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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_XDECREF(__pyx_t_1); + __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":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + +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_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":250 + * + * if buf == NULL: + * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":253 + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 253, __pyx_L1_error) + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":254 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":256 + * 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":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":282 + * 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 282, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 282, __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":283 + * 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":282 + * 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":284 + * 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) { + 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":285 + * 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":284 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __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; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = 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); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(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_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 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), 0xb068931, None), state + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __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_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __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_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 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_4); + __Pyx_XDECREF(__pyx_t_5); + __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), 0xb068931, 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, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__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), 0xb068931, 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)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __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), 0xb068931, 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":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":301 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset + * + */ + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + + /* "View.MemoryView":305 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":308 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p + */ + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":310 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":346 + * 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static 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 (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 346, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 346, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__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, 346, __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, 346, __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, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 346, __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; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":347 + * + * 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":348 + * 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":349 + * 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)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":350 + * 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_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 350, __pyx_L1_error) + + /* "View.MemoryView":351 + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":352 + * __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":353 + * 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":351 + * 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":349 + * 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":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + __pyx_t_1 = ((!(__PYX_CYTHON_ATOMICS_ENABLED() != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":358 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * 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":359 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * 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":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":360 + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":361 + * __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":362 + * 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) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":363 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 363, __pyx_L1_error) + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":360 + * 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":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + } + + /* "View.MemoryView":365 + * 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":366 + * + * 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') != 0); + 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') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L12_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":365 + * 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":368 + * 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 # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + */ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L11:; + + /* "View.MemoryView":370 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL + */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); + + /* "View.MemoryView":372 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":346 + * 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":374 + * 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) { + __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; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":375 + * + * 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":376 + * 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":375 + * + * 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":377 + * 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_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":379 + * 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":380 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i + */ + Py_DECREF(Py_None); + + /* "View.MemoryView":377 + * 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":384 + * 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_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":385 + * 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_3 = __pyx_memoryview_thread_locks_used; + __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":386 + * 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_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":387 + * 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":388 + * 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_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":390 + * 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_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":389 + * __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_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + + /* "View.MemoryView":388 + * 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":391 + * __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":386 + * 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":393 + * 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":384 + * 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":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":395 + * 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":397 + * 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":399 + * 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, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 399, __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, 399, __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, 399, __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, 399, __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, 399, __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, 399, __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":400 + * + * 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, 400, __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, 400, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":399 + * 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":402 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":395 + * 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":405 + * + * + * 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) { + 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; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":407 + * 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":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":409 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp + */ + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + 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, 409, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 409, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 412, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":413 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":415 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * + */ + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 415, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":416 + * 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_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __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":418 + * 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) { + 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 + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + 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("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":420 + * 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_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 420, __pyx_L1_error) + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":422 + * raise TypeError("Cannot assign to read-only memoryview") + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: + */ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __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, 422, __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, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 422, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj: + * self.setitem_slice_assignment(self[index], obj) + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 426, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":427 + * 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_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":429 + * 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_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 429, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":431 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":418 + * 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __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":433 + * 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":434 + * + * 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 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":435 + * 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":436 + * 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, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":437 + * 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, 437, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":436 + * 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, 436, __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, 436, __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":435 + * 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":438 + * 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, 438, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":439 + * 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; + __pyx_L6_except_error:; + + /* "View.MemoryView":435 + * 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_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":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":441 + * 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":433 + * 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":443 + * 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; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + __Pyx_memviewslice *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 447, __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, 447, __pyx_L1_error) + + /* "View.MemoryView":448 + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< + * 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, 448, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) + + /* "View.MemoryView":449 + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":443 + * 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_3); + __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":451 + * 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":453 + * 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":458 + * 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, 458, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":460 + * 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))) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":461 + * + * 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":462 + * 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) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":463 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 463, __pyx_L1_error) + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":464 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":460 + * 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":466 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":468 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":470 + * 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":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":472 + * ( 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, 472, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":476 + * + * + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":477 + * + * 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_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":476 + * + * + * 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":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, # <<<<<<<<<<<<<< + * 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":481 + * 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":451 + * 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":483 + * 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":484 + * + * 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, 484, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":485 + * 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, 485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":483 + * 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":487 + * 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; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":490 + * """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_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":493 + * 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, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * 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":495 + * 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, 495, __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, 495, __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; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); + __Pyx_INCREF(__pyx_v_bytesitem); + __Pyx_GIVEREF(__pyx_v_bytesitem); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + /*else:*/ { + __pyx_t_10 = strlen(__pyx_v_self->view.format); + __pyx_t_11 = ((__pyx_t_10 == 1) != 0); + if (__pyx_t_11) { + + /* "View.MemoryView":500 + * 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, 500, __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":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":501 + * 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; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":496 + * 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_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 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_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":497 + * 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_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 497, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.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":487 + * 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_XDECREF(__pyx_t_9); + __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":503 + * 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; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + char *__pyx_t_11; + char *__pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":506 + * """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_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":511 + * 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); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "View.MemoryView":512 + * + * 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, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":514 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 514, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 516, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_10 = __pyx_v_bytesvalue; + __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); + __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); + for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_11 = __pyx_t_14; + __pyx_v_c = (__pyx_t_11[0]); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = (__pyx_t_9 + 1); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "View.MemoryView":503 + * 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_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __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":520 + * + * @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") + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + 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; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + char *__pyx_t_5; + void *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__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":521 + * @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_2 = (__pyx_v_self->view.readonly != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":522 + * 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_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 522, __pyx_L1_error) + + /* "View.MemoryView":521 + * @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":524 + * 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":525 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL + */ + __pyx_t_4 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_4; + + /* "View.MemoryView":524 + * 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":527 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":529 + * 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":530 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL + */ + __pyx_t_4 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_4; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":532 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":534 + * 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":535 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL + */ + __pyx_t_4 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_4; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":537 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":539 + * 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":540 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_5 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_5; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":542 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":544 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + */ + __pyx_t_6 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_6; + + /* "View.MemoryView":545 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len + */ + __pyx_t_7 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_7; + + /* "View.MemoryView":546 + * 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_8 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_8; + + /* "View.MemoryView":547 + * 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_8 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_8; + + /* "View.MemoryView":548 + * 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":549 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __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":520 + * + * @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") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __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":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + +/* 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) { + 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)0))) __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":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + + /* 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":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +/* 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) { + 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 + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":562 + * @property + * def 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":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":565 + * + * @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) { + 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_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":566 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __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_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __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":565 + * + * @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":569 + * + * @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) { + 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_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":570 + * @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) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":572 + * 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_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 572, __pyx_L1_error) + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":574 + * 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); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __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_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __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":569 + * + * @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":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + +/* 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) { + 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_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + Py_ssize_t *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":579 + * 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_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":581 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { + __pyx_t_4 = __pyx_t_6; + __pyx_v_suboffset = (__pyx_t_4[0]); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __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":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __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":584 + * + * @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) { + 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":585 + * @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, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":584 + * + * @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":588 + * + * @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) { + 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":589 + * @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, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":588 + * + * @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":592 + * + * @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) { + 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":593 + * @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, 593, __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, 593, __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, 593, __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":592 + * + * @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":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + +/* 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) { + 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; + int __pyx_t_2; + 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":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":598 + * 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":600 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * + */ + __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":601 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result + */ + __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":603 + * 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":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":605 + * 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":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __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":607 + * 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) { + 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":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":609 + * 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":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":611 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":607 + * 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":613 + * 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) { + 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":614 + * + * 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, 614, __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, 614, __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, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":615 + * 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, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __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, 614, __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":613 + * 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":617 + * 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) { + 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":618 + * + * 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, 618, __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, 618, __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, 618, __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, 618, __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, 618, __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":617 + * 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":621 + * + * + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + __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":624 + * 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, 624, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":625 + * 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, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":621 + * + * + * 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":627 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + __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":630 + * 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, 630, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":631 + * 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, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":627 + * 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":633 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __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":635 + * 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":637 + * 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":638 + * + * 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, 638, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":643 + * 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, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":633 + * 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":645 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + __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":647 + * 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":649 + * 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":650 + * + * 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, 650, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":655 + * 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, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":645 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __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 + PyObject *__pyx_t_1 = NULL; + 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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_XDECREF(__pyx_t_1); + __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, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__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 + 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)":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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_XDECREF(__pyx_t_1); + __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":659 + * + * @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":660 + * @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, 660, __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, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __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, 660, __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":661 + * 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":662 + * 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":659 + * + * @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":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * 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":666 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): + * 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":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":668 + * 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) { + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + __pyx_t_1 = PyTuple_Check(__pyx_v_index); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":674 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 674, __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_v_tup = __pyx_t_3; + __pyx_t_3 = 0; + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":676 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":678 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":679 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":680 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { + __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 681, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 681, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__16); + __Pyx_GIVEREF(__pyx_slice__16); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__16); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":685 + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * else: + * result.append(slice(None)) + */ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + goto __pyx_L7; + } + + /* "View.MemoryView":687 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__16); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":688 + * else: + * result.append(slice(None)) + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + */ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + goto __pyx_L6; + } + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); + __pyx_t_1 = __pyx_t_10; + __pyx_L9_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":691 + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< + * + * have_slices = have_slices or isinstance(item, slice) + */ + __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, 0); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(1, 691, __pyx_L1_error) + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + } + + /* "View.MemoryView":693 + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< + * result.append(item) + * + */ + __pyx_t_10 = (__pyx_v_have_slices != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = PySlice_Check(__pyx_v_item); + __pyx_t_2 = (__pyx_t_10 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_have_slices = __pyx_t_1; + + /* "View.MemoryView":694 + * + * have_slices = have_slices or isinstance(item, slice) + * result.append(item) # <<<<<<<<<<<<<< + * + * nslices = ndim - len(result) + */ + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 694, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":696 + * result.append(item) + * + * nslices = ndim - len(result) # <<<<<<<<<<<<<< + * if nslices: + * result.extend([slice(None)] * nslices) + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":698 + * nslices = ndim - len(result) + * if nslices: + * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + * + * return have_slices or nslices, tuple(result) + */ + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__16); + __Pyx_GIVEREF(__pyx_slice__16); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__16); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":700 + * result.extend([slice(None)] * nslices) + * + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + */ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L14_bool_binop_done:; + __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = ((PyObject*)__pyx_t_11); + __pyx_t_11 = 0; + goto __pyx_L0; + + /* "View.MemoryView":668 + * 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_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __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_idx); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + +static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); + + /* "View.MemoryView":703 + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * 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":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 705, __pyx_L1_error) + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + } + } + + /* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "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 + */ + +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; + 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; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + struct __pyx_memoryview_obj *__pyx_t_4; + char *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":713 + * @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":720 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":724 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(1, 724, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":726 + * 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":727 + * + * 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, 727, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":728 + * 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":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":730 + * 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":731 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":737 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * + */ + __pyx_t_4 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_4; + + /* "View.MemoryView":738 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_5; + + /* "View.MemoryView":743 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step + */ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":744 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step + * cdef bint have_start, have_stop, have_step + */ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + __pyx_t_6 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 748, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_v_dim = __pyx_t_6; + __pyx_t_6 = (__pyx_t_6 + 1); + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":753 + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< + * 0, 0, 0, # have_{start,stop,step} + * False) + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 753, __pyx_L1_error) + + /* "View.MemoryView":750 + * for dim, index in enumerate(indices): + * if PyIndex_Check(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_11 = __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_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + 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_2 = (__pyx_v_index == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + 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_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_10; + + /* "View.MemoryView":763 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 763, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_10; + + /* "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_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "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_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 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_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 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_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 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_11 = __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_11 == ((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":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "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_3 = __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_3)) __PYX_ERR(1, 779, __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, 779, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 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_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "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 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __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":809 + * + * @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; + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + __pyx_t_1 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":832 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(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 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":834 + * start += shape + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 834, __pyx_L1_error) + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":837 + * else: + * + * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< + * + * if have_step and step == 0: + */ + /*else*/ { + __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step < 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + __pyx_v_negative_step = __pyx_t_2; + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + __pyx_t_1 = (__pyx_v_have_step != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step == 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "View.MemoryView":840 + * + * if have_step and step == 0: + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 840, __pyx_L1_error) + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + } + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":845 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":847 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":850 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":852 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":855 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":857 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":861 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":863 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":865 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":868 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":870 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":873 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":877 + * + * 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":879 + * 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":880 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":883 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":886 + * + * + * 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":887 + * + * 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":888 + * 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":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":892 + * + * 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":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":894 + * 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_L23:; + + /* "View.MemoryView":896 + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":898 + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":899 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + */ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":901 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: + */ + /*else*/ { + + /* "View.MemoryView":902 + * else: + * _err_dim(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(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 901, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":904 + * "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_L25:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":906 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":809 + * + * @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 + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":912 + * + * @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; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":914 + * 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":915 + * 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":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":919 + * + * 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, 919, __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(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); + + /* "View.MemoryView":920 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":922 + * 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":923 + * 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":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":925 + * 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":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":928 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + */ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":930 + * index += view.shape[dim] + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * if index >= shape: + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 930, __pyx_L1_error) + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":933 + * + * if index >= shape: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 933, __pyx_L1_error) + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":935 + * raise IndexError("Out of bounds on buffer access (axis %d)" % 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":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":937 + * 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":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":939 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":912 + * + * @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_4); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * 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; + + /* "View.MemoryView":946 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * 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":948 + * 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":949 + * + * 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":953 + * + * 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":954 + * 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":955 + * 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":956 + * 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":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 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) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":959 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 1 + */ + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 959, __pyx_L1_error) + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + } + } + + /* "View.MemoryView":961 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = 0; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_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) { + __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":979 + * + * def __dealloc__(self): + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":981 + * __PYX_XDEC_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":982 + * + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":983 + * 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, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":985 + * 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, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":981 + * __PYX_XDEC_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":987 + * 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":988 + * + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":989 + * 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, 989, __pyx_L1_error) + + /* "View.MemoryView":988 + * + * 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":991 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * @property + */ + /*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, 991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":987 + * 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":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":995 + * @property + * def base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":994 + * + * @property + * def 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __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 + PyObject *__pyx_t_1 = NULL; + 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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_XDECREF(__pyx_t_1); + __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, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__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 + 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)":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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_XDECREF(__pyx_t_1); + __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":1001 + * + * @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":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1010 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1015 + * + * + * result = _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, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1015, __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 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__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":1017 + * result = _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":1018 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1020 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1020, __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":1021 + * + * result.from_object = ( memviewslice.memview).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":1023 + * 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":1024 + * + * 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":1025 + * 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":1026 + * 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":1027 + * 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":1029 + * 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":1030 + * + * 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":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1032 + * 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":1034 + * 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":1035 + * + * 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":1038 + * + * + * 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":1039 + * + * 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":1040 + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1041 + * 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":1042 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1040 + * 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":1044 + * 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":1045 + * + * 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, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1046 + * 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, 1046, __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, 1046, __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, 1046, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1048 + * 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":1049 + * + * 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":1051 + * 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":1001 + * + * @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":1054 + * + * @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; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1057 + * __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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1058 + * 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, 1058, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":1059 + * 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":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1061 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1062 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1054 + * + * @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_3); + __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":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * 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":1069 + * 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":1070 + * + * 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":1071 + * 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":1073 + * 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":1074 + * + * 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":1076 + * 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":1077 + * + * 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":1078 + * 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":1079 + * 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":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1082 + * + * @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":1085 + * "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":1086 + * 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, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1082 + * + * @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":1089 + * + * @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; + int __pyx_t_2; + PyObject *(*__pyx_t_3)(char *); + int (*__pyx_t_4)(char *, PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1096 + * 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1097 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1098 + * 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_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1096 + * 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":1100 + * 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":1101 + * 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":1103 + * 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":1105 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __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_5)) __PYX_ERR(1, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1089 + * + * @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_5); + __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":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + __pyx_t_1 = ((__pyx_v_arg < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1113 + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: + * return -arg # <<<<<<<<<<<<<< + * else: + * return arg + */ + __pyx_r = (-__pyx_v_arg); + goto __pyx_L0; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1115 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) 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":1123 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1124 + * 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":1126 + * 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":1127 + * + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1128 + * 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":1129 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1131 + * 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":1132 + * + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1133 + * 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":1134 + * 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":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1136 + * 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)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1137 + * + * 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":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1139 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1142 + * + * @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; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + + /* "View.MemoryView":1149 + * + * 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":1150 + * 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":1151 + * 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":1152 + * 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":1154 + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1155 + * + * 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) != 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) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1156 + * 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_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1155 + * + * 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":1157 + * 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":1155 + * + * 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":1159 + * 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_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1160 + * 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":1161 + * 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":1162 + * 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":1154 + * 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":1164 + * 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_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1165 + * 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":1169 + * 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":1170 + * 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":1142 + * + * @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":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) 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":1175 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) 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":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) 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":1181 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) 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":1183 + * 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":1184 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1186 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) 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":1189 + * + * @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) 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":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1199 + * + * 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":1200 + * 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":1201 + * 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":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1203 + * 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":1204 + * 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":1205 + * 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":1207 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1189 + * + * @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) nogil: + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1210 + * + * @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; + + /* "View.MemoryView":1221 + * 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":1222 + * + * 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":1224 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err(MemoryError, NULL) + */ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1226 + * result = malloc(size) + * if not result: + * _err(MemoryError, NULL) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1226, __pyx_L1_error) + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1229 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1230 + * + * 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":1231 + * 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":1232 + * 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":1233 + * 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, + */ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1235 + * 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":1239 + * + * + * 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":1240 + * + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1241 + * 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":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + } + } + + /* "View.MemoryView":1243 + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1244 + * + * 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":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":1246 + * 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":1248 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1210 + * + * @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 + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = NULL; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1253 + * + * @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("got differing extents in dimension %d (got %d and %d)" % + */ + +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; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + 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":1256 + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * (i, extent1, extent2)) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":1255 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< + * (i, extent1, extent2)) + * + */ + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 1255, __pyx_L1_error) + + /* "View.MemoryView":1253 + * + * @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("got differing extents in dimension %d (got %d and %d)" % + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __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":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + 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_dim", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1260 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: + * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') + */ + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_v_error); + __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 1260, __pyx_L1_error) + + /* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = 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", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":1265 + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: + * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< + * else: + * raise error + */ + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_error); + __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1265, __pyx_L1_error) + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + } + + /* "View.MemoryView":1267 + * raise error(msg.decode('ascii')) + * else: + * raise error # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_contents') + */ + /*else*/ { + __Pyx_Raise(__pyx_v_error, 0, 0, 0); + __PYX_ERR(1, 1267, __pyx_L1_error) + } + + /* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { + void *__pyx_v_tmpdata; + size_t __pyx_v_itemsize; + int __pyx_v_i; + char __pyx_v_order; + int __pyx_v_broadcasting; + int __pyx_v_direct_copy; + __Pyx_memviewslice __pyx_v_tmp; + int __pyx_v_ndim; + int __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1278 + * Check for overlapping memory and verify the shapes. + * """ + * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + */ + __pyx_v_tmpdata = NULL; + + /* "View.MemoryView":1279 + * """ + * cdef void *tmpdata = NULL + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + */ + __pyx_t_1 = __pyx_v_src.memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1281 + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< + * cdef bint broadcasting = False + * cdef bint direct_copy = False + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); + + /* "View.MemoryView":1282 + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False # <<<<<<<<<<<<<< + * cdef bint direct_copy = False + * cdef __Pyx_memviewslice tmp + */ + __pyx_v_broadcasting = 0; + + /* "View.MemoryView":1283 + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False + * cdef bint direct_copy = False # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice tmp + * + */ + __pyx_v_direct_copy = 0; + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1287 + * + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1289 + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< + * + * cdef int ndim = max(src_ndim, dst_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + } + __pyx_L3:; + + /* "View.MemoryView":1291 + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + __pyx_t_3 = __pyx_v_dst_ndim; + __pyx_t_4 = __pyx_v_src_ndim; + if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1293 + * cdef int ndim = max(src_ndim, dst_ndim) + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + */ + __pyx_t_5 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_5; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1296 + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + * broadcasting = True # <<<<<<<<<<<<<< + * src.strides[i] = 0 + * else: + */ + __pyx_v_broadcasting = 1; + + /* "View.MemoryView":1297 + * if src.shape[i] == 1: + * broadcasting = True + * src.strides[i] = 0 # <<<<<<<<<<<<<< + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) + */ + (__pyx_v_src.strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + goto __pyx_L7; + } + + /* "View.MemoryView":1299 + * src.strides[i] = 0 + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< + * + * if src.suboffsets[i] >= 0: + */ + /*else*/ { + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1299, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1302 + * + * if src.suboffsets[i] >= 0: + * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): + */ + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1302, __pyx_L1_error) + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + } + } + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1307 + * + * if not slice_is_contig(src, order, ndim): + * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1309 + * order = get_best_order(&dst, ndim) + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< + * src = tmp + * + */ + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1309, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1310 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1316 + * + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + goto __pyx_L12; + } + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1318 + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< + * + * if direct_copy: + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + } + __pyx_L12:; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_2 = (__pyx_v_direct_copy != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1322 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1323 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + */ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1324 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1325 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1326 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (__pyx_v_order == 'F'); + if (__pyx_t_2) { + __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); + } + __pyx_t_8 = (__pyx_t_2 != 0); + if (__pyx_t_8) { + + /* "View.MemoryView":1331 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1331, __pyx_L1_error) + + /* "View.MemoryView":1332 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1332, __pyx_L1_error) + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1334 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1335 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + */ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1336 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * free(tmpdata) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1338 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1339 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { + int __pyx_v_i; + int __pyx_v_offset; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + + /* "View.MemoryView":1346 + * int ndim_other) nogil: + * cdef int i + * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); + + /* "View.MemoryView":1348 + * cdef int offset = ndim_other - ndim + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = 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":1349 + * + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + */ + (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); + + /* "View.MemoryView":1350 + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + */ + (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1351 + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< + * + * for i in range(offset): + */ + (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); + } + + /* "View.MemoryView":1353 + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + * for i in range(offset): # <<<<<<<<<<<<<< + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + */ + __pyx_t_1 = __pyx_v_offset; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1354 + * + * for i in range(offset): + * mslice.shape[i] = 1 # <<<<<<<<<<<<<< + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 + */ + (__pyx_v_mslice->shape[__pyx_v_i]) = 1; + + /* "View.MemoryView":1355 + * for i in range(offset): + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< + * mslice.suboffsets[i] = -1 + * + */ + (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); + + /* "View.MemoryView":1356 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + int __pyx_t_1; + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + __pyx_t_1 = (__pyx_v_dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1369 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< + * dst.strides, ndim, inc) + * + */ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + + /* function exit code */ +} + +/* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); + + /* "View.MemoryView":1376 + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif +} + +/* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + +static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); + + /* "View.MemoryView":1383 + * cdef Py_ssize_t i + * + * for i in range(shape[0]): # <<<<<<<<<<<<<< + * if ndim == 1: + * if inc: + */ + __pyx_t_1 = (__pyx_v_shape[0]); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + __pyx_t_4 = (__pyx_v_inc != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1386 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1388 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + */ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1390 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1391 + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + * ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += strides[0] + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); + } + __pyx_L5:; + + /* "View.MemoryView":1393 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { + + /* "View.MemoryView":1402 + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1403 + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1405 + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + +static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_extent; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "View.MemoryView":1413 + * size_t itemsize, void *item) nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * + */ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1414 + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] + * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_extent = (__pyx_v_shape[0]); + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1417 + * + * if ndim == 1: + * for i in range(extent): # <<<<<<<<<<<<<< + * memcpy(data, item, itemsize) + * data += stride + */ + __pyx_t_2 = __pyx_v_extent; + __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":1418 + * if ndim == 1: + * for i in range(extent): + * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< + * data += stride + * else: + */ + (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); + + /* "View.MemoryView":1419 + * for i in range(extent): + * memcpy(data, item, itemsize) + * data += stride # <<<<<<<<<<<<<< + * else: + * for i in range(extent): + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1421 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_extent; + __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":1422 + * else: + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, itemsize, item) + * data += stride + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1424 + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + * data += stride # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +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) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + 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_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__20, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); + __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result = __pyx_t_4; + __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_3 = (__pyx_v___pyx_state != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_4 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_3 > 1) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* 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_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_array __pyx_vtable_array; + +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_array_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_array; + p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_array(PyObject *o) { + struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_array___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_array = { + __pyx_array___len__, /*mp_length*/ + __pyx_array___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_array = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "larynx_train.vits.monotonic_align.core.array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_array, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_array, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_Enum(PyObject *o) { + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + if (p->name) { + e = (*v)(p->name, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_Enum(PyObject *o) { + PyObject* tmp; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + tmp = ((PyObject*)p->name); + p->name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "larynx_train.vits.monotonic_align.core.Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_MemviewEnum___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_Enum, /*tp_traverse*/ + __pyx_tp_clear_Enum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_Enum, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_MemviewEnum___init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_Enum, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryview_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_memoryview; + p->obj = Py_None; Py_INCREF(Py_None); + p->_size = Py_None; Py_INCREF(Py_None); + p->_array_interface = Py_None; Py_INCREF(Py_None); + p->view.obj = NULL; + if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_memoryview(PyObject *o) { + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryview___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + Py_CLEAR(p->_array_interface); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + if (p->obj) { + e = (*v)(p->obj, a); if (e) return e; + } + if (p->_size) { + e = (*v)(p->_size, a); if (e) return e; + } + if (p->_array_interface) { + e = (*v)(p->_array_interface, a); if (e) return e; + } + if (p->view.obj) { + e = (*v)(p->view.obj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_memoryview(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + tmp = ((PyObject*)p->obj); + p->obj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_size); + p->_size = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_array_interface); + p->_array_interface = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + Py_CLEAR(p->view.obj); + return 0; +} +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} + +static PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, + {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, + {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, + {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, + {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, + {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, + {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, + {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, + {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, + {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, + {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, + {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_memoryview = { + __pyx_memoryview___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_memoryview, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_memoryview = { + __pyx_memoryview___len__, /*mp_length*/ + __pyx_memoryview___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "larynx_train.vits.monotonic_align.core.memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->from_object); + PyObject_GC_Track(o); + __pyx_tp_dealloc_memoryview(o); +} + +static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; + if (p->from_object) { + e = (*v)(p->from_object, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear__memoryviewslice(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + __pyx_tp_clear_memoryview(o); + tmp = ((PyObject*)p->from_object); + p->from_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + __PYX_XDEC_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { + {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "larynx_train.vits.monotonic_align.core._memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "Internal class for passing memoryview slices to Python", /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"maximum_path_c", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_12larynx_train_4vits_15monotonic_align_4core_1maximum_path_c, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_core}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "core", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, + {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, + {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, + {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, + {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, + {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, + {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, + {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, + {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0}, + {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, + {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1}, + {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, + {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1}, + {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, + {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, + {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, + {&__pyx_n_s_paths, __pyx_k_paths, sizeof(__pyx_k_paths), 0, 0, 1, 1}, + {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, + {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, + {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1}, + {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, + {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0}, + {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0}, + {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, + {&__pyx_n_s_t_xs, __pyx_k_t_xs, sizeof(__pyx_k_t_xs), 0, 0, 1, 1}, + {&__pyx_n_s_t_ys, __pyx_k_t_ys, sizeof(__pyx_k_t_ys), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0}, + {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0}, + {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 15, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 149, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 152, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 615, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 834, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "View.MemoryView":193 + * 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_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "(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_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "(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_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":420 + * 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_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":497 + * 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_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "View.MemoryView":522 + * 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_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "View.MemoryView":572 + * 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_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "View.MemoryView":579 + * 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_tuple__13 = PyTuple_New(1); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_tuple__13, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "(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_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "(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_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_slice__16 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__16)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__16); + __Pyx_GIVEREF(__pyx_slice__16); + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "(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_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + /* "(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_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_tuple__20 = PyTuple_Pack(3, __pyx_int_184977713, __pyx_int_136983863, __pyx_int_112105877); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__26 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + /* InitThreads.init */ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 +PyEval_InitThreads(); +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_array.tp_print = 0; + #endif + if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_MemviewEnum.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryview.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_memoryview_type = &__pyx_type___pyx_memoryview; + __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; + __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; + __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; + __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; + __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; + if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryviewslice.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcore(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_core(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + static PyThread_type_lock __pyx_t_2[8]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_larynx_train__vits__monotonic_align__core) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "larynx_train.vits.monotonic_align.core")) { + if (unlikely(PyDict_SetItemString(modules, "larynx_train.vits.monotonic_align.core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_import_code(); + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "larynx_train/vits/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 + */ + __pyx_k_ = (-1e9); + + /* "larynx_train/vits/monotonic_align/core.pyx":1 + * cimport cython # <<<<<<<<<<<<<< + * from cython.parallel import prange + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":210 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":317 + * + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":318 + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_2[0] = PyThread_allocate_lock(); + __pyx_t_2[1] = PyThread_allocate_lock(); + __pyx_t_2[2] = PyThread_allocate_lock(); + __pyx_t_2[3] = PyThread_allocate_lock(); + __pyx_t_2[4] = PyThread_allocate_lock(); + __pyx_t_2[5] = PyThread_allocate_lock(); + __pyx_t_2[6] = PyThread_allocate_lock(); + __pyx_t_2[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":551 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":997 + * return self.from_object + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init larynx_train.vits.monotonic_align.core", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init larynx_train.vits.monotonic_align.core"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* MemviewSliceInit */ +static int +__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference) +{ + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF(memview); + } + retval = 0; + goto no_fail; +fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} +#ifndef Py_NO_RETURN +#define Py_NO_RETURN +#endif +static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { + va_list vargs; + char msg[200]; +#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); +} +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +{ + int first_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) + return; + if (unlikely(__pyx_get_slice_count(memview) < 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + first_time = __pyx_add_acquisition_count(memview) == 0; + if (unlikely(first_time)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } +} +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + int last_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + if (unlikely(__pyx_get_slice_count(memview) <= 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + last_time = __pyx_sub_acquisition_count(memview) == 1; + memslice->data = NULL; + if (unlikely(last_time)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + memslice->memview = NULL; + } +} + +/* RaiseArgTupleInvalid */ +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) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* None */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* DivInt[Py_ssize_t] */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* decode_c_string */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + Py_ssize_t length; + if (unlikely((start < 0) | (stop < 0))) { + size_t slen = strlen(cstring); + if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, + "c-string too long to convert to Python"); + return NULL; + } + length = (Py_ssize_t) slen; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (unlikely(stop <= start)) + return __Pyx_NewRef(__pyx_empty_unicode); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetAttr3 */ +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r = __Pyx_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* DivInt[long] */ +static CYTHON_INLINE long __Pyx_div_long(long a, long b) { + long q = a / b; + long r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* HasAttr */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!__Pyx_PyBaseString_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); +#else + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); +#endif + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetVTable */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* PyObjectGetAttrStrNoError */ +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + +/* MemviewSliceIsContig */ +static int +__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) +{ + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; +} + +/* OverlappingSlices */ +static void +__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) +{ + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + *out_start = start; + *out_end = end + itemsize; +} +static int +__pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) +{ + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); +} + +/* Capsule */ +static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) +{ + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); +#else + cobj = PyCObject_FromVoidPtr(p, NULL); +#endif + return cobj; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* TypeInfoCompare */ + static int +__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) +{ + int i; + if (!a || !b) + return 0; + if (a == b) + return 1; + if (a->size != b->size || a->typegroup != b->typegroup || + a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { + if (a->typegroup == 'H' || b->typegroup == 'H') { + return a->size == b->size; + } else { + return 0; + } + } + if (a->ndim) { + for (i = 0; i < a->ndim; i++) + if (a->arraysize[i] != b->arraysize[i]) + return 0; + } + if (a->typegroup == 'S') { + if (a->flags != b->flags) + return 0; + if (a->fields || b->fields) { + if (!(a->fields && b->fields)) + return 0; + for (i = 0; a->fields[i].type && b->fields[i].type; i++) { + __Pyx_StructField *field_a = a->fields + i; + __Pyx_StructField *field_b = b->fields + i; + if (field_a->offset != field_b->offset || + !__pyx_typeinfo_cmp(field_a->type, field_b->type)) + return 0; + } + return !a->fields[i].type && !b->fields[i].type; + } + } + return 1; +} + +/* MemviewSliceValidateAndInit */ + static int +__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) +{ + if (buf->shape[dim] <= 1) + return 1; + if (buf->strides) { + if (spec & __Pyx_MEMVIEW_CONTIG) { + if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { + if (unlikely(buf->strides[dim] != sizeof(void *))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly contiguous " + "in dimension %d.", dim); + goto fail; + } + } else if (unlikely(buf->strides[dim] != buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_FOLLOW) { + Py_ssize_t stride = buf->strides[dim]; + if (stride < 0) + stride = -stride; + if (unlikely(stride < buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + } else { + if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not contiguous in " + "dimension %d", dim); + goto fail; + } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not indirect in " + "dimension %d", dim); + goto fail; + } else if (unlikely(buf->suboffsets)) { + PyErr_SetString(PyExc_ValueError, + "Buffer exposes suboffsets but no strides"); + goto fail; + } + } + return 1; +fail: + return 0; +} +static int +__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) +{ + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + PyErr_Format(PyExc_ValueError, + "Buffer not compatible with direct access " + "in dimension %d.", dim); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_PTR) { + if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly accessible " + "in dimension %d.", dim); + goto fail; + } + } + return 1; +fail: + return 0; +} +static int +__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) +{ + int i; + if (c_or_f_flag & __Pyx_IS_F_CONTIG) { + Py_ssize_t stride = 1; + for (i = 0; i < ndim; i++) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not fortran contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { + Py_ssize_t stride = 1; + for (i = ndim - 1; i >- 1; i--) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not C contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } + return 1; +fail: + return 0; +} +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) +{ + struct __pyx_memoryview_obj *memview, *new_memview; + __Pyx_RefNannyDeclarations + Py_buffer *buf; + int i, spec = 0, retval = -1; + __Pyx_BufFmt_Context ctx; + int from_memoryview = __pyx_memoryview_check(original_obj); + __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); + if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) + original_obj)->typeinfo)) { + memview = (struct __pyx_memoryview_obj *) original_obj; + new_memview = NULL; + } else { + memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + original_obj, buf_flags, 0, dtype); + new_memview = memview; + if (unlikely(!memview)) + goto fail; + } + buf = &memview->view; + if (unlikely(buf->ndim != ndim)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + ndim, buf->ndim); + goto fail; + } + if (new_memview) { + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; + } + if (unlikely((unsigned) buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " + "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", + buf->itemsize, + (buf->itemsize > 1) ? "s" : "", + dtype->name, + dtype->size, + (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->len > 0) { + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) + goto fail; + if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) + goto fail; + } + if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) + goto fail; + } + if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, + new_memview != NULL) == -1)) { + goto fail; + } + retval = 0; + goto no_fail; +fail: + Py_XDECREF(new_memview); + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, + (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3, + &__Pyx_TypeInfo_int, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, + (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3, + &__Pyx_TypeInfo_float, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, + (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, + &__Pyx_TypeInfo_int, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* MemviewSliceCopyTemplate */ + 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) +{ + __Pyx_RefNannyDeclarations + int i; + __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; + struct __pyx_memoryview_obj *from_memview = from_mvs->memview; + Py_buffer *buf = &from_memview->view; + PyObject *shape_tuple = NULL; + PyObject *temp_int = NULL; + struct __pyx_array_obj *array_obj = NULL; + struct __pyx_memoryview_obj *memview_obj = NULL; + __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); + for (i = 0; i < ndim; i++) { + if (unlikely(from_mvs->suboffsets[i] >= 0)) { + PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " + "indirect dimensions (axis %d)", i); + goto fail; + } + } + shape_tuple = PyTuple_New(ndim); + if (unlikely(!shape_tuple)) { + goto fail; + } + __Pyx_GOTREF(shape_tuple); + for(i = 0; i < ndim; i++) { + temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); + if(unlikely(!temp_int)) { + goto fail; + } else { + PyTuple_SET_ITEM(shape_tuple, i, temp_int); + temp_int = NULL; + } + } + array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); + if (unlikely(!array_obj)) { + goto fail; + } + __Pyx_GOTREF(array_obj); + memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + (PyObject *) array_obj, contig_flag, + dtype_is_object, + from_mvs->memview->typeinfo); + if (unlikely(!memview_obj)) + goto fail; + if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) + goto fail; + if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, + dtype_is_object) < 0)) + goto fail; + goto no_fail; +fail: + __Pyx_XDECREF(new_mvs.memview); + new_mvs.memview = NULL; + new_mvs.data = NULL; +no_fail: + __Pyx_XDECREF(shape_tuple); + __Pyx_XDECREF(temp_int); + __Pyx_XDECREF(array_obj); + __Pyx_RefNannyFinishContext(); + return new_mvs; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const char neg_one = (char) -1, const_zero = (char) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(char) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (char) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(char) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + case -2: + if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + } +#endif + if (sizeof(char) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + char val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (char) -1; + } + } else { + char val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (char) -1; + val = __Pyx_PyInt_As_char(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to char"); + return (char) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to char"); + return (char) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[5]; + int same=1, i, found_dot; + const char* rt_from_call = Py_GetVersion(); + PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + found_dot = 0; + for (i = 0; i < 4; i++) { + if (!ctversion[i]) { + same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); + break; + } + if (rt_from_call[i] != ctversion[i]) { + same = 0; + break; + } + } + if (!same) { + char rtversion[5] = {'\0'}; + char message[200]; + for (i=0; i<4; ++i) { + if (rt_from_call[i] == '.') { + if (found_dot) break; + found_dot = 1; + } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { + break; + } + rtversion[i] = rt_from_call[i]; + } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/src/python/larynx_train/vits/monotonic_align/core.pyx b/src/python/larynx_train/vits/monotonic_align/core.pyx new file mode 100644 index 0000000..bfaabd4 --- /dev/null +++ b/src/python/larynx_train/vits/monotonic_align/core.pyx @@ -0,0 +1,42 @@ +cimport cython +from cython.parallel import prange + + +@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 + cdef float v_prev + cdef float v_cur + cdef float tmp + cdef int index = t_x - 1 + + for y in range(t_y): + for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): + if x == y: + v_cur = max_neg_val + else: + v_cur = value[y-1, x] + if x == 0: + if y == 0: + v_prev = 0. + else: + v_prev = max_neg_val + else: + v_prev = value[y-1, x-1] + value[y, x] += max(v_prev, v_cur) + + for y in range(t_y - 1, -1, -1): + path[y, index] = 1 + if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]): + index = index - 1 + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_ys, int[::1] t_xs) nogil: + cdef int b = paths.shape[0] + cdef int i + for i in prange(b, nogil=True): + maximum_path_each(paths[i], values[i], t_ys[i], t_xs[i]) diff --git a/src/python/larynx_train/vits/monotonic_align/setup.py b/src/python/larynx_train/vits/monotonic_align/setup.py new file mode 100644 index 0000000..ce87738 --- /dev/null +++ b/src/python/larynx_train/vits/monotonic_align/setup.py @@ -0,0 +1,13 @@ +from distutils.core import setup +from pathlib import Path + +import numpy +from Cython.Build import cythonize + +_DIR = Path(__file__).parent + +setup( + name="monotonic_align", + ext_modules=cythonize(str(_DIR / "core.pyx")), + include_dirs=[numpy.get_include()], +) diff --git a/src/python/larynx_train/vits/transforms.py b/src/python/larynx_train/vits/transforms.py new file mode 100644 index 0000000..329862f --- /dev/null +++ b/src/python/larynx_train/vits/transforms.py @@ -0,0 +1,212 @@ +import numpy as np +import torch +from torch.nn import functional as F + +DEFAULT_MIN_BIN_WIDTH = 1e-3 +DEFAULT_MIN_BIN_HEIGHT = 1e-3 +DEFAULT_MIN_DERIVATIVE = 1e-3 + + +def piecewise_rational_quadratic_transform( + inputs, + unnormalized_widths, + unnormalized_heights, + unnormalized_derivatives, + inverse=False, + tails=None, + tail_bound=1.0, + min_bin_width=DEFAULT_MIN_BIN_WIDTH, + min_bin_height=DEFAULT_MIN_BIN_HEIGHT, + min_derivative=DEFAULT_MIN_DERIVATIVE, +): + + if tails is None: + spline_fn = rational_quadratic_spline + spline_kwargs = {} + else: + spline_fn = unconstrained_rational_quadratic_spline + spline_kwargs = {"tails": tails, "tail_bound": tail_bound} + + outputs, logabsdet = spline_fn( + inputs=inputs, + unnormalized_widths=unnormalized_widths, + unnormalized_heights=unnormalized_heights, + unnormalized_derivatives=unnormalized_derivatives, + inverse=inverse, + min_bin_width=min_bin_width, + min_bin_height=min_bin_height, + min_derivative=min_derivative, + **spline_kwargs + ) + return outputs, logabsdet + + +def searchsorted(bin_locations, inputs, eps=1e-6): + # bin_locations[..., -1] += eps + bin_locations[..., bin_locations.size(-1) - 1] += eps + return torch.sum(inputs[..., None] >= bin_locations, dim=-1) - 1 + + +def unconstrained_rational_quadratic_spline( + inputs, + unnormalized_widths, + unnormalized_heights, + unnormalized_derivatives, + inverse=False, + tails="linear", + tail_bound=1.0, + min_bin_width=DEFAULT_MIN_BIN_WIDTH, + min_bin_height=DEFAULT_MIN_BIN_HEIGHT, + min_derivative=DEFAULT_MIN_DERIVATIVE, +): + inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound) + outside_interval_mask = ~inside_interval_mask + + outputs = torch.zeros_like(inputs) + logabsdet = torch.zeros_like(inputs) + + if tails == "linear": + unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1)) + constant = np.log(np.exp(1 - min_derivative) - 1) + unnormalized_derivatives[..., 0] = constant + # unnormalized_derivatives[..., -1] = constant + unnormalized_derivatives[..., unnormalized_derivatives.size(-1) - 1] = constant + + outputs[outside_interval_mask] = inputs[outside_interval_mask] + logabsdet[outside_interval_mask] = 0 + else: + raise RuntimeError("{} tails are not implemented.".format(tails)) + + ( + outputs[inside_interval_mask], + logabsdet[inside_interval_mask], + ) = rational_quadratic_spline( + inputs=inputs[inside_interval_mask], + unnormalized_widths=unnormalized_widths[inside_interval_mask, :], + unnormalized_heights=unnormalized_heights[inside_interval_mask, :], + unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :], + inverse=inverse, + left=-tail_bound, + right=tail_bound, + bottom=-tail_bound, + top=tail_bound, + min_bin_width=min_bin_width, + min_bin_height=min_bin_height, + min_derivative=min_derivative, + ) + + return outputs, logabsdet + + +def rational_quadratic_spline( + inputs, + unnormalized_widths, + unnormalized_heights, + unnormalized_derivatives, + inverse=False, + left=0.0, + right=1.0, + bottom=0.0, + top=1.0, + min_bin_width=DEFAULT_MIN_BIN_WIDTH, + min_bin_height=DEFAULT_MIN_BIN_HEIGHT, + min_derivative=DEFAULT_MIN_DERIVATIVE, +): + # if torch.min(inputs) < left or torch.max(inputs) > right: + # raise ValueError("Input to a transform is not within its domain") + + num_bins = unnormalized_widths.shape[-1] + + # if min_bin_width * num_bins > 1.0: + # raise ValueError("Minimal bin width too large for the number of bins") + # if min_bin_height * num_bins > 1.0: + # raise ValueError("Minimal bin height too large for the number of bins") + + widths = F.softmax(unnormalized_widths, dim=-1) + widths = min_bin_width + (1 - min_bin_width * num_bins) * widths + cumwidths = torch.cumsum(widths, dim=-1) + cumwidths = F.pad(cumwidths, pad=(1, 0), mode="constant", value=0.0) + cumwidths = (right - left) * cumwidths + left + cumwidths[..., 0] = left + # cumwidths[..., -1] = right + cumwidths[..., cumwidths.size(-1) - 1] = right + widths = cumwidths[..., 1:] - cumwidths[..., :-1] + + derivatives = min_derivative + F.softplus(unnormalized_derivatives) + + heights = F.softmax(unnormalized_heights, dim=-1) + heights = min_bin_height + (1 - min_bin_height * num_bins) * heights + cumheights = torch.cumsum(heights, dim=-1) + cumheights = F.pad(cumheights, pad=(1, 0), mode="constant", value=0.0) + cumheights = (top - bottom) * cumheights + bottom + cumheights[..., 0] = bottom + # cumheights[..., -1] = top + cumheights[..., cumheights.size(-1) - 1] = top + heights = cumheights[..., 1:] - cumheights[..., :-1] + + if inverse: + bin_idx = searchsorted(cumheights, inputs)[..., None] + else: + bin_idx = searchsorted(cumwidths, inputs)[..., None] + + input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0] + input_bin_widths = widths.gather(-1, bin_idx)[..., 0] + + input_cumheights = cumheights.gather(-1, bin_idx)[..., 0] + delta = heights / widths + input_delta = delta.gather(-1, bin_idx)[..., 0] + + input_derivatives = derivatives.gather(-1, bin_idx)[..., 0] + input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0] + + input_heights = heights.gather(-1, bin_idx)[..., 0] + + if inverse: + a = (inputs - input_cumheights) * ( + input_derivatives + input_derivatives_plus_one - 2 * input_delta + ) + input_heights * (input_delta - input_derivatives) + b = input_heights * input_derivatives - (inputs - input_cumheights) * ( + input_derivatives + input_derivatives_plus_one - 2 * input_delta + ) + c = -input_delta * (inputs - input_cumheights) + + discriminant = b.pow(2) - 4 * a * c + assert (discriminant >= 0).all(), discriminant + + root = (2 * c) / (-b - torch.sqrt(discriminant)) + outputs = root * input_bin_widths + input_cumwidths + + theta_one_minus_theta = root * (1 - root) + denominator = input_delta + ( + (input_derivatives + input_derivatives_plus_one - 2 * input_delta) + * theta_one_minus_theta + ) + derivative_numerator = input_delta.pow(2) * ( + input_derivatives_plus_one * root.pow(2) + + 2 * input_delta * theta_one_minus_theta + + input_derivatives * (1 - root).pow(2) + ) + logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator) + + return outputs, -logabsdet + + theta = (inputs - input_cumwidths) / input_bin_widths + theta_one_minus_theta = theta * (1 - theta) + + numerator = input_heights * ( + input_delta * theta.pow(2) + input_derivatives * theta_one_minus_theta + ) + denominator = input_delta + ( + (input_derivatives + input_derivatives_plus_one - 2 * input_delta) + * theta_one_minus_theta + ) + outputs = input_cumheights + numerator / denominator + + derivative_numerator = input_delta.pow(2) * ( + input_derivatives_plus_one * theta.pow(2) + + 2 * input_delta * theta_one_minus_theta + + input_derivatives * (1 - theta).pow(2) + ) + logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator) + + return outputs, logabsdet diff --git a/src/python/larynx_train/vits/utils.py b/src/python/larynx_train/vits/utils.py new file mode 100644 index 0000000..84d7ecc --- /dev/null +++ b/src/python/larynx_train/vits/utils.py @@ -0,0 +1,16 @@ +import numpy as np +import torch + + +def to_gpu(x: torch.Tensor) -> torch.Tensor: + return x.contiguous().cuda(non_blocking=True) + + +def audio_float_to_int16( + audio: np.ndarray, max_wav_value: float = 32767.0 +) -> np.ndarray: + """Normalize audio and convert to int16 range""" + audio_norm = audio * (max_wav_value / max(0.01, np.max(np.abs(audio)))) + audio_norm = np.clip(audio_norm, -max_wav_value, max_wav_value) + audio_norm = audio_norm.astype("int16") + return audio_norm diff --git a/src/python/larynx_train/vits/utterance.py b/src/python/larynx_train/vits/utterance.py new file mode 100644 index 0000000..9e59ced --- /dev/null +++ b/src/python/larynx_train/vits/utterance.py @@ -0,0 +1,172 @@ +import json +from dataclasses import dataclass +from pathlib import Path +from subprocess import Popen +from typing import List, Optional + +import librosa +import torch +from dataclasses_json import DataClassJsonMixin +from torch import Tensor + + +@dataclass +class DatasetUtterance(DataClassJsonMixin): + id: str + text: Optional[str] = None + phonemes: Optional[List[str]] = None + phoneme_ids: Optional[List[int]] = None + audio_path: Optional[Path] = None + audio_norm_path: Optional[Path] = None + mel_spec_path: Optional[Path] = None + speaker: Optional[str] = None + speaker_id: Optional[int] = None + + def __post_init__(self): + self._original_json: Optional[str] = None + + @property + def original_json(self) -> str: + if self._original_json is None: + self._original_json = self.to_json(ensure_ascii=False) + + return self._original_json + + +@dataclass +class TrainingUtterance: + id: str + phoneme_ids: Tensor + audio_norm: Tensor + mel_spec: Tensor + speaker_id: Optional[Tensor] = None + + +# ----------------------------------------------------------------------------- + + +@dataclass +class UtteranceLoadingContext: + cache_dir: Path + is_multispeaker: bool + phonemize: Optional[Popen] = None + phonemes2ids: Optional[Popen] = None + speaker2id: Optional[Popen] = None + audio2norm: Optional[Popen] = None + audio2spec: Optional[Popen] = None + + +def load_utterance( + utterance_json: str, context: UtteranceLoadingContext +) -> TrainingUtterance: + data_utterance = DatasetUtterance.from_json(utterance_json) + + # pylint: disable=protected-access + data_utterance._original_json = utterance_json + + # Requirements: + # 1. phoneme ids + # 2. audio norm + # 3. mel spec + # 4. speaker id (if multispeaker) + + # 1. phoneme ids + if data_utterance.phoneme_ids is None: + _load_phoneme_ids(data_utterance, context) + + # 2. audio norm + if (data_utterance.audio_norm_path is None) or ( + not data_utterance.audio_norm_path.exists() + ): + _load_audio_norm(data_utterance, context) + + # 3. mel spec + if (data_utterance.mel_spec_path is None) or ( + not data_utterance.mel_spec_path.exists() + ): + _load_mel_spec(data_utterance, context) + + # 4. speaker id + if context.is_multispeaker: + if data_utterance.speaker_id is None: + _load_speaker_id(data_utterance, context) + + # Convert to training utterance + assert data_utterance.phoneme_ids is not None + assert data_utterance.audio_norm_path is not None + assert data_utterance.mel_spec_path is not None + + if context.is_multispeaker: + assert data_utterance.speaker_id is not None + + train_utterance = TrainingUtterance( + id=data_utterance.id, + phoneme_ids=torch.LongTensor(data_utterance.phoneme_ids), + audio_norm=torch.load(data_utterance.audio_norm_path), + mel_spec=torch.load(data_utterance.mel_spec_path), + speaker_id=None + if data_utterance.speaker_id is None + else torch.LongTensor(data_utterance.speaker_id), + ) + + return train_utterance + + +def _load_phoneme_ids( + data_utterance: DatasetUtterance, context: UtteranceLoadingContext +): + if data_utterance.phonemes is None: + # Need phonemes first + _load_phonemes(data_utterance, context) + + assert ( + data_utterance.phonemes is not None + ), f"phonemes is required for phoneme ids: {data_utterance}" + + assert ( + context.phonemes2ids is not None + ), f"phonemes2ids program is required for phoneme ids: {data_utterance}" + + assert context.phonemes2ids.stdin is not None + assert context.phonemes2ids.stdout is not None + + # JSON in, JSON out + print(data_utterance.original_json, file=context.phonemes2ids.stdin, flush=True) + result_json = context.phonemes2ids.stdout.readline() + result_dict = json.loads(result_json) + + # Update utterance + data_utterance.phoneme_ids = result_dict["phoneme_ids"] + data_utterance._original_json = result_json + + +def _load_phonemes(data_utterance: DatasetUtterance, context: UtteranceLoadingContext): + assert ( + data_utterance.text is not None + ), f"text is required for phonemes: {data_utterance}" + + assert ( + context.phonemize is not None + ), f"phonemize program is required for phonemes: {data_utterance}" + + assert context.phonemize.stdin is not None + assert context.phonemize.stdout is not None + + # JSON in, JSON out + print(data_utterance.original_json, file=context.phonemize.stdin, flush=True) + result_json = context.phonemize.stdout.readline() + result_dict = json.loads(result_json) + + # Update utterance + data_utterance.phonemes = result_dict["phoneme"] + data_utterance._original_json = result_json + + +def _load_audio_norm( + data_utterance: DatasetUtterance, context: UtteranceLoadingContext +): + pass + + +def _load_mel_spec(data_utterance: DatasetUtterance, context: UtteranceLoadingContext): + pass diff --git a/src/python/larynx_train/vits/wavfile.py b/src/python/larynx_train/vits/wavfile.py new file mode 100644 index 0000000..38a71c9 --- /dev/null +++ b/src/python/larynx_train/vits/wavfile.py @@ -0,0 +1,860 @@ +""" +Module to read / write wav files using NumPy arrays + +Functions +--------- +`read`: Return the sample rate (in samples/sec) and data from a WAV file. + +`write`: Write a NumPy array as a WAV file. + +""" +import io +import struct +import sys +import warnings +from enum import IntEnum + +import numpy + +__all__ = ["WavFileWarning", "read", "write"] + + +class WavFileWarning(UserWarning): + pass + + +class WAVE_FORMAT(IntEnum): + """ + WAVE form wFormatTag IDs + + Complete list is in mmreg.h in Windows 10 SDK. ALAC and OPUS are the + newest additions, in v10.0.14393 2016-07 + """ + + UNKNOWN = 0x0000 + PCM = 0x0001 + ADPCM = 0x0002 + IEEE_FLOAT = 0x0003 + VSELP = 0x0004 + IBM_CVSD = 0x0005 + ALAW = 0x0006 + MULAW = 0x0007 + DTS = 0x0008 + DRM = 0x0009 + WMAVOICE9 = 0x000A + WMAVOICE10 = 0x000B + OKI_ADPCM = 0x0010 + DVI_ADPCM = 0x0011 + IMA_ADPCM = 0x0011 # Duplicate + MEDIASPACE_ADPCM = 0x0012 + SIERRA_ADPCM = 0x0013 + G723_ADPCM = 0x0014 + DIGISTD = 0x0015 + DIGIFIX = 0x0016 + DIALOGIC_OKI_ADPCM = 0x0017 + MEDIAVISION_ADPCM = 0x0018 + CU_CODEC = 0x0019 + HP_DYN_VOICE = 0x001A + YAMAHA_ADPCM = 0x0020 + SONARC = 0x0021 + DSPGROUP_TRUESPEECH = 0x0022 + ECHOSC1 = 0x0023 + AUDIOFILE_AF36 = 0x0024 + APTX = 0x0025 + AUDIOFILE_AF10 = 0x0026 + PROSODY_1612 = 0x0027 + LRC = 0x0028 + DOLBY_AC2 = 0x0030 + GSM610 = 0x0031 + MSNAUDIO = 0x0032 + ANTEX_ADPCME = 0x0033 + CONTROL_RES_VQLPC = 0x0034 + DIGIREAL = 0x0035 + DIGIADPCM = 0x0036 + CONTROL_RES_CR10 = 0x0037 + NMS_VBXADPCM = 0x0038 + CS_IMAADPCM = 0x0039 + ECHOSC3 = 0x003A + ROCKWELL_ADPCM = 0x003B + ROCKWELL_DIGITALK = 0x003C + XEBEC = 0x003D + G721_ADPCM = 0x0040 + G728_CELP = 0x0041 + MSG723 = 0x0042 + INTEL_G723_1 = 0x0043 + INTEL_G729 = 0x0044 + SHARP_G726 = 0x0045 + MPEG = 0x0050 + RT24 = 0x0052 + PAC = 0x0053 + MPEGLAYER3 = 0x0055 + LUCENT_G723 = 0x0059 + CIRRUS = 0x0060 + ESPCM = 0x0061 + VOXWARE = 0x0062 + CANOPUS_ATRAC = 0x0063 + G726_ADPCM = 0x0064 + G722_ADPCM = 0x0065 + DSAT = 0x0066 + DSAT_DISPLAY = 0x0067 + VOXWARE_BYTE_ALIGNED = 0x0069 + VOXWARE_AC8 = 0x0070 + VOXWARE_AC10 = 0x0071 + VOXWARE_AC16 = 0x0072 + VOXWARE_AC20 = 0x0073 + VOXWARE_RT24 = 0x0074 + VOXWARE_RT29 = 0x0075 + VOXWARE_RT29HW = 0x0076 + VOXWARE_VR12 = 0x0077 + VOXWARE_VR18 = 0x0078 + VOXWARE_TQ40 = 0x0079 + VOXWARE_SC3 = 0x007A + VOXWARE_SC3_1 = 0x007B + SOFTSOUND = 0x0080 + VOXWARE_TQ60 = 0x0081 + MSRT24 = 0x0082 + G729A = 0x0083 + MVI_MVI2 = 0x0084 + DF_G726 = 0x0085 + DF_GSM610 = 0x0086 + ISIAUDIO = 0x0088 + ONLIVE = 0x0089 + MULTITUDE_FT_SX20 = 0x008A + INFOCOM_ITS_G721_ADPCM = 0x008B + CONVEDIA_G729 = 0x008C + CONGRUENCY = 0x008D + SBC24 = 0x0091 + DOLBY_AC3_SPDIF = 0x0092 + MEDIASONIC_G723 = 0x0093 + PROSODY_8KBPS = 0x0094 + ZYXEL_ADPCM = 0x0097 + PHILIPS_LPCBB = 0x0098 + PACKED = 0x0099 + MALDEN_PHONYTALK = 0x00A0 + RACAL_RECORDER_GSM = 0x00A1 + RACAL_RECORDER_G720_A = 0x00A2 + RACAL_RECORDER_G723_1 = 0x00A3 + RACAL_RECORDER_TETRA_ACELP = 0x00A4 + NEC_AAC = 0x00B0 + RAW_AAC1 = 0x00FF + RHETOREX_ADPCM = 0x0100 + IRAT = 0x0101 + VIVO_G723 = 0x0111 + VIVO_SIREN = 0x0112 + PHILIPS_CELP = 0x0120 + PHILIPS_GRUNDIG = 0x0121 + DIGITAL_G723 = 0x0123 + SANYO_LD_ADPCM = 0x0125 + SIPROLAB_ACEPLNET = 0x0130 + SIPROLAB_ACELP4800 = 0x0131 + SIPROLAB_ACELP8V3 = 0x0132 + SIPROLAB_G729 = 0x0133 + SIPROLAB_G729A = 0x0134 + SIPROLAB_KELVIN = 0x0135 + VOICEAGE_AMR = 0x0136 + G726ADPCM = 0x0140 + DICTAPHONE_CELP68 = 0x0141 + DICTAPHONE_CELP54 = 0x0142 + QUALCOMM_PUREVOICE = 0x0150 + QUALCOMM_HALFRATE = 0x0151 + TUBGSM = 0x0155 + MSAUDIO1 = 0x0160 + WMAUDIO2 = 0x0161 + WMAUDIO3 = 0x0162 + WMAUDIO_LOSSLESS = 0x0163 + WMASPDIF = 0x0164 + UNISYS_NAP_ADPCM = 0x0170 + UNISYS_NAP_ULAW = 0x0171 + UNISYS_NAP_ALAW = 0x0172 + UNISYS_NAP_16K = 0x0173 + SYCOM_ACM_SYC008 = 0x0174 + SYCOM_ACM_SYC701_G726L = 0x0175 + SYCOM_ACM_SYC701_CELP54 = 0x0176 + SYCOM_ACM_SYC701_CELP68 = 0x0177 + KNOWLEDGE_ADVENTURE_ADPCM = 0x0178 + FRAUNHOFER_IIS_MPEG2_AAC = 0x0180 + DTS_DS = 0x0190 + CREATIVE_ADPCM = 0x0200 + CREATIVE_FASTSPEECH8 = 0x0202 + CREATIVE_FASTSPEECH10 = 0x0203 + UHER_ADPCM = 0x0210 + ULEAD_DV_AUDIO = 0x0215 + ULEAD_DV_AUDIO_1 = 0x0216 + QUARTERDECK = 0x0220 + ILINK_VC = 0x0230 + RAW_SPORT = 0x0240 + ESST_AC3 = 0x0241 + GENERIC_PASSTHRU = 0x0249 + IPI_HSX = 0x0250 + IPI_RPELP = 0x0251 + CS2 = 0x0260 + SONY_SCX = 0x0270 + SONY_SCY = 0x0271 + SONY_ATRAC3 = 0x0272 + SONY_SPC = 0x0273 + TELUM_AUDIO = 0x0280 + TELUM_IA_AUDIO = 0x0281 + NORCOM_VOICE_SYSTEMS_ADPCM = 0x0285 + FM_TOWNS_SND = 0x0300 + MICRONAS = 0x0350 + MICRONAS_CELP833 = 0x0351 + BTV_DIGITAL = 0x0400 + INTEL_MUSIC_CODER = 0x0401 + INDEO_AUDIO = 0x0402 + QDESIGN_MUSIC = 0x0450 + ON2_VP7_AUDIO = 0x0500 + ON2_VP6_AUDIO = 0x0501 + VME_VMPCM = 0x0680 + TPC = 0x0681 + LIGHTWAVE_LOSSLESS = 0x08AE + OLIGSM = 0x1000 + OLIADPCM = 0x1001 + OLICELP = 0x1002 + OLISBC = 0x1003 + OLIOPR = 0x1004 + LH_CODEC = 0x1100 + LH_CODEC_CELP = 0x1101 + LH_CODEC_SBC8 = 0x1102 + LH_CODEC_SBC12 = 0x1103 + LH_CODEC_SBC16 = 0x1104 + NORRIS = 0x1400 + ISIAUDIO_2 = 0x1401 + SOUNDSPACE_MUSICOMPRESS = 0x1500 + MPEG_ADTS_AAC = 0x1600 + MPEG_RAW_AAC = 0x1601 + MPEG_LOAS = 0x1602 + NOKIA_MPEG_ADTS_AAC = 0x1608 + NOKIA_MPEG_RAW_AAC = 0x1609 + VODAFONE_MPEG_ADTS_AAC = 0x160A + VODAFONE_MPEG_RAW_AAC = 0x160B + MPEG_HEAAC = 0x1610 + VOXWARE_RT24_SPEECH = 0x181C + SONICFOUNDRY_LOSSLESS = 0x1971 + INNINGS_TELECOM_ADPCM = 0x1979 + LUCENT_SX8300P = 0x1C07 + LUCENT_SX5363S = 0x1C0C + CUSEEME = 0x1F03 + NTCSOFT_ALF2CM_ACM = 0x1FC4 + DVM = 0x2000 + DTS2 = 0x2001 + MAKEAVIS = 0x3313 + DIVIO_MPEG4_AAC = 0x4143 + NOKIA_ADAPTIVE_MULTIRATE = 0x4201 + DIVIO_G726 = 0x4243 + LEAD_SPEECH = 0x434C + LEAD_VORBIS = 0x564C + WAVPACK_AUDIO = 0x5756 + OGG_VORBIS_MODE_1 = 0x674F + OGG_VORBIS_MODE_2 = 0x6750 + OGG_VORBIS_MODE_3 = 0x6751 + OGG_VORBIS_MODE_1_PLUS = 0x676F + OGG_VORBIS_MODE_2_PLUS = 0x6770 + OGG_VORBIS_MODE_3_PLUS = 0x6771 + ALAC = 0x6C61 + _3COM_NBX = 0x7000 # Can't have leading digit + OPUS = 0x704F + FAAD_AAC = 0x706D + AMR_NB = 0x7361 + AMR_WB = 0x7362 + AMR_WP = 0x7363 + GSM_AMR_CBR = 0x7A21 + GSM_AMR_VBR_SID = 0x7A22 + COMVERSE_INFOSYS_G723_1 = 0xA100 + COMVERSE_INFOSYS_AVQSBC = 0xA101 + COMVERSE_INFOSYS_SBC = 0xA102 + SYMBOL_G729_A = 0xA103 + VOICEAGE_AMR_WB = 0xA104 + INGENIENT_G726 = 0xA105 + MPEG4_AAC = 0xA106 + ENCORE_G726 = 0xA107 + ZOLL_ASAO = 0xA108 + SPEEX_VOICE = 0xA109 + VIANIX_MASC = 0xA10A + WM9_SPECTRUM_ANALYZER = 0xA10B + WMF_SPECTRUM_ANAYZER = 0xA10C + GSM_610 = 0xA10D + GSM_620 = 0xA10E + GSM_660 = 0xA10F + GSM_690 = 0xA110 + GSM_ADAPTIVE_MULTIRATE_WB = 0xA111 + POLYCOM_G722 = 0xA112 + POLYCOM_G728 = 0xA113 + POLYCOM_G729_A = 0xA114 + POLYCOM_SIREN = 0xA115 + GLOBAL_IP_ILBC = 0xA116 + RADIOTIME_TIME_SHIFT_RADIO = 0xA117 + NICE_ACA = 0xA118 + NICE_ADPCM = 0xA119 + VOCORD_G721 = 0xA11A + VOCORD_G726 = 0xA11B + VOCORD_G722_1 = 0xA11C + VOCORD_G728 = 0xA11D + VOCORD_G729 = 0xA11E + VOCORD_G729_A = 0xA11F + VOCORD_G723_1 = 0xA120 + VOCORD_LBC = 0xA121 + NICE_G728 = 0xA122 + FRACE_TELECOM_G729 = 0xA123 + CODIAN = 0xA124 + FLAC = 0xF1AC + EXTENSIBLE = 0xFFFE + DEVELOPMENT = 0xFFFF + + +KNOWN_WAVE_FORMATS = {WAVE_FORMAT.PCM, WAVE_FORMAT.IEEE_FLOAT} + + +def _raise_bad_format(format_tag): + try: + format_name = WAVE_FORMAT(format_tag).name + except ValueError: + format_name = f"{format_tag:#06x}" + raise ValueError( + f"Unknown wave file format: {format_name}. Supported " + "formats: " + ", ".join(x.name for x in KNOWN_WAVE_FORMATS) + ) + + +def _read_fmt_chunk(fid, is_big_endian): + """ + Returns + ------- + size : int + size of format subchunk in bytes (minus 8 for "fmt " and itself) + format_tag : int + PCM, float, or compressed format + channels : int + number of channels + fs : int + sampling frequency in samples per second + bytes_per_second : int + overall byte rate for the file + block_align : int + bytes per sample, including all channels + bit_depth : int + bits per sample + + Notes + ----- + Assumes file pointer is immediately after the 'fmt ' id + """ + if is_big_endian: + fmt = ">" + else: + fmt = "<" + + size = struct.unpack(fmt + "I", fid.read(4))[0] + + if size < 16: + raise ValueError("Binary structure of wave file is not compliant") + + res = struct.unpack(fmt + "HHIIHH", fid.read(16)) + bytes_read = 16 + + format_tag, channels, fs, bytes_per_second, block_align, bit_depth = res + + if format_tag == WAVE_FORMAT.EXTENSIBLE and size >= (16 + 2): + ext_chunk_size = struct.unpack(fmt + "H", fid.read(2))[0] + bytes_read += 2 + if ext_chunk_size >= 22: + extensible_chunk_data = fid.read(22) + bytes_read += 22 + raw_guid = extensible_chunk_data[2 + 4 : 2 + 4 + 16] + # GUID template {XXXXXXXX-0000-0010-8000-00AA00389B71} (RFC-2361) + # MS GUID byte order: first three groups are native byte order, + # rest is Big Endian + if is_big_endian: + tail = b"\x00\x00\x00\x10\x80\x00\x00\xAA\x00\x38\x9B\x71" + else: + tail = b"\x00\x00\x10\x00\x80\x00\x00\xAA\x00\x38\x9B\x71" + if raw_guid.endswith(tail): + format_tag = struct.unpack(fmt + "I", raw_guid[:4])[0] + else: + raise ValueError("Binary structure of wave file is not compliant") + + if format_tag not in KNOWN_WAVE_FORMATS: + _raise_bad_format(format_tag) + + # move file pointer to next chunk + if size > bytes_read: + fid.read(size - bytes_read) + + # fmt should always be 16, 18 or 40, but handle it just in case + _handle_pad_byte(fid, size) + + return (size, format_tag, channels, fs, bytes_per_second, block_align, bit_depth) + + +def _read_data_chunk( + fid, format_tag, channels, bit_depth, is_big_endian, block_align, mmap=False +): + """ + Notes + ----- + Assumes file pointer is immediately after the 'data' id + + It's possible to not use all available bits in a container, or to store + samples in a container bigger than necessary, so bytes_per_sample uses + the actual reported container size (nBlockAlign / nChannels). Real-world + examples: + + Adobe Audition's "24-bit packed int (type 1, 20-bit)" + + nChannels = 2, nBlockAlign = 6, wBitsPerSample = 20 + + http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Samples/AFsp/M1F1-int12-AFsp.wav + is: + + nChannels = 2, nBlockAlign = 4, wBitsPerSample = 12 + + http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/multichaudP.pdf + gives an example of: + + nChannels = 2, nBlockAlign = 8, wBitsPerSample = 20 + """ + if is_big_endian: + fmt = ">" + else: + fmt = "<" + + # Size of the data subchunk in bytes + size = struct.unpack(fmt + "I", fid.read(4))[0] + + # Number of bytes per sample (sample container size) + bytes_per_sample = block_align // channels + n_samples = size // bytes_per_sample + + if format_tag == WAVE_FORMAT.PCM: + if 1 <= bit_depth <= 8: + dtype = "u1" # WAV of 8-bit integer or less are unsigned + elif bytes_per_sample in {3, 5, 6, 7}: + # No compatible dtype. Load as raw bytes for reshaping later. + dtype = "V1" + elif bit_depth <= 64: + # Remaining bit depths can map directly to signed numpy dtypes + dtype = f"{fmt}i{bytes_per_sample}" + else: + raise ValueError( + "Unsupported bit depth: the WAV file " + f"has {bit_depth}-bit integer data." + ) + elif format_tag == WAVE_FORMAT.IEEE_FLOAT: + if bit_depth in {32, 64}: + dtype = f"{fmt}f{bytes_per_sample}" + else: + raise ValueError( + "Unsupported bit depth: the WAV file " + f"has {bit_depth}-bit floating-point data." + ) + else: + _raise_bad_format(format_tag) + + start = fid.tell() + if not mmap: + try: + count = size if dtype == "V1" else n_samples + data = numpy.fromfile(fid, dtype=dtype, count=count) + except io.UnsupportedOperation: # not a C-like file + fid.seek(start, 0) # just in case it seeked, though it shouldn't + data = numpy.frombuffer(fid.read(size), dtype=dtype) + + if dtype == "V1": + # Rearrange raw bytes into smallest compatible numpy dtype + dt = f"{fmt}i4" if bytes_per_sample == 3 else f"{fmt}i8" + a = numpy.zeros( + (len(data) // bytes_per_sample, numpy.dtype(dt).itemsize), dtype="V1" + ) + if is_big_endian: + a[:, :bytes_per_sample] = data.reshape((-1, bytes_per_sample)) + else: + a[:, -bytes_per_sample:] = data.reshape((-1, bytes_per_sample)) + data = a.view(dt).reshape(a.shape[:-1]) + else: + if bytes_per_sample in {1, 2, 4, 8}: + start = fid.tell() + data = numpy.memmap( + fid, dtype=dtype, mode="c", offset=start, shape=(n_samples,) + ) + fid.seek(start + size) + else: + raise ValueError( + "mmap=True not compatible with " + f"{bytes_per_sample}-byte container size." + ) + + _handle_pad_byte(fid, size) + + if channels > 1: + data = data.reshape(-1, channels) + return data + + +def _skip_unknown_chunk(fid, is_big_endian): + if is_big_endian: + fmt = ">I" + else: + fmt = ">> from os.path import dirname, join as pjoin + >>> from scipy.io import wavfile + >>> import scipy.io + + Get the filename for an example .wav file from the tests/data directory. + + >>> data_dir = pjoin(dirname(scipy.io.__file__), 'tests', 'data') + >>> wav_fname = pjoin(data_dir, 'test-44100Hz-2ch-32bit-float-be.wav') + + Load the .wav file contents. + + >>> samplerate, data = wavfile.read(wav_fname) + >>> print(f"number of channels = {data.shape[1]}") + number of channels = 2 + >>> length = data.shape[0] / samplerate + >>> print(f"length = {length}s") + length = 0.01s + + Plot the waveform. + + >>> import matplotlib.pyplot as plt + >>> import numpy as np + >>> time = np.linspace(0., length, data.shape[0]) + >>> plt.plot(time, data[:, 0], label="Left channel") + >>> plt.plot(time, data[:, 1], label="Right channel") + >>> plt.legend() + >>> plt.xlabel("Time [s]") + >>> plt.ylabel("Amplitude") + >>> plt.show() + + """ + if hasattr(filename, "read"): + fid = filename + mmap = False + else: + # pylint: disable=consider-using-with + fid = open(filename, "rb") + + try: + file_size, is_big_endian = _read_riff_chunk(fid) + fmt_chunk_received = False + data_chunk_received = False + while fid.tell() < file_size: + # read the next chunk + chunk_id = fid.read(4) + + if not chunk_id: + if data_chunk_received: + # End of file but data successfully read + warnings.warn( + f"Reached EOF prematurely; finished at {fid.tell()} bytes, " + "expected {file_size} bytes from header.", + WavFileWarning, + stacklevel=2, + ) + break + + raise ValueError("Unexpected end of file.") + if len(chunk_id) < 4: + msg = f"Incomplete chunk ID: {repr(chunk_id)}" + # If we have the data, ignore the broken chunk + if fmt_chunk_received and data_chunk_received: + warnings.warn(msg + ", ignoring it.", WavFileWarning, stacklevel=2) + else: + raise ValueError(msg) + + if chunk_id == b"fmt ": + fmt_chunk_received = True + fmt_chunk = _read_fmt_chunk(fid, is_big_endian) + format_tag, channels, fs = fmt_chunk[1:4] + bit_depth = fmt_chunk[6] + block_align = fmt_chunk[5] + elif chunk_id == b"fact": + _skip_unknown_chunk(fid, is_big_endian) + elif chunk_id == b"data": + data_chunk_received = True + if not fmt_chunk_received: + raise ValueError("No fmt chunk before data") + data = _read_data_chunk( + fid, + format_tag, + channels, + bit_depth, + is_big_endian, + block_align, + mmap, + ) + elif chunk_id == b"LIST": + # Someday this could be handled properly but for now skip it + _skip_unknown_chunk(fid, is_big_endian) + elif chunk_id in {b"JUNK", b"Fake"}: + # Skip alignment chunks without warning + _skip_unknown_chunk(fid, is_big_endian) + else: + warnings.warn( + "Chunk (non-data) not understood, skipping it.", + WavFileWarning, + stacklevel=2, + ) + _skip_unknown_chunk(fid, is_big_endian) + finally: + if not hasattr(filename, "read"): + fid.close() + else: + fid.seek(0) + + return fs, data + + +def write(filename, rate, data): + """ + Write a NumPy array as a WAV file. + + Parameters + ---------- + filename : string or open file handle + Output wav file. + rate : int + The sample rate (in samples/sec). + data : ndarray + A 1-D or 2-D NumPy array of either integer or float data-type. + + Notes + ----- + * Writes a simple uncompressed WAV file. + * To write multiple-channels, use a 2-D array of shape + (Nsamples, Nchannels). + * The bits-per-sample and PCM/float will be determined by the data-type. + + Common data types: [1]_ + + ===================== =========== =========== ============= + WAV format Min Max NumPy dtype + ===================== =========== =========== ============= + 32-bit floating-point -1.0 +1.0 float32 + 32-bit PCM -2147483648 +2147483647 int32 + 16-bit PCM -32768 +32767 int16 + 8-bit PCM 0 255 uint8 + ===================== =========== =========== ============= + + Note that 8-bit PCM is unsigned. + + References + ---------- + .. [1] IBM Corporation and Microsoft Corporation, "Multimedia Programming + Interface and Data Specifications 1.0", section "Data Format of the + Samples", August 1991 + http://www.tactilemedia.com/info/MCI_Control_Info.html + + Examples + -------- + Create a 100Hz sine wave, sampled at 44100Hz. + Write to 16-bit PCM, Mono. + + >>> from scipy.io.wavfile import write + >>> samplerate = 44100; fs = 100 + >>> t = np.linspace(0., 1., samplerate) + >>> amplitude = np.iinfo(np.int16).max + >>> data = amplitude * np.sin(2. * np.pi * fs * t) + >>> write("example.wav", samplerate, data.astype(np.int16)) + + """ + if hasattr(filename, "write"): + fid = filename + else: + # pylint: disable=consider-using-with + fid = open(filename, "wb") + + fs = rate + + try: + dkind = data.dtype.kind + if not ( + dkind == "i" or dkind == "f" or (dkind == "u" and data.dtype.itemsize == 1) + ): + raise ValueError(f"Unsupported data type '{data.dtype}'") + + header_data = b"" + + header_data += b"RIFF" + header_data += b"\x00\x00\x00\x00" + header_data += b"WAVE" + + # fmt chunk + header_data += b"fmt " + if dkind == "f": + format_tag = WAVE_FORMAT.IEEE_FLOAT + else: + format_tag = WAVE_FORMAT.PCM + if data.ndim == 1: + channels = 1 + else: + channels = data.shape[1] + bit_depth = data.dtype.itemsize * 8 + bytes_per_second = fs * (bit_depth // 8) * channels + block_align = channels * (bit_depth // 8) + + fmt_chunk_data = struct.pack( + " 0xFFFFFFFF: + raise ValueError("Data exceeds wave file size limit") + + fid.write(header_data) + + # data chunk + fid.write(b"data") + fid.write(struct.pack("" or ( + data.dtype.byteorder == "=" and sys.byteorder == "big" + ): + data = data.byteswap() + _array_tofile(fid, data) + + # Determine file size and place it in correct + # position at start of the file. + size = fid.tell() + fid.seek(4) + fid.write(struct.pack("=0.29.0,<1 +espeak-phonemizer>=1.1.0,<2 +librosa>=0.9.2,<1 +numpy>=1.19.0 +onnxruntime~=1.11.0 +pytorch-lightning~=1.7.0 +torch~=1.11.0 diff --git a/src/python/requirements_dev.txt b/src/python/requirements_dev.txt new file mode 100644 index 0000000..3401b9b --- /dev/null +++ b/src/python/requirements_dev.txt @@ -0,0 +1,7 @@ +black==22.3.0 +coverage==5.0.4 +flake8==3.7.9 +mypy==0.910 +pylint==2.10.2 +pytest==5.4.1 +pytest-cov==2.8.1 diff --git a/src/python/scripts/check.sh b/src/python/scripts/check.sh new file mode 100755 index 0000000..d8414c5 --- /dev/null +++ b/src/python/scripts/check.sh @@ -0,0 +1,29 @@ +#!/usr/bin/env bash + +# Runs formatters, linters, and type checkers on Python code. + +set -eo pipefail + +# Directory of *this* script +this_dir="$( cd "$( dirname "$0" )" && pwd )" + +base_dir="$(realpath "${this_dir}/..")" + +# Path to virtual environment +: "${venv:=${base_dir}/.venv}" + +if [ -d "${venv}" ]; then + # Activate virtual environment if available + source "${venv}/bin/activate" +fi + +python_files=("${base_dir}/larynx_train") + +# Format code +black "${python_files[@]}" +isort "${python_files[@]}" + +# Check +flake8 "${python_files[@]}" +pylint "${python_files[@]}" +mypy "${python_files[@]}" diff --git a/src/python/setup.py b/src/python/setup.py new file mode 100644 index 0000000..4c7260b --- /dev/null +++ b/src/python/setup.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python3 +from collections import defaultdict +from pathlib import Path + +import setuptools +from setuptools import setup + +this_dir = Path(__file__).parent +module_dir = this_dir / "larynx_train" + +# ----------------------------------------------------------------------------- + +# Load README in as long description +long_description: str = "" +readme_path = this_dir / "README.md" +if readme_path.is_file(): + long_description = readme_path.read_text(encoding="utf-8") + +requirements = [] +requirements_path = this_dir / "requirements.txt" +if requirements_path.is_file(): + with open(requirements_path, "r", encoding="utf-8") as requirements_file: + requirements = requirements_file.read().splitlines() + +version_path = module_dir / "VERSION" +with open(version_path, "r", encoding="utf-8") as version_file: + version = version_file.read().strip() + +# ----------------------------------------------------------------------------- + +setup( + name="larynx_train", + version=version, + description="A fast and local neural text to speech system", + long_description=long_description, + url="http://github.com/rhasspy/larynx", + author="Michael Hansen", + author_email="mike@rhasspy.org", + license="MIT", + packages=setuptools.find_packages(), + package_data={ + "larynx_train": ["VERSION", "py.typed"], + }, + install_requires=requirements, + extras_require={':python_version<"3.9"': ["importlib_resources"]}, + entry_points={ + "console_scripts": [ + "larynx-train = larynx_train.__main__:main", + ] + }, + classifiers=[ + "Development Status :: 3 - Alpha", + "Intended Audience :: Developers", + "Topic :: Text Processing :: Linguistic", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + ], + keywords="rhasspy tts speech voice", +)