From 57b830b637474f59bb62d385f5b445c7f4353300 Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sat, 23 Dec 2023 14:17:49 +0800 Subject: [PATCH 01/16] =?UTF-8?q?=E5=8A=A0=E5=85=A5VITS=E6=A8=A1=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/__init__.py | 0 talkingface/data/dataprocess/vits_porcess.py | 24 + talkingface/data/dataset/vits_dataset.py | 251 + talkingface/evaluator/__init__.py | 3 +- talkingface/evaluator/metrics_vits.py | 58 + .../audio_driven_talkingface/model_vits.py | 1329 + .../properties/dataset/LJSpeech_vits.yaml | 14 + talkingface/properties/model/VITS.yaml | 16 + talkingface/properties/overall_vits.yaml | 17 + talkingface/trainer/trainer.py | 13 +- talkingface/utils/vits_utils/__init__.py | 0 talkingface/utils/vits_utils/commons.py | 159 + .../utils/vits_utils/mel_processing.py | 112 + .../vits_utils/monotonic_align/__init__.py | 19 + .../utils/vits_utils/monotonic_align/core.c | 21299 ++++++++++++++++ .../utils/vits_utils/monotonic_align/core.pyx | 42 + .../utils/vits_utils/monotonic_align/setup.py | 9 + talkingface/utils/vits_utils/text/LICENSE | 19 + talkingface/utils/vits_utils/text/__init__.py | 56 + .../utils/vits_utils/text/cantonese.py | 59 + talkingface/utils/vits_utils/text/cleaners.py | 128 + talkingface/utils/vits_utils/text/english.py | 188 + talkingface/utils/vits_utils/text/japanese.py | 153 + talkingface/utils/vits_utils/text/korean.py | 210 + talkingface/utils/vits_utils/text/mandarin.py | 326 + .../utils/vits_utils/text/ngu_dialect.py | 30 + talkingface/utils/vits_utils/text/sanskrit.py | 62 + .../utils/vits_utils/text/shanghainese.py | 64 + talkingface/utils/vits_utils/text/symbols.py | 75 + talkingface/utils/vits_utils/text/thai.py | 44 + talkingface/utils/vits_utils/transforms.py | 193 + talkingface/utils/vits_utils/utils.py | 258 + 32 files changed, 25228 insertions(+), 2 deletions(-) create mode 100644 talkingface/__init__.py create mode 100644 talkingface/data/dataprocess/vits_porcess.py create mode 100644 talkingface/data/dataset/vits_dataset.py create mode 100644 talkingface/evaluator/metrics_vits.py create mode 100644 talkingface/model/audio_driven_talkingface/model_vits.py create mode 100644 talkingface/properties/dataset/LJSpeech_vits.yaml create mode 100644 talkingface/properties/model/VITS.yaml create mode 100644 talkingface/properties/overall_vits.yaml create mode 100644 talkingface/utils/vits_utils/__init__.py create mode 100644 talkingface/utils/vits_utils/commons.py create mode 100644 talkingface/utils/vits_utils/mel_processing.py create mode 100644 talkingface/utils/vits_utils/monotonic_align/__init__.py create mode 100644 talkingface/utils/vits_utils/monotonic_align/core.c create mode 100644 talkingface/utils/vits_utils/monotonic_align/core.pyx create mode 100644 talkingface/utils/vits_utils/monotonic_align/setup.py create mode 100644 talkingface/utils/vits_utils/text/LICENSE create mode 100644 talkingface/utils/vits_utils/text/__init__.py create mode 100644 talkingface/utils/vits_utils/text/cantonese.py create mode 100644 talkingface/utils/vits_utils/text/cleaners.py create mode 100644 talkingface/utils/vits_utils/text/english.py create mode 100644 talkingface/utils/vits_utils/text/japanese.py create mode 100644 talkingface/utils/vits_utils/text/korean.py create mode 100644 talkingface/utils/vits_utils/text/mandarin.py create mode 100644 talkingface/utils/vits_utils/text/ngu_dialect.py create mode 100644 talkingface/utils/vits_utils/text/sanskrit.py create mode 100644 talkingface/utils/vits_utils/text/shanghainese.py create mode 100644 talkingface/utils/vits_utils/text/symbols.py create mode 100644 talkingface/utils/vits_utils/text/thai.py create mode 100644 talkingface/utils/vits_utils/transforms.py create mode 100644 talkingface/utils/vits_utils/utils.py diff --git a/talkingface/__init__.py b/talkingface/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/talkingface/data/dataprocess/vits_porcess.py b/talkingface/data/dataprocess/vits_porcess.py new file mode 100644 index 00000000..51a3d5d9 --- /dev/null +++ b/talkingface/data/dataprocess/vits_porcess.py @@ -0,0 +1,24 @@ +import argparse +from talkingface.utils.vits_utils import text +from talkingface.utils.vits_utils.utils import load_filepaths_and_text + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("--out_extension", default="cleaned") + parser.add_argument("--text_index", default=1, type=int) + parser.add_argument("--filelists", nargs="+", default=["filelists/list.txt", "filelists/list_val.txt"]) + parser.add_argument("--text_cleaners", nargs="+", default=["cjke_cleaners2"]) + + args = parser.parse_args() + + for filelist in args.filelists: + print("START:", filelist) + filepaths_and_text = load_filepaths_and_text(filelist) + for i in range(len(filepaths_and_text)): + original_text = filepaths_and_text[i][args.text_index] + cleaned_text = text._clean_text(original_text, args.text_cleaners) + filepaths_and_text[i][args.text_index] = cleaned_text + + new_filelist = filelist + "." + args.out_extension + with open(new_filelist, "w", encoding="utf-8") as f: + f.writelines(["|".join(x) + "\n" for x in filepaths_and_text]) diff --git a/talkingface/data/dataset/vits_dataset.py b/talkingface/data/dataset/vits_dataset.py new file mode 100644 index 00000000..03cb6a7a --- /dev/null +++ b/talkingface/data/dataset/vits_dataset.py @@ -0,0 +1,251 @@ +import time +import os +import random +import numpy as np +import torch +import torch.utils.data + +from talkingface.data.dataset.dataset import Dataset +from talkingface.utils.vits_utils import commons +from talkingface.utils.vits_utils.mel_processing import spectrogram_torch +from talkingface.utils.vits_utils.utils import load_wav_to_torch, load_filepaths_and_text +from talkingface.utils.vits_utils.text import text_to_sequence, cleaned_text_to_sequence + + +class TextAudioLoader(Dataset): + """ + 1) loads audio, text pairs + 2) normalizes text and converts them to sequences of integers + 3) computes spectrograms from audio files. + """ + + def __init__(self, config, datasplit, audiopaths_and_text, hparams): + super().__init__(config, datasplit) + self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text) + self.text_cleaners = hparams.text_cleaners + self.max_wav_value = hparams.max_wav_value + self.sampling_rate = hparams.sampling_rate + self.filter_length = hparams.filter_length + self.hop_length = hparams.hop_length + self.win_length = hparams.win_length + self.sampling_rate = hparams.sampling_rate + + self.cleaned_text = getattr(hparams, "cleaned_text", False) + + self.add_blank = hparams.add_blank + self.min_text_len = getattr(hparams, "min_text_len", 1) + self.max_text_len = getattr(hparams, "max_text_len", 190) + + random.seed(1234) + random.shuffle(self.audiopaths_and_text) + self._filter() + + def _filter(self): + """ + Filter text & store spec lengths + """ + # Store spectrogram lengths for Bucketing + # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2) + # spec_length = wav_length // hop_length + + audiopaths_and_text_new = [] + lengths = [] + for audiopath, text in self.audiopaths_and_text: + if self.min_text_len <= len(text) and len(text) <= self.max_text_len: + audiopaths_and_text_new.append([audiopath, text]) + lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length)) + self.audiopaths_and_text = audiopaths_and_text_new + self.lengths = lengths + + def get_audio_text_pair(self, audiopath_and_text): + # separate filename and text + audiopath, text = audiopath_and_text[0], audiopath_and_text[1] + text = self.get_text(text) + spec, wav = self.get_audio(audiopath) + return {"text": text, "spec": spec, "wav": wav} + + def get_audio(self, filename): + audio, sampling_rate = load_wav_to_torch(filename) + if sampling_rate != self.sampling_rate: + raise ValueError("{} {} SR doesn't match target {} SR".format( + sampling_rate, self.sampling_rate)) + audio_norm = audio / self.max_wav_value + audio_norm = audio_norm.unsqueeze(0) + spec_filename = filename.replace(".wav", ".spec.pt") + if os.path.exists(spec_filename): + spec = torch.load(spec_filename) + else: + spec = spectrogram_torch(audio_norm, self.filter_length, + self.sampling_rate, self.hop_length, self.win_length, + center=False) + spec = torch.squeeze(spec, 0) + torch.save(spec, spec_filename) + return spec, audio_norm + + def get_text(self, text): + if self.cleaned_text: + text_norm = cleaned_text_to_sequence(text) + else: + text_norm = text_to_sequence(text, self.text_cleaners) + if self.add_blank: + text_norm = commons.intersperse(text_norm, 0) + text_norm = torch.LongTensor(text_norm) + return text_norm + + def __getitem__(self, index): + return self.get_audio_text_pair(self.audiopaths_and_text[index]) + + def __len__(self): + return len(self.audiopaths_and_text) + + +class TextAudioCollate(): + """ Zero-pads model inputs and targets + """ + + def __init__(self, return_ids=False): + self.return_ids = return_ids + + def __call__(self, batch): + """Collate's training batch from normalized text and aduio + PARAMS + ------ + batch: [text_normalized, spec_normalized, wav_normalized] + """ + # Right zero-pad all one-hot text sequences to max input length + _, ids_sorted_decreasing = torch.sort( + torch.LongTensor([x[1].size(1) for x in batch]), + dim=0, descending=True) + + max_text_len = max([len(x[0]) for x in batch]) + max_spec_len = max([x[1].size(1) for x in batch]) + max_wav_len = max([x[2].size(1) for x in batch]) + + text_lengths = torch.LongTensor(len(batch)) + spec_lengths = torch.LongTensor(len(batch)) + wav_lengths = torch.LongTensor(len(batch)) + + text_padded = torch.LongTensor(len(batch), max_text_len) + spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len) + wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len) + text_padded.zero_() + spec_padded.zero_() + wav_padded.zero_() + for i in range(len(ids_sorted_decreasing)): + row = batch[ids_sorted_decreasing[i]] + + text = row[0] + text_padded[i, :text.size(0)] = text + text_lengths[i] = text.size(0) + + spec = row[1] + spec_padded[i, :, :spec.size(1)] = spec + spec_lengths[i] = spec.size(1) + + wav = row[2] + wav_padded[i, :, :wav.size(1)] = wav + wav_lengths[i] = wav.size(1) + + if self.return_ids: + return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, ids_sorted_decreasing + return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths + + +class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler): + """ + Maintain similar input lengths in a batch. + Length groups are specified by boundaries. + Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}. + + It removes samples which are not included in the boundaries. + Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded. + """ + + def __init__(self, dataset, batch_size, boundaries, num_replicas=None, rank=None, shuffle=True): + super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle) + self.lengths = dataset.lengths + self.batch_size = batch_size + self.boundaries = boundaries + + self.buckets, self.num_samples_per_bucket = self._create_buckets() + self.total_size = sum(self.num_samples_per_bucket) + self.num_samples = self.total_size // self.num_replicas + + def _create_buckets(self): + buckets = [[] for _ in range(len(self.boundaries) - 1)] + for i in range(len(self.lengths)): + length = self.lengths[i] + idx_bucket = self._bisect(length) + if idx_bucket != -1: + buckets[idx_bucket].append(i) + + for i in range(len(buckets) - 1, -1, -1): + if len(buckets[i]) == 0: + buckets.pop(i) + self.boundaries.pop(i + 1) + + num_samples_per_bucket = [] + for i in range(len(buckets)): + len_bucket = len(buckets[i]) + total_batch_size = self.num_replicas * self.batch_size + rem = (total_batch_size - (len_bucket % total_batch_size)) % total_batch_size + num_samples_per_bucket.append(len_bucket + rem) + return buckets, num_samples_per_bucket + + def __iter__(self): + # deterministically shuffle based on epoch + g = torch.Generator() + g.manual_seed(self.epoch) + + indices = [] + if self.shuffle: + for bucket in self.buckets: + indices.append(torch.randperm(len(bucket), generator=g).tolist()) + else: + for bucket in self.buckets: + indices.append(list(range(len(bucket)))) + + batches = [] + for i in range(len(self.buckets)): + bucket = self.buckets[i] + len_bucket = len(bucket) + ids_bucket = indices[i] + num_samples_bucket = self.num_samples_per_bucket[i] + + # add extra samples to make it evenly divisible + rem = num_samples_bucket - len_bucket + ids_bucket = ids_bucket + ids_bucket * (rem // len_bucket) + ids_bucket[:(rem % len_bucket)] + + # subsample + ids_bucket = ids_bucket[self.rank::self.num_replicas] + + # batching + for j in range(len(ids_bucket) // self.batch_size): + batch = [bucket[idx] for idx in ids_bucket[j * self.batch_size:(j + 1) * self.batch_size]] + batches.append(batch) + + if self.shuffle: + batch_ids = torch.randperm(len(batches), generator=g).tolist() + batches = [batches[i] for i in batch_ids] + self.batches = batches + + assert len(self.batches) * self.batch_size == self.num_samples + return iter(self.batches) + + def _bisect(self, x, lo=0, hi=None): + if hi is None: + hi = len(self.boundaries) - 1 + + if hi > lo: + mid = (hi + lo) // 2 + if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]: + return mid + elif x <= self.boundaries[mid]: + return self._bisect(x, lo, mid) + else: + return self._bisect(x, mid + 1, hi) + else: + return -1 + + def __len__(self): + return self.num_samples // self.batch_size diff --git a/talkingface/evaluator/__init__.py b/talkingface/evaluator/__init__.py index d5eeefda..142c482b 100644 --- a/talkingface/evaluator/__init__.py +++ b/talkingface/evaluator/__init__.py @@ -1,4 +1,5 @@ from talkingface.evaluator.metric_models import * from talkingface.evaluator.metrics import * +from talkingface.evaluator.metrics_vits import * from talkingface.evaluator.register import * -from talkingface.evaluator.evaluator import * \ No newline at end of file +from talkingface.evaluator.evaluator import * diff --git a/talkingface/evaluator/metrics_vits.py b/talkingface/evaluator/metrics_vits.py new file mode 100644 index 00000000..0b5816eb --- /dev/null +++ b/talkingface/evaluator/metrics_vits.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 = torch.mean((1-dg)**2) + gen_losses.append(l) + loss += l + + return loss, gen_losses + + +def kl_loss(z_p, logs_q, m_p, logs_p, z_mask): + """ + z_p, logs_q: [b, h, t_t] + m_p, logs_p: [b, h, t_t] + """ + z_p = z_p.float() + logs_q = logs_q.float() + m_p = m_p.float() + logs_p = logs_p.float() + z_mask = z_mask.float() + + kl = logs_p - logs_q - 0.5 + kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p) + kl = torch.sum(kl * z_mask) + l = kl / torch.sum(z_mask) + return l diff --git a/talkingface/model/audio_driven_talkingface/model_vits.py b/talkingface/model/audio_driven_talkingface/model_vits.py new file mode 100644 index 00000000..9c67f5c4 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/model_vits.py @@ -0,0 +1,1329 @@ +""" +################################### +####### 原仓库models.py的代码 ####### +################################### + +下面还有原仓库modules.py的代码和attentions.py的代码 +不过import导入包中的互相引用部分已经优化 +""" +import copy +import math +import torch +from torch import nn +from torch.nn import functional as F + +from talkingface.utils.vits_utils import commons +from talkingface.utils.vits_utils import monotonic_align + +from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d +from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm + +from talkingface.utils.vits_utils.commons import init_weights, get_padding +from talkingface.utils.vits_utils.transforms import piecewise_rational_quadratic_transform +from talkingface.model.abstract_talkingface import AbstractTalkingFace + + +class StochasticDurationPredictor(nn.Module): + def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0): + super().__init__() + filter_channels = in_channels # it needs to be removed from future version. + self.in_channels = in_channels + self.filter_channels = filter_channels + self.kernel_size = kernel_size + self.p_dropout = p_dropout + self.n_flows = n_flows + self.gin_channels = gin_channels + + self.log_flow = Log() + self.flows = nn.ModuleList() + self.flows.append(ElementwiseAffine(2)) + for i in range(n_flows): + self.flows.append(ConvFlow(2, filter_channels, kernel_size, n_layers=3)) + self.flows.append(Flip()) + + self.post_pre = nn.Conv1d(1, filter_channels, 1) + self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1) + self.post_convs = DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout) + self.post_flows = nn.ModuleList() + self.post_flows.append(ElementwiseAffine(2)) + for i in range(4): + self.post_flows.append(ConvFlow(2, filter_channels, kernel_size, n_layers=3)) + self.post_flows.append(Flip()) + + self.pre = nn.Conv1d(in_channels, filter_channels, 1) + self.proj = nn.Conv1d(filter_channels, filter_channels, 1) + self.convs = DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout) + if gin_channels != 0: + self.cond = nn.Conv1d(gin_channels, filter_channels, 1) + + def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0): + x = torch.detach(x) + x = self.pre(x) + if g is not None: + g = torch.detach(g) + x = x + self.cond(g) + x = self.convs(x, x_mask) + x = self.proj(x) * x_mask + + if not reverse: + flows = self.flows + assert w is not None + + logdet_tot_q = 0 + h_w = self.post_pre(w) + h_w = self.post_convs(h_w, x_mask) + h_w = self.post_proj(h_w) * x_mask + e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask + z_q = e_q + for flow in self.post_flows: + z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w)) + logdet_tot_q += logdet_q + z_u, z1 = torch.split(z_q, [1, 1], 1) + u = torch.sigmoid(z_u) * x_mask + z0 = (w - u) * x_mask + logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1, 2]) + logq = torch.sum(-0.5 * (math.log(2 * math.pi) + (e_q ** 2)) * x_mask, [1, 2]) - logdet_tot_q + + logdet_tot = 0 + z0, logdet = self.log_flow(z0, x_mask) + logdet_tot += logdet + z = torch.cat([z0, z1], 1) + for flow in flows: + z, logdet = flow(z, x_mask, g=x, reverse=reverse) + logdet_tot = logdet_tot + logdet + nll = torch.sum(0.5 * (math.log(2 * math.pi) + (z ** 2)) * x_mask, [1, 2]) - logdet_tot + return nll + logq # [b] + else: + flows = list(reversed(self.flows)) + flows = flows[:-2] + [flows[-1]] # remove a useless vflow + z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale + for flow in flows: + z = flow(z, x_mask, g=x, reverse=reverse) + z0, z1 = torch.split(z, [1, 1], 1) + logw = z0 + return logw + + +class DurationPredictor(nn.Module): + def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0): + super().__init__() + + self.in_channels = in_channels + self.filter_channels = filter_channels + self.kernel_size = kernel_size + self.p_dropout = p_dropout + self.gin_channels = gin_channels + + self.drop = nn.Dropout(p_dropout) + self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size // 2) + self.norm_1 = LayerNorm(filter_channels) + self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size // 2) + self.norm_2 = LayerNorm(filter_channels) + self.proj = nn.Conv1d(filter_channels, 1, 1) + + if gin_channels != 0: + self.cond = nn.Conv1d(gin_channels, in_channels, 1) + + def forward(self, x, x_mask, g=None): + x = torch.detach(x) + if g is not None: + g = torch.detach(g) + x = x + self.cond(g) + x = self.conv_1(x * x_mask) + x = torch.relu(x) + x = self.norm_1(x) + x = self.drop(x) + x = self.conv_2(x * x_mask) + x = torch.relu(x) + x = self.norm_2(x) + x = self.drop(x) + x = self.proj(x * x_mask) + return x * x_mask + + +class TextEncoder(nn.Module): + def __init__(self, + n_vocab, + out_channels, + hidden_channels, + filter_channels, + n_heads, + n_layers, + kernel_size, + p_dropout): + 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 = 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).to(x.dtype) + + 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, + hidden_channels, + kernel_size, + dilation_rate, + n_layers, + n_flows=4, + gin_channels=0): + super().__init__() + self.channels = channels + self.hidden_channels = hidden_channels + self.kernel_size = kernel_size + self.dilation_rate = dilation_rate + self.n_layers = n_layers + self.n_flows = n_flows + self.gin_channels = gin_channels + + self.flows = nn.ModuleList() + for i in range(n_flows): + self.flows.append( + ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, + gin_channels=gin_channels, mean_only=True)) + self.flows.append(Flip()) + + def forward(self, x, x_mask, g=None, reverse=False): + if not reverse: + for flow in self.flows: + x, _ = flow(x, x_mask, g=g, reverse=reverse) + else: + for flow in reversed(self.flows): + x = flow(x, x_mask, g=g, reverse=reverse) + return x + + +class PosteriorEncoder(nn.Module): + def __init__(self, + in_channels, + out_channels, + hidden_channels, + kernel_size, + dilation_rate, + n_layers, + gin_channels=0): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.hidden_channels = hidden_channels + self.kernel_size = kernel_size + self.dilation_rate = dilation_rate + self.n_layers = n_layers + self.gin_channels = gin_channels + + self.pre = nn.Conv1d(in_channels, hidden_channels, 1) + self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels) + self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1) + + def forward(self, x, x_lengths, g=None): + x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype) + x = self.pre(x) * x_mask + x = self.enc(x, x_mask, g=g) + stats = self.proj(x) * x_mask + m, logs = torch.split(stats, self.out_channels, dim=1) + z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask + return z, m, logs, x_mask + + +class Generator(torch.nn.Module): + def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, + upsample_initial_channel, upsample_kernel_sizes, gin_channels=0): + super(Generator, self).__init__() + self.num_kernels = len(resblock_kernel_sizes) + self.num_upsamples = len(upsample_rates) + self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3) + resblock = ResBlock1 if resblock == '1' else ResBlock2 + + self.ups = nn.ModuleList() + for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)): + self.ups.append(weight_norm( + ConvTranspose1d(upsample_initial_channel // (2 ** i), upsample_initial_channel // (2 ** (i + 1)), + k, u, padding=(k - u) // 2))) + + self.resblocks = nn.ModuleList() + for i in range(len(self.ups)): + ch = upsample_initial_channel // (2 ** (i + 1)) + for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)): + self.resblocks.append(resblock(ch, k, d)) + + self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False) + self.ups.apply(init_weights) + + if gin_channels != 0: + self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1) + + def forward(self, x, g=None): + x = self.conv_pre(x) + if g is not None: + x = x + self.cond(g) + + for i in range(self.num_upsamples): + x = F.leaky_relu(x, LRELU_SLOPE) + x = self.ups[i](x) + xs = None + for j in range(self.num_kernels): + if xs is None: + xs = self.resblocks[i * self.num_kernels + j](x) + else: + xs += self.resblocks[i * self.num_kernels + j](x) + x = xs / self.num_kernels + x = F.leaky_relu(x) + x = self.conv_post(x) + x = torch.tanh(x) + + return x + + def remove_weight_norm(self): + print('Removing weight norm...') + for l in self.ups: + remove_weight_norm(l) + for l in self.resblocks: + l.remove_weight_norm() + + +class DiscriminatorP(torch.nn.Module): + def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False): + super(DiscriminatorP, self).__init__() + self.period = period + self.use_spectral_norm = use_spectral_norm + norm_f = weight_norm if use_spectral_norm == False else spectral_norm + self.convs = nn.ModuleList([ + norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), + norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), + norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), + norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), + norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))), + ]) + self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0))) + + def forward(self, x): + fmap = [] + + # 1d to 2d + b, c, t = x.shape + if t % self.period != 0: # pad first + n_pad = self.period - (t % self.period) + x = F.pad(x, (0, n_pad), "reflect") + t = t + n_pad + x = x.view(b, c, t // self.period, self.period) + + for l in self.convs: + x = l(x) + x = F.leaky_relu(x, LRELU_SLOPE) + fmap.append(x) + x = self.conv_post(x) + fmap.append(x) + x = torch.flatten(x, 1, -1) + + return x, fmap + + +class DiscriminatorS(torch.nn.Module): + def __init__(self, use_spectral_norm=False): + super(DiscriminatorS, self).__init__() + norm_f = weight_norm if use_spectral_norm == False else spectral_norm + self.convs = nn.ModuleList([ + norm_f(Conv1d(1, 16, 15, 1, padding=7)), + norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)), + norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)), + norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)), + norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)), + norm_f(Conv1d(1024, 1024, 5, 1, padding=2)), + ]) + self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1)) + + def forward(self, x): + fmap = [] + + for l in self.convs: + x = l(x) + x = F.leaky_relu(x, LRELU_SLOPE) + fmap.append(x) + x = self.conv_post(x) + fmap.append(x) + x = torch.flatten(x, 1, -1) + + return x, fmap + + +class MultiPeriodDiscriminator(AbstractTalkingFace): + """ + vits的decoder + """ + 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 + + def predict(self, interaction): + """ + 进行一次预输入的interaction应当是一个字典，具体格式如下： + interaction = { + "y": y, + "y_hat": y_hat, + } + Args: + interaction: + + Returns: y_d_rs, y_d_gs, fmap_rs, fmap_gs + + """ + return self.forward(**interaction) + + def calculate_loss(self, interaction): + """ + Calculate the training loss for a batch data. + Args: + interaction: interaction在此处应该是一个元组，里面是self.forward里面的前两个返回值(y_d_rs, y_d_gs) + + Returns: {"loss": loss, "r_losses": r_losses, "g_losses": g_losses} + + """ + from talkingface.evaluator.metrics_vits import discriminator_loss + + y_d_hat_r, y_d_hat_g = interaction + loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g) + return {"loss": loss_disc, "r_losses": losses_disc_r, "g_losses": losses_disc_g} + + def generate_batch(self): + pass + + +class SynthesizerTrn(AbstractTalkingFace): + """ + Synthesizer for Training + + vits的生成器 + """ + + def __init__(self, + n_vocab, + spec_channels, + segment_size, + inter_channels, + hidden_channels, + filter_channels, + n_heads, + n_layers, + kernel_size, + p_dropout, + resblock, + resblock_kernel_sizes, + resblock_dilation_sizes, + upsample_rates, + upsample_initial_channel, + upsample_kernel_sizes, + n_speakers=0, + gin_channels=0, + use_sdp=True, + **kwargs): + + super(SynthesizerTrn, self).__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 > 0: + 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 predict(self, interaction): + """ + 进行一次预输入的interaction应当是一个字典，具体格式如下： + interaction = { + "x": x, + "x_length": x_length, + } + Args: + interaction: + + Returns: o, attn, y_mask, (z, z_p, m_p, logs_p) + + """ + return self.infer(**interaction) + + def calculate_loss(self, interaction, valid=False): + """ + Calculate the training loss for a batch data. + interaction参数里面的结构是： + (hps, (y_mel, y_hat_mel), \ + (y_d_hat_r, y_d_hat_g, fmap_r, fmap_g), \ + (l_length, z_mask, (z, z_p, m_p, logs_p, m_q, logs_q))) + Args: + interaction: 一个元组 + valid: 是否是valid + + Returns: {"loss": loss_gen_all, "loss_gen": loss_gen, "loss_fm": loss_fm, + "loss_mel": loss_mel, "loss_dur": loss_dur, "loss_kl": loss_kl} + + """ + from talkingface.evaluator.metrics_vits import kl_loss, feature_loss, generator_loss + + hps, (y_mel, y_hat_mel), \ + (y_d_hat_r, y_d_hat_g, fmap_r, fmap_g), \ + (l_length, z_mask, (z, z_p, m_p, logs_p, m_q, logs_q)) = interaction + loss_dur = torch.sum(l_length.float()) + loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel + loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.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 + return {"loss": loss_gen_all, "loss_gen": loss_gen, "loss_fm": loss_fm, + "loss_mel": loss_mel, "loss_dur": loss_dur, "loss_kl": loss_kl} + + def generate_batch(self): + pass + + def infer(self, x, x_lengths, sid=None, noise_scale=1, length_scale=1, noise_scale_w=1., max_len=None): + x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths) + if self.n_speakers > 0: + 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, None), 1).to(x_mask.dtype) + attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1) + attn = commons.generate_path(w_ceil, attn_mask) + + m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t'] + logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, + 2) # [b, t', t], [b, t, d] -> [b, d, t'] + + z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale + z = self.flow(z_p, y_mask, g=g, reverse=True) + o = self.dec((z * y_mask)[:, :, :max_len], g=g) + return o, attn, y_mask, (z, z_p, m_p, logs_p) + + def voice_conversion(self, y, y_lengths, sid_src, sid_tgt): + assert self.n_speakers > 0, "n_speakers have to be larger than 0." + 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) + + +""" +################################### +###### 原仓库modules.py的代码 ####### +################################### +""" + + +LRELU_SLOPE = 0.1 + + +class LayerNorm(nn.Module): + def __init__(self, channels, eps=1e-5): + super().__init__() + self.channels = channels + self.eps = eps + + self.gamma = nn.Parameter(torch.ones(channels)) + self.beta = nn.Parameter(torch.zeros(channels)) + + def forward(self, x): + x = x.transpose(1, -1) + x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps) + return x.transpose(1, -1) + + +class ConvReluNorm(nn.Module): + def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout): + super().__init__() + self.in_channels = in_channels + self.hidden_channels = hidden_channels + self.out_channels = out_channels + self.kernel_size = kernel_size + self.n_layers = n_layers + self.p_dropout = p_dropout + assert n_layers > 1, "Number of layers should be larger than 0." + + self.conv_layers = nn.ModuleList() + self.norm_layers = nn.ModuleList() + self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size // 2)) + self.norm_layers.append(LayerNorm(hidden_channels)) + self.relu_drop = nn.Sequential( + nn.ReLU(), + nn.Dropout(p_dropout)) + for _ in range(n_layers - 1): + self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size // 2)) + self.norm_layers.append(LayerNorm(hidden_channels)) + self.proj = nn.Conv1d(hidden_channels, out_channels, 1) + self.proj.weight.data.zero_() + self.proj.bias.data.zero_() + + def forward(self, x, x_mask): + x_org = x + for i in range(self.n_layers): + x = self.conv_layers[i](x * x_mask) + x = self.norm_layers[i](x) + x = self.relu_drop(x) + x = x_org + self.proj(x) + return x * x_mask + + +class DDSConv(nn.Module): + """ + Dialted and Depth-Separable Convolution + """ + + def __init__(self, channels, kernel_size, n_layers, p_dropout=0.): + super().__init__() + self.channels = channels + self.kernel_size = kernel_size + self.n_layers = n_layers + self.p_dropout = p_dropout + + self.drop = nn.Dropout(p_dropout) + self.convs_sep = nn.ModuleList() + self.convs_1x1 = nn.ModuleList() + self.norms_1 = nn.ModuleList() + self.norms_2 = nn.ModuleList() + for i in range(n_layers): + dilation = kernel_size ** i + padding = (kernel_size * dilation - dilation) // 2 + self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size, + groups=channels, dilation=dilation, padding=padding + )) + self.convs_1x1.append(nn.Conv1d(channels, channels, 1)) + self.norms_1.append(LayerNorm(channels)) + self.norms_2.append(LayerNorm(channels)) + + def forward(self, x, x_mask, g=None): + if g is not None: + x = x + g + for i in range(self.n_layers): + y = self.convs_sep[i](x * x_mask) + y = self.norms_1[i](y) + y = F.gelu(y) + y = self.convs_1x1[i](y) + y = self.norms_2[i](y) + y = F.gelu(y) + y = self.drop(y) + x = x + y + return x * x_mask + + +class WN(torch.nn.Module): + def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0): + super(WN, self).__init__() + assert (kernel_size % 2 == 1) + self.hidden_channels = hidden_channels + self.kernel_size = kernel_size, + self.dilation_rate = dilation_rate + self.n_layers = n_layers + self.gin_channels = gin_channels + self.p_dropout = p_dropout + + self.in_layers = torch.nn.ModuleList() + self.res_skip_layers = torch.nn.ModuleList() + self.drop = nn.Dropout(p_dropout) + + if gin_channels != 0: + cond_layer = torch.nn.Conv1d(gin_channels, 2 * hidden_channels * n_layers, 1) + self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight') + + for i in range(n_layers): + dilation = dilation_rate ** i + padding = int((kernel_size * dilation - dilation) / 2) + in_layer = torch.nn.Conv1d(hidden_channels, 2 * hidden_channels, kernel_size, + dilation=dilation, padding=padding) + in_layer = torch.nn.utils.weight_norm(in_layer, name='weight') + self.in_layers.append(in_layer) + + # last one is not necessary + if i < n_layers - 1: + res_skip_channels = 2 * hidden_channels + else: + res_skip_channels = hidden_channels + + res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1) + res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight') + self.res_skip_layers.append(res_skip_layer) + + def forward(self, x, x_mask, g=None, **kwargs): + output = torch.zeros_like(x) + n_channels_tensor = torch.IntTensor([self.hidden_channels]) + + if g is not None: + g = self.cond_layer(g) + + for i in range(self.n_layers): + x_in = self.in_layers[i](x) + if g is not None: + cond_offset = i * 2 * self.hidden_channels + g_l = g[:, cond_offset:cond_offset + 2 * self.hidden_channels, :] + else: + g_l = torch.zeros_like(x_in) + + acts = commons.fused_add_tanh_sigmoid_multiply( + x_in, + g_l, + n_channels_tensor) + acts = self.drop(acts) + + res_skip_acts = self.res_skip_layers[i](acts) + if i < self.n_layers - 1: + res_acts = res_skip_acts[:, :self.hidden_channels, :] + x = (x + res_acts) * x_mask + output = output + res_skip_acts[:, self.hidden_channels:, :] + else: + output = output + res_skip_acts + return output * x_mask + + def remove_weight_norm(self): + if self.gin_channels != 0: + torch.nn.utils.remove_weight_norm(self.cond_layer) + for l in self.in_layers: + torch.nn.utils.remove_weight_norm(l) + for l in self.res_skip_layers: + torch.nn.utils.remove_weight_norm(l) + + +class ResBlock1(torch.nn.Module): + def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)): + super(ResBlock1, self).__init__() + self.convs1 = nn.ModuleList([ + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0], + padding=get_padding(kernel_size, dilation[0]))), + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1], + padding=get_padding(kernel_size, dilation[1]))), + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2], + padding=get_padding(kernel_size, dilation[2]))) + ]) + self.convs1.apply(init_weights) + + self.convs2 = nn.ModuleList([ + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1, + padding=get_padding(kernel_size, 1))), + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1, + padding=get_padding(kernel_size, 1))), + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1, + padding=get_padding(kernel_size, 1))) + ]) + self.convs2.apply(init_weights) + + def forward(self, x, x_mask=None): + for c1, c2 in zip(self.convs1, self.convs2): + xt = F.leaky_relu(x, LRELU_SLOPE) + if x_mask is not None: + xt = xt * x_mask + xt = c1(xt) + xt = F.leaky_relu(xt, LRELU_SLOPE) + if x_mask is not None: + xt = xt * x_mask + xt = c2(xt) + x = xt + x + if x_mask is not None: + x = x * x_mask + return x + + def remove_weight_norm(self): + for l in self.convs1: + remove_weight_norm(l) + for l in self.convs2: + remove_weight_norm(l) + + +class ResBlock2(torch.nn.Module): + def __init__(self, channels, kernel_size=3, dilation=(1, 3)): + super(ResBlock2, self).__init__() + self.convs = nn.ModuleList([ + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0], + padding=get_padding(kernel_size, dilation[0]))), + weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1], + padding=get_padding(kernel_size, dilation[1]))) + ]) + self.convs.apply(init_weights) + + def forward(self, x, x_mask=None): + for c in self.convs: + xt = F.leaky_relu(x, LRELU_SLOPE) + if x_mask is not None: + xt = xt * x_mask + xt = c(xt) + x = xt + x + if x_mask is not None: + x = x * x_mask + return x + + def remove_weight_norm(self): + for l in self.convs: + remove_weight_norm(l) + + +class Log(nn.Module): + def forward(self, x, x_mask, reverse=False, **kwargs): + if not reverse: + y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask + logdet = torch.sum(-y, [1, 2]) + return y, logdet + else: + x = torch.exp(x) * x_mask + return x + + +class Flip(nn.Module): + def forward(self, x, *args, reverse=False, **kwargs): + x = torch.flip(x, [1]) + if not reverse: + logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device) + return x, logdet + else: + return x + + +class ElementwiseAffine(nn.Module): + def __init__(self, channels): + super().__init__() + self.channels = channels + self.m = nn.Parameter(torch.zeros(channels, 1)) + self.logs = nn.Parameter(torch.zeros(channels, 1)) + + def forward(self, x, x_mask, reverse=False, **kwargs): + if not reverse: + y = self.m + torch.exp(self.logs) * x + y = y * x_mask + logdet = torch.sum(self.logs * x_mask, [1, 2]) + return y, logdet + else: + x = (x - self.m) * torch.exp(-self.logs) * x_mask + return x + + +class ResidualCouplingLayer(nn.Module): + def __init__(self, + channels, + hidden_channels, + kernel_size, + dilation_rate, + n_layers, + p_dropout=0, + gin_channels=0, + mean_only=False): + assert channels % 2 == 0, "channels should be divisible by 2" + super().__init__() + self.channels = channels + self.hidden_channels = hidden_channels + self.kernel_size = kernel_size + self.dilation_rate = dilation_rate + self.n_layers = n_layers + self.half_channels = channels // 2 + self.mean_only = mean_only + + self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1) + self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, + gin_channels=gin_channels) + self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1) + self.post.weight.data.zero_() + self.post.bias.data.zero_() + + def forward(self, x, x_mask, g=None, reverse=False): + x0, x1 = torch.split(x, [self.half_channels] * 2, 1) + h = self.pre(x0) * x_mask + h = self.enc(h, x_mask, g=g) + stats = self.post(h) * x_mask + if not self.mean_only: + m, logs = torch.split(stats, [self.half_channels] * 2, 1) + else: + m = stats + logs = torch.zeros_like(m) + + if not reverse: + x1 = m + x1 * torch.exp(logs) * x_mask + x = torch.cat([x0, x1], 1) + logdet = torch.sum(logs, [1, 2]) + return x, logdet + else: + x1 = (x1 - m) * torch.exp(-logs) * x_mask + x = torch.cat([x0, x1], 1) + return x + + +class ConvFlow(nn.Module): + def __init__(self, in_channels, filter_channels, kernel_size, n_layers, num_bins=10, tail_bound=5.0): + super().__init__() + self.in_channels = in_channels + self.filter_channels = filter_channels + self.kernel_size = kernel_size + self.n_layers = n_layers + self.num_bins = num_bins + self.tail_bound = tail_bound + self.half_channels = in_channels // 2 + + self.pre = nn.Conv1d(self.half_channels, filter_channels, 1) + self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.) + self.proj = nn.Conv1d(filter_channels, self.half_channels * (num_bins * 3 - 1), 1) + self.proj.weight.data.zero_() + self.proj.bias.data.zero_() + + def forward(self, x, x_mask, g=None, reverse=False): + x0, x1 = torch.split(x, [self.half_channels] * 2, 1) + h = self.pre(x0) + h = self.convs(h, x_mask, g=g) + h = self.proj(h) * x_mask + + b, c, t = x0.shape + h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?] + + unnormalized_widths = h[..., :self.num_bins] / math.sqrt(self.filter_channels) + unnormalized_heights = h[..., self.num_bins:2 * self.num_bins] / math.sqrt(self.filter_channels) + unnormalized_derivatives = h[..., 2 * self.num_bins:] + + x1, logabsdet = piecewise_rational_quadratic_transform(x1, + unnormalized_widths, + unnormalized_heights, + unnormalized_derivatives, + inverse=reverse, + tails='linear', + tail_bound=self.tail_bound + ) + + x = torch.cat([x0, x1], 1) * x_mask + logdet = torch.sum(logabsdet * x_mask, [1, 2]) + if not reverse: + return x, logdet + else: + return x + + +""" +################################### +##### 原仓库attentions.py的代码 ##### +################################### +""" + + +class Encoder(nn.Module): + def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=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, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., + proximal_bias=False, proximal_init=True, **kwargs): + super().__init__() + self.hidden_channels = hidden_channels + self.filter_channels = filter_channels + self.n_heads = n_heads + self.n_layers = n_layers + self.kernel_size = kernel_size + self.p_dropout = p_dropout + self.proximal_bias = proximal_bias + self.proximal_init = proximal_init + + self.drop = nn.Dropout(p_dropout) + self.self_attn_layers = nn.ModuleList() + self.norm_layers_0 = nn.ModuleList() + self.encdec_attn_layers = nn.ModuleList() + self.norm_layers_1 = nn.ModuleList() + self.ffn_layers = nn.ModuleList() + self.norm_layers_2 = nn.ModuleList() + for i in range(self.n_layers): + self.self_attn_layers.append( + MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, + proximal_bias=proximal_bias, proximal_init=proximal_init)) + self.norm_layers_0.append(LayerNorm(hidden_channels)) + self.encdec_attn_layers.append( + MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout)) + self.norm_layers_1.append(LayerNorm(hidden_channels)) + self.ffn_layers.append( + FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True)) + self.norm_layers_2.append(LayerNorm(hidden_channels)) + + def forward(self, x, x_mask, h, h_mask): + """ + x: decoder input + h: encoder output + """ + self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype) + encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1) + x = x * x_mask + for i in range(self.n_layers): + y = self.self_attn_layers[i](x, x, self_attn_mask) + y = self.drop(y) + x = self.norm_layers_0[i](x + y) + + y = self.encdec_attn_layers[i](x, h, encdec_attn_mask) + y = self.drop(y) + x = self.norm_layers_1[i](x + y) + + y = self.ffn_layers[i](x, x_mask) + y = self.drop(y) + x = self.norm_layers_2[i](x + y) + x = x * x_mask + return x + + +class MultiHeadAttention(nn.Module): + def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, + block_length=None, proximal_bias=False, proximal_init=False): + super().__init__() + assert channels % n_heads == 0 + + self.channels = channels + self.out_channels = out_channels + self.n_heads = n_heads + self.p_dropout = p_dropout + self.window_size = window_size + self.heads_share = heads_share + self.block_length = block_length + self.proximal_bias = proximal_bias + self.proximal_init = proximal_init + self.attn = None + + self.k_channels = channels // n_heads + self.conv_q = nn.Conv1d(channels, channels, 1) + self.conv_k = nn.Conv1d(channels, channels, 1) + self.conv_v = nn.Conv1d(channels, channels, 1) + self.conv_o = nn.Conv1d(channels, out_channels, 1) + self.drop = nn.Dropout(p_dropout) + + if window_size is not None: + n_heads_rel = 1 if heads_share else n_heads + rel_stddev = self.k_channels ** -0.5 + self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev) + self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev) + + nn.init.xavier_uniform_(self.conv_q.weight) + nn.init.xavier_uniform_(self.conv_k.weight) + nn.init.xavier_uniform_(self.conv_v.weight) + if proximal_init: + with torch.no_grad(): + self.conv_k.weight.copy_(self.conv_q.weight) + self.conv_k.bias.copy_(self.conv_q.bias) + + def forward(self, x, c, attn_mask=None): + q = self.conv_q(x) + k = self.conv_k(c) + v = self.conv_v(c) + + x, self.attn = self.attention(q, k, v, mask=attn_mask) + + x = self.conv_o(x) + return x + + def attention(self, query, key, value, mask=None): + # reshape [b, d, t] -> [b, n_h, t, d_k] + b, d, t_s, t_t = (*key.size(), query.size(2)) + query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3) + key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3) + value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3) + + scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1)) + if self.window_size is not None: + assert t_s == t_t, "Relative attention is only available for self-attention." + key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s) + rel_logits = self._matmul_with_relative_keys(query / math.sqrt(self.k_channels), key_relative_embeddings) + scores_local = self._relative_position_to_absolute_position(rel_logits) + scores = scores + scores_local + if self.proximal_bias: + assert t_s == t_t, "Proximal bias is only available for self-attention." + scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype) + if mask is not None: + scores = scores.masked_fill(mask == 0, -1e4) + if self.block_length is not None: + assert t_s == t_t, "Local attention is only available for self-attention." + block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length) + scores = scores.masked_fill(block_mask == 0, -1e4) + p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s] + p_attn = self.drop(p_attn) + output = torch.matmul(p_attn, value) + if self.window_size is not None: + relative_weights = self._absolute_position_to_relative_position(p_attn) + value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s) + output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings) + output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t] + return output, p_attn + + def _matmul_with_relative_values(self, x, y): + """ + x: [b, h, l, m] + y: [h or 1, m, d] + ret: [b, h, l, d] + """ + ret = torch.matmul(x, y.unsqueeze(0)) + return ret + + def _matmul_with_relative_keys(self, x, y): + """ + x: [b, h, l, d] + y: [h or 1, m, d] + ret: [b, h, l, m] + """ + ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1)) + return ret + + def _get_relative_embeddings(self, relative_embeddings, length): + max_relative_position = 2 * self.window_size + 1 + # Pad first before slice to avoid using cond ops. + pad_length = max(length - (self.window_size + 1), 0) + slice_start_position = max((self.window_size + 1) - length, 0) + slice_end_position = slice_start_position + 2 * length - 1 + if pad_length > 0: + padded_relative_embeddings = F.pad( + relative_embeddings, + commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]])) + else: + padded_relative_embeddings = relative_embeddings + used_relative_embeddings = padded_relative_embeddings[:, slice_start_position:slice_end_position] + return used_relative_embeddings + + def _relative_position_to_absolute_position(self, x): + """ + x: [b, h, l, 2*l-1] + ret: [b, h, l, l] + """ + batch, heads, length, _ = x.size() + # Concat columns of pad to shift from relative to absolute indexing. + x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 1]])) + + # Concat extra elements so to add up to shape (len+1, 2*len-1). + x_flat = x.view([batch, heads, length * 2 * length]) + x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [0, length - 1]])) + + # Reshape and slice out the padded elements. + x_final = x_flat.view([batch, heads, length + 1, 2 * length - 1])[:, :, :length, length - 1:] + return x_final + + def _absolute_position_to_relative_position(self, x): + """ + x: [b, h, l, l] + ret: [b, h, l, 2*l-1] + """ + batch, heads, length, _ = x.size() + # padd along column + x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length - 1]])) + x_flat = x.view([batch, heads, length ** 2 + length * (length - 1)]) + # add 0's in the beginning that will skew the elements after reshape + x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]])) + x_final = x_flat.view([batch, heads, length, 2 * length])[:, :, :, 1:] + return x_final + + def _attention_bias_proximal(self, length): + """Bias for self-attention to encourage attention to close positions. + Args: + length: an integer scalar. + Returns: + a Tensor with shape [1, 1, length, length] + """ + r = torch.arange(length, dtype=torch.float32) + diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1) + return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0) + + +class FFN(nn.Module): + def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, + causal=False): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.filter_channels = filter_channels + self.kernel_size = kernel_size + self.p_dropout = p_dropout + self.activation = activation + self.causal = causal + + if causal: + self.padding = self._causal_padding + else: + self.padding = self._same_padding + + self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size) + self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size) + self.drop = nn.Dropout(p_dropout) + + def forward(self, x, x_mask): + x = self.conv_1(self.padding(x * x_mask)) + if self.activation == "gelu": + x = x * torch.sigmoid(1.702 * x) + else: + x = torch.relu(x) + x = self.drop(x) + x = self.conv_2(self.padding(x * x_mask)) + return x * x_mask + + def _causal_padding(self, x): + if self.kernel_size == 1: + return x + pad_l = self.kernel_size - 1 + pad_r = 0 + padding = [[0, 0], [0, 0], [pad_l, pad_r]] + x = F.pad(x, commons.convert_pad_shape(padding)) + return x + + def _same_padding(self, x): + if self.kernel_size == 1: + return x + pad_l = (self.kernel_size - 1) // 2 + pad_r = self.kernel_size // 2 + padding = [[0, 0], [0, 0], [pad_l, pad_r]] + x = F.pad(x, commons.convert_pad_shape(padding)) + return x diff --git a/talkingface/properties/dataset/LJSpeech_vits.yaml b/talkingface/properties/dataset/LJSpeech_vits.yaml new file mode 100644 index 00000000..9a23199a --- /dev/null +++ b/talkingface/properties/dataset/LJSpeech_vits.yaml @@ -0,0 +1,14 @@ +training_files: "filelists/list.txt.cleaned", # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 +validation_files: "filelists/list_val.txt.cleaned", # 当前数据划分为测试机的文件名列表存放位置 +text_cleaners: ["cjke_cleaners2"], # 选择合适的cleaner，具体可以参考talkingface/utils/vits_utils/text/cleaners.py中的代码 +max_wav_value: 32768.0, +sampling_rate: 22050, +filter_length: 1024, +hop_length: 256, +win_length: 1024, +n_mel_channels: 80, +mel_fmin: 0.0, +mel_fmax: null, +add_blank: true, +n_speakers: 0, # 数据集中的说话人数，如果是一个人填0 +cleaned_text: true # 因为数据处理过后就有cleaned后缀，这里就是true \ No newline at end of file diff --git a/talkingface/properties/model/VITS.yaml b/talkingface/properties/model/VITS.yaml new file mode 100644 index 00000000..85bfd6fc --- /dev/null +++ b/talkingface/properties/model/VITS.yaml @@ -0,0 +1,16 @@ +inter_channels: 192, +hidden_channels: 192, +filter_channels: 768, +n_heads: 2, +n_layers: 6, +kernel_size: 3, +p_dropout: 0.1, +resblock: "1", +resblock_kernel_sizes: [3,7,11], +resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]], +upsample_rates: [8,8,2,2], +upsample_initial_channel: 512, +upsample_kernel_sizes: [16,16,4,4], +n_layers_q: 3, +use_spectral_norm: false, +gin_channels: 256 \ No newline at end of file diff --git a/talkingface/properties/overall_vits.yaml b/talkingface/properties/overall_vits.yaml new file mode 100644 index 00000000..1b1fc51d --- /dev/null +++ b/talkingface/properties/overall_vits.yaml @@ -0,0 +1,17 @@ +log_interval: 200, # 生成日志的间隔 +eval_interval: 1000, # 模型保存和测试的间隔 +seed: 1234, # 随机数种子 +epochs: 20000, # 要训练的epoch轮数 +learning_rate: 2e-4, # 学习率设置 +betas: [0.8, 0.99], +eps: 1e-9, +batch_size: 64, +fp16_run: true, +lr_decay: 0.999875, +segment_size: 8192, +init_lr_ratio: 1, +warmup_epochs: 0, +c_mel: 45, +c_kl: 1.0 +# 如果你不了解cleaner的工作机制，请不要动symbols，这里的Unicode是与talkingface.utils.vits_utils.text.symbols.py保持一致 +"symbols": ["_", ",", ".", "!", "?", "-", "~", "\u2026", "N", "Q", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "s", "t", "u", "v", "w", "x", "y", "z", "\u0251", "\u00e6", "\u0283", "\u0291", "\u00e7", "\u026f", "\u026a", "\u0254", "\u025b", "\u0279", "\u00f0", "\u0259", "\u026b", "\u0265", "\u0278", "\u028a", "\u027e", "\u0292", "\u03b8", "\u03b2", "\u014b", "\u0266", "\u207c", "\u02b0", "`", "^", "#", "*", "=", "\u02c8", "\u02cc", "\u2192", "\u2193", "\u2191", " "] \ No newline at end of file diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index 2c34717b..7d6838c8 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -554,4 +554,15 @@ def _valid_epoch(self, valid_data, loss_func=None, show_progress=False): if losses_dict["sync_loss"] < .75: self.model.config["syncnet_wt"] = 0.01 return average_loss_dict - \ No newline at end of file + + +class VITSTrainer(Trainer): + def __init__(self, config, model): + super(VITSTrainer, self).__init__(config, model) + + def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=False): + pass + + + def _valid_epoch(self, valid_data, show_progress=False): + pass diff --git a/talkingface/utils/vits_utils/__init__.py b/talkingface/utils/vits_utils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/talkingface/utils/vits_utils/commons.py b/talkingface/utils/vits_utils/commons.py new file mode 100644 index 00000000..3a59265c --- /dev/null +++ b/talkingface/utils/vits_utils/commons.py @@ -0,0 +1,159 @@ +import math + +import torch +from torch.nn import functional as F + + +def init_weights(m, mean=0.0, std=0.01): + classname = m.__class__.__name__ + if classname.find("Conv") != -1: + m.weight.data.normal_(mean, std) + + +def get_padding(kernel_size, dilation=1): + return int((kernel_size * dilation - dilation) / 2) + + +def convert_pad_shape(pad_shape): + l = pad_shape[::-1] + pad_shape = [item for sublist in l for item in sublist] + return pad_shape + + +def intersperse(lst, item): + result = [item] * (len(lst) * 2 + 1) + result[1::2] = lst + return result + + +def kl_divergence(m_p, logs_p, m_q, logs_q): + """KL(P||Q)""" + kl = (logs_q - logs_p) - 0.5 + kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2. * logs_q) + return kl + + +def rand_gumbel(shape): + """Sample from the Gumbel distribution, protect from overflows.""" + uniform_samples = torch.rand(shape) * 0.99998 + 0.00001 + return -torch.log(-torch.log(uniform_samples)) + + +def rand_gumbel_like(x): + g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device) + return g + + +def slice_segments(x, ids_str, segment_size=4): + ret = torch.zeros_like(x[:, :, :segment_size]) + for i in range(x.size(0)): + idx_str = ids_str[i] + idx_end = idx_str + segment_size + ret[i] = x[i, :, idx_str:idx_end] + return ret + + +def rand_slice_segments(x, x_lengths=None, segment_size=4): + b, d, t = x.size() + if x_lengths is None: + x_lengths = t + ids_str_max = x_lengths - segment_size + 1 + ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long) + ret = slice_segments(x, ids_str, segment_size) + return ret, ids_str + + +def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4): + position = torch.arange(length, dtype=torch.float) + num_timescales = channels // 2 + log_timescale_increment = ( + math.log(float(max_timescale) / float(min_timescale)) / + (num_timescales - 1)) + inv_timescales = min_timescale * torch.exp( + torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment) + scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1) + signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0) + signal = F.pad(signal, [0, 0, 0, channels % 2]) + signal = signal.view(1, channels, length) + return signal + + +def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4): + b, channels, length = x.size() + signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale) + return x + signal.to(dtype=x.dtype, device=x.device) + + +def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1): + b, channels, length = x.size() + signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale) + return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis) + + +def subsequent_mask(length): + mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0) + return mask + + +@torch.jit.script +def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels): + n_channels_int = n_channels[0] + in_act = input_a + input_b + t_act = torch.tanh(in_act[:, :n_channels_int, :]) + s_act = torch.sigmoid(in_act[:, n_channels_int:, :]) + acts = t_act * s_act + return acts + + +def convert_pad_shape(pad_shape): + l = pad_shape[::-1] + pad_shape = [item for sublist in l for item in sublist] + return pad_shape + + +def shift_1d(x): + x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1] + return x + + +def sequence_mask(length, max_length=None): + if max_length is None: + max_length = length.max() + x = torch.arange(max_length, dtype=length.dtype, device=length.device) + return x.unsqueeze(0) < length.unsqueeze(1) + + +def generate_path(duration, mask): + """ + duration: [b, 1, t_x] + mask: [b, 1, t_y, t_x] + """ + device = duration.device + + b, _, t_y, t_x = mask.shape + cum_duration = torch.cumsum(duration, -1) + + cum_duration_flat = cum_duration.view(b * t_x) + path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype) + path = path.view(b, t_x, t_y) + path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1] + path = path.unsqueeze(1).transpose(2, 3) * mask + return path + + +def clip_grad_value_(parameters, clip_value, norm_type=2): + if isinstance(parameters, torch.Tensor): + parameters = [parameters] + parameters = list(filter(lambda p: p.grad is not None, parameters)) + norm_type = float(norm_type) + if clip_value is not None: + clip_value = float(clip_value) + + total_norm = 0 + for p in parameters: + param_norm = p.grad.data.norm(norm_type) + total_norm += param_norm.item() ** norm_type + if clip_value is not None: + p.grad.data.clamp_(min=-clip_value, max=clip_value) + total_norm = total_norm ** (1. / norm_type) + return total_norm diff --git a/talkingface/utils/vits_utils/mel_processing.py b/talkingface/utils/vits_utils/mel_processing.py new file mode 100644 index 00000000..817f0375 --- /dev/null +++ b/talkingface/utils/vits_utils/mel_processing.py @@ -0,0 +1,112 @@ +import math +import os +import random +import torch +from torch import nn +import torch.nn.functional as F +import torch.utils.data +import numpy as np +import librosa +import librosa.util as librosa_util +from librosa.util import normalize, pad_center, tiny +from scipy.signal import get_window +from scipy.io.wavfile import read +from librosa.filters import mel as librosa_mel_fn + +MAX_WAV_VALUE = 32768.0 + + +def dynamic_range_compression_torch(x, C=1, clip_val=1e-5): + """ + PARAMS + ------ + C: compression factor + """ + return torch.log(torch.clamp(x, min=clip_val) * C) + + +def dynamic_range_decompression_torch(x, C=1): + """ + PARAMS + ------ + C: compression factor used to compress + """ + return torch.exp(x) / C + + +def spectral_normalize_torch(magnitudes): + output = dynamic_range_compression_torch(magnitudes) + return output + + +def spectral_de_normalize_torch(magnitudes): + output = dynamic_range_decompression_torch(magnitudes) + return output + + +mel_basis = {} +hann_window = {} + + +def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False): + if torch.min(y) < -1.: + print('min value is ', torch.min(y)) + if torch.max(y) > 1.: + print('max value is ', torch.max(y)) + + global hann_window + dtype_device = str(y.dtype) + '_' + str(y.device) + wnsize_dtype_device = str(win_size) + '_' + dtype_device + if wnsize_dtype_device not in hann_window: + hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device) + + y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect') + y = y.squeeze(1) + + spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device], + center=center, pad_mode='reflect', normalized=False, onesided=True) + + spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6) + return spec + + +def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax): + global mel_basis + dtype_device = str(spec.dtype) + '_' + str(spec.device) + fmax_dtype_device = str(fmax) + '_' + dtype_device + if fmax_dtype_device not in mel_basis: + mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax) + mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device) + spec = torch.matmul(mel_basis[fmax_dtype_device], spec) + spec = spectral_normalize_torch(spec) + return spec + + +def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False): + if torch.min(y) < -1.: + print('min value is ', torch.min(y)) + if torch.max(y) > 1.: + print('max value is ', torch.max(y)) + + global mel_basis, hann_window + dtype_device = str(y.dtype) + '_' + str(y.device) + fmax_dtype_device = str(fmax) + '_' + dtype_device + wnsize_dtype_device = str(win_size) + '_' + dtype_device + if fmax_dtype_device not in mel_basis: + mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax) + mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device) + if wnsize_dtype_device not in hann_window: + hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device) + + y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect') + y = y.squeeze(1) + + spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device], + center=center, pad_mode='reflect', normalized=False, onesided=True) + + 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/talkingface/utils/vits_utils/monotonic_align/__init__.py b/talkingface/utils/vits_utils/monotonic_align/__init__.py new file mode 100644 index 00000000..3d7009c4 --- /dev/null +++ b/talkingface/utils/vits_utils/monotonic_align/__init__.py @@ -0,0 +1,19 @@ +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/talkingface/utils/vits_utils/monotonic_align/core.c b/talkingface/utils/vits_utils/monotonic_align/core.c new file mode 100644 index 00000000..5631d20a --- /dev/null +++ b/talkingface/utils/vits_utils/monotonic_align/core.c @@ -0,0 +1,21299 @@ +/* Generated by Cython 0.29.21 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "name": "monotonic_align.core", + "sources": [ + "core.pyx" + ] + }, + "module_name": "monotonic_align.core" +} +END: Cython Metadata */ + +#define 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_21" +#define CYTHON_HEX_VERSION 0x001D15F0 +#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 + #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 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 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 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #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 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #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 + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #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" +#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#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 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #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) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #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 PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_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(MS_WINDOWS) + #define _USE_MATH_DEFINES +#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__monotonic_align__core +#define __PYX_HAVE_API__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); +#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_atomic_int_type int +#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\ + !defined(__i386__) + #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0 + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type LONG + #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value) + #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0 + #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value) + #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using Intel 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), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) +#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_15monotonic_align_4core_maximum_path_each; + +/* "monotonic_align/core.pyx":7 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< + * cdef int x + * cdef int y + */ +struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each { + int __pyx_n; + float max_neg_val; +}; + +/* "View.MemoryView":105 + * + * @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":279 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":330 + * + * @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":965 + * + * @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":105 + * + * @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":330 + * + * @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":965 + * + * @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 + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif + +/* 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 + +/* None.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 + +/* None.proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long); + +/* 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); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* 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); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* 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 '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_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/ +static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/ +static 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 "monotonic_align.core" +extern int __pyx_module_is_main_monotonic_align__core; +int __pyx_module_is_main_monotonic_align__core = 0; + +/* Implementation of 'monotonic_align.core' */ +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_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))"; +static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; +static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %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_s_vs_0xb0; +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_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_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_codeobj__26; +/* Late includes */ + +/* "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_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_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; + } + } + + /* "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); + + /* "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; + + /* "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; + + /* "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) { + + /* "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; + + /* "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; + } + + /* "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:; + + /* "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) { + + /* "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) { + + /* "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.; + + /* "monotonic_align/core.pyx":22 + * v_cur = value[y-1, x] + * if x == 0: + * if y == 0: # <<<<<<<<<<<<<< + * v_prev = 0. + * else: + */ + goto __pyx_L9; + } + + /* "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:; + + /* "monotonic_align/core.pyx":21 + * else: + * v_cur = value[y-1, x] + * if x == 0: # <<<<<<<<<<<<<< + * if y == 0: + * v_prev = 0. + */ + goto __pyx_L8; + } + + /* "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:; + + /* "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; + } + } + + /* "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; + + /* "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; + + /* "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) { + + /* "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); + + /* "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 + * + */ + } + } + + /* "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 */ +} + +/* "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_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static void __pyx_f_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; + + /* "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]); + + /* "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); + + /* "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_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 + } + + /* "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:; + } + } + + /* "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_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_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("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_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_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_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("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":122 + * 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, 122, __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, 122, __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, 122, __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, 122, __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, 123, __pyx_L3_error) + } else { + + /* "View.MemoryView":123 + * + * 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, 122, __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, 122, __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, 122, __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":122 + * 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":129 + * 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, 129, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 129, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":130 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: + */ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":132 + * 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":133 + * + * 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, 133, __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, 133, __pyx_L1_error) + + /* "View.MemoryView":132 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + } + + /* "View.MemoryView":135 + * 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":136 + * + * 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, 136, __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, 136, __pyx_L1_error) + + /* "View.MemoryView":135 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":138 + * 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":139 + * + * 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, 139, __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, 139, __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":138 + * 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":140 + * 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, 140, __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":141 + * 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, 141, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":144 + * + * + * 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":145 + * + * 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":147 + * 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":148 + * + * 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, 148, __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, 148, __pyx_L1_error) + + /* "View.MemoryView":147 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":151 + * + * + * 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, 151, __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, 151, __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, 151, __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":152 + * + * 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":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_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 153, __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, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __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, 153, __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, 153, __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, 153, __pyx_L1_error) + + /* "View.MemoryView":152 + * + * 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":154 + * 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":151 + * + * + * 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":157 + * + * 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, 157, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":158 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":159 + * 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":157 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":160 + * 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, 160, __pyx_L1_error) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":161 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":162 + * 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":160 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":164 + * 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, 164, __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, 164, __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, 164, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":166 + * 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":169 + * 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":170 + * + * 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, 170, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":171 + * 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":174 + * + * + * 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":175 + * + * 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":176 + * 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, 176, __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, 176, __pyx_L1_error) + + /* "View.MemoryView":175 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":178 + * 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":179 + * + * 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":180 + * 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, 180, __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, 180, __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":181 + * 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":182 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":178 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":171 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":122 + * 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":185 + * + * @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":186 + * @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":187 + * 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, 187, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":188 + * 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":187 + * 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":189 + * 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, 189, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":190 + * 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":189 + * 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":191 + * 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":192 + * 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, 192, __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, 192, __pyx_L1_error) + + /* "View.MemoryView":191 + * 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":193 + * 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":194 + * 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":195 + * 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":196 + * 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":197 + * 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":198 + * 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":199 + * 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":200 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":202 + * 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":203 + * + * 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":202 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":205 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":207 + * 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":185 + * + * @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":211 + * __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":212 + * + * 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":213 + * 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":212 + * + * 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":214 + * 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":215 + * 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":216 + * 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":215 + * 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":218 + * 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":214 + * 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":219 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":211 + * __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":222 + * + * @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":223 + * @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, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":222 + * + * @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":226 + * + * @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":227 + * @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":228 + * 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, 228, __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, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 228, __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, 228, __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":226 + * + * @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":230 + * 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":231 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":230 + * 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":233 + * 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":234 + * + * 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, 234, __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, 234, __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":233 + * 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":236 + * 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":237 + * + * 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, 237, __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, 237, __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":236 + * 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":239 + * 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":240 + * + * 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, 240, __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, 240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":239 + * 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":244 + * + * @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":248 + * 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":249 + * + * 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, 249, __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, 249, __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, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 249, __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, 249, __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":248 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":251 + * 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, 251, __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, 251, __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, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 251, __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":252 + * 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, 252, __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, 252, __pyx_L1_error) + + /* "View.MemoryView":251 + * 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, 251, __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":253 + * 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":255 + * 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":244 + * + * @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":281 + * 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, 281, __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, 281, __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":282 + * 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":281 + * 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":283 + * 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":284 + * 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":283 + * 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":298 + * + * @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":300 + * 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":304 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":306 + * 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":307 + * + * 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":306 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":309 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":298 + * + * @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":345 + * 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, 345, __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, 345, __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, 345, __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, 345, __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, 345, __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":346 + * + * 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":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_GetBuffer(obj, &self.view, flags) + */ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":348 + * 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":349 + * 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, 349, __pyx_L1_error) + + /* "View.MemoryView":350 + * 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":351 + * __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":352 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * global __pyx_memoryview_thread_locks_used + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":350 + * 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":348 + * 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 + * + * 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":356 + * 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":357 + * 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":355 + * + * 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":358 + * 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":359 + * __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":360 + * 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":361 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 361, __pyx_L1_error) + + /* "View.MemoryView":360 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":358 + * 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":363 + * 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":364 + * + * 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_L11_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":363 + * 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_L10; + } + + /* "View.MemoryView":366 + * 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_L10:; + + /* "View.MemoryView":368 + * 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":370 + * 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":345 + * 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":372 + * 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":373 + * + * 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":374 + * 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":373 + * + * 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":375 + * 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":377 + * 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":378 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i + */ + Py_DECREF(Py_None); + + /* "View.MemoryView":375 + * 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":382 + * 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":383 + * 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":384 + * 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":385 + * 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":386 + * 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":388 + * 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":387 + * __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":386 + * 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":389 + * __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":384 + * 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":391 + * 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":382 + * 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":372 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":393 + * 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":395 + * 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":397 + * 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, 397, __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, 397, __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, 397, __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, 397, __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, 397, __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, 397, __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, 397, __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":398 + * + * 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, 398, __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, 398, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":397 + * 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":400 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":393 + * 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":403 + * + * + * 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":404 + * + * 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":405 + * 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":404 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":407 + * 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, 407, __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, 407, __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, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 407, __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":410 + * + * 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, 410, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":411 + * 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, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":410 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":413 + * 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, 413, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":414 + * 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, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":403 + * + * + * 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":416 + * 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":417 + * + * 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":418 + * 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, 418, __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, 418, __pyx_L1_error) + + /* "View.MemoryView":417 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":420 + * 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, 420, __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, 420, __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, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 420, __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":422 + * 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, 422, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":423 + * + * 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, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":424 + * 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, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * 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, 425, __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, 425, __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":424 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":427 + * 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, 427, __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, 427, __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, 427, __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":422 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":429 + * 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, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":416 + * 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":431 + * 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":432 + * + * 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":433 + * 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":434 + * 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, 434, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":435 + * 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, 435, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":434 + * 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, 434, __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, 434, __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":433 + * 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":436 + * 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, 436, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":437 + * 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":433 + * 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":432 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":439 + * 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":431 + * 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":441 + * 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":445 + * 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, 445, __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, 445, __pyx_L1_error) + + /* "View.MemoryView":446 + * + * 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, 446, __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, 446, __pyx_L1_error) + + /* "View.MemoryView":447 + * 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, 447, __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, 447, __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, 447, __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, 447, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":445 + * 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, 445, __pyx_L1_error) + + /* "View.MemoryView":441 + * 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":449 + * 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":451 + * 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":456 + * 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, 456, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":458 + * 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":459 + * + * 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":460 + * 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":461 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 461, __pyx_L1_error) + + /* "View.MemoryView":460 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":462 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":458 + * 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":464 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":466 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":467 + * + * 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":468 + * 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":467 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":470 + * ( 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, 470, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":474 + * + * + * 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":475 + * + * 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, 475, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":474 + * + * + * 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":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, # <<<<<<<<<<<<<< + * 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":479 + * 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":449 + * 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":481 + * 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":482 + * + * 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, 482, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":483 + * 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, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":481 + * 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":485 + * 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":488 + * """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, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":491 + * 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, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":492 + * + * 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":493 + * 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, 493, __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, 493, __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, 493, __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, 493, __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, 493, __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, 493, __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":492 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":497 + * 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":498 + * 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, 498, __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":497 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":499 + * 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":494 + * 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, 494, __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, 494, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":495 + * 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, 495, __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, 495, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":492 + * + * 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":485 + * 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":501 + * 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":504 + * """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, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":509 + * 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":510 + * + * 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, 510, __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, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 510, __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, 510, __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, 510, __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, 510, __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, 510, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":509 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":512 + * 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, 512, __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, 512, __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, 512, __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, 512, __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, 512, __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, 512, __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, 512, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":514 + * 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, 514, __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":515 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":514 + * 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":515 + * + * 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":501 + * 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":518 + * + * @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":519 + * @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":520 + * 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, 520, __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, 520, __pyx_L1_error) + + /* "View.MemoryView":519 + * @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":522 + * 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":523 + * + * 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":522 + * 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":525 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":527 + * 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":528 + * + * 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":527 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":530 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":532 + * 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":533 + * + * 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":532 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":535 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":537 + * 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":538 + * + * 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":537 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":540 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":542 + * 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":543 + * + * 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":544 + * 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":545 + * 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":546 + * 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":547 + * 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":518 + * + * @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":553 + * + * @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":554 + * @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, 554, __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, 554, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":555 + * 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, 555, __pyx_L1_error) + + /* "View.MemoryView":556 + * 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":553 + * + * @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":559 + * + * @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":560 + * @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":559 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":563 + * + * @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":564 + * @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, 564, __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, 564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 564, __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, 564, __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":563 + * + * @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":567 + * + * @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":568 + * @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":570 + * 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, 570, __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, 570, __pyx_L1_error) + + /* "View.MemoryView":568 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":572 + * 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, 572, __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, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 572, __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, 572, __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":567 + * + * @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":575 + * + * @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":576 + * @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":577 + * 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, 577, __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, 577, __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":576 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":579 + * 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, 579, __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, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 579, __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, 579, __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":575 + * + * @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":582 + * + * @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":583 + * @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, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":582 + * + * @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":586 + * + * @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":587 + * @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, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":586 + * + * @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":590 + * + * @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":591 + * @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, 591, __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, 591, __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, 591, __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":590 + * + * @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":594 + * + * @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":595 + * @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":596 + * 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":598 + * 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, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":599 + * + * 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, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":601 + * 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":595 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":603 + * 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":594 + * + * @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":605 + * 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":606 + * + * 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":607 + * 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":606 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":609 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":605 + * 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":611 + * 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":612 + * + * 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, 612, __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, 612, __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, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":613 + * 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, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":612 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __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, 612, __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":611 + * 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":615 + * 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":616 + * + * 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, 616, __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, 616, __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, 616, __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, 616, __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, 616, __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":615 + * 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":619 + * + * + * 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":622 + * 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, 622, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":623 + * 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, 623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":619 + * + * + * 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":625 + * 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":628 + * 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, 628, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":629 + * 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, 629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":625 + * 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":631 + * 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":633 + * 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":635 + * 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":636 + * + * 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, 636, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":641 + * 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, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":631 + * 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":643 + * 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":645 + * 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":647 + * 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":648 + * + * 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, 648, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":653 + * 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, 653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":643 + * 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":657 + * + * @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":658 + * @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, 658, __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, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 658, __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, 658, __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":659 + * 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":660 + * 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":657 + * + * @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":663 + * + * @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":664 + * @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":663 + * + * @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":666 + * 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":671 + * 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":672 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 672, __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":671 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":674 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":676 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":677 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":678 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":679 + * 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, 679, __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, 679, __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, 679, __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, 679, __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, 679, __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, 679, __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, 679, __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, 679, __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":680 + * 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":681 + * 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":682 + * 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, 682, __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, 682, __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, 682, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":683 + * 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":681 + * 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":685 + * 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, 685, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":686 + * 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":680 + * 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":688 + * 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":689 + * 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, 689, __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, 689, __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, 689, __pyx_L1_error) + + /* "View.MemoryView":688 + * 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":691 + * 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":692 + * + * 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, 692, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":679 + * 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":694 + * 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, 694, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":695 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":696 + * 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, 696, __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, 696, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":695 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":698 + * 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, 698, __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, 698, __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, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 698, __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":666 + * 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":700 + * 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":701 + * + * 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":702 + * 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":703 + * 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, 703, __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, 703, __pyx_L1_error) + + /* "View.MemoryView":702 + * 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":700 + * 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":710 + * + * @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":711 + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< + * cdef bint negative_step + * cdef __Pyx_memviewslice src, dst + */ + __pyx_v_new_ndim = 0; + __pyx_v_suboffset_dim = -1; + + /* "View.MemoryView":718 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":722 + * 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, 722, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":724 + * 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":725 + * + * 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, 725, __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":726 + * 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":724 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":728 + * 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":729 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":735 + * + * + * 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":736 + * + * 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":741 + * + * + * 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":742 + * + * 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":746 + * 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, 746, __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, 746, __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, 746, __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, 746, __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, 746, __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, 746, __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, 746, __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":747 + * + * 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":751 + * 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, 751, __pyx_L1_error) + + /* "View.MemoryView":748 + * 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, 748, __pyx_L1_error) + + /* "View.MemoryView":747 + * + * 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":754 + * 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":755 + * 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":756 + * 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":757 + * 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":758 + * 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":754 + * 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":760 + * 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, 760, __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, 760, __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, 760, __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":761 + * 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, 761, __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, 761, __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, 761, __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":762 + * 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, 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_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "View.MemoryView":764 + * 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, 764, __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":765 + * + * 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, 765, __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":766 + * 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, 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_step = __pyx_t_1; + + /* "View.MemoryView":768 + * 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, 768, __pyx_L1_error) + + /* "View.MemoryView":774 + * 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":746 + * 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":776 + * 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":777 + * + * 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":778 + * 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, 778, __pyx_L1_error) } + + /* "View.MemoryView":779 + * 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, 779, __pyx_L1_error) } + + /* "View.MemoryView":777 + * + * 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, 777, __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, 777, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":776 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + } + + /* "View.MemoryView":782 + * 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":783 + * 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, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":782 + * 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, 782, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":710 + * + * @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":807 + * + * @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":827 + * 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":829 + * 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":830 + * + * 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":829 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":831 + * 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":832 + * 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, 832, __pyx_L1_error) + + /* "View.MemoryView":831 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":827 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":835 + * 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":837 + * 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":838 + * + * 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, 838, __pyx_L1_error) + + /* "View.MemoryView":837 + * 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":841 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":842 + * + * 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":843 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":844 + * 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":845 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":844 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":842 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":846 + * 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":847 + * 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":848 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":847 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":850 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":846 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":841 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":852 + * 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":853 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":852 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":855 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":857 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":858 + * + * 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":859 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":860 + * 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":861 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":860 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":858 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":862 + * 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":863 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":862 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":857 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":865 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":866 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":865 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":868 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":870 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":871 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":870 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":875 + * + * 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":877 + * 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":878 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":877 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":880 + * 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":881 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":880 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":884 + * + * + * 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":885 + * + * 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":886 + * 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":889 + * + * + * 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":890 + * + * 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":889 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":892 + * 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":894 + * 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":895 + * + * 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":896 + * 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":897 + * 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":896 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":899 + * 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":900 + * 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, 899, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":895 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":902 + * "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":894 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":904 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":807 + * + * @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":910 + * + * @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":912 + * 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":913 + * 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":916 + * 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":917 + * + * 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, 917, __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, 917, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); + + /* "View.MemoryView":918 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":916 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":920 + * 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":921 + * 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":922 + * 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":923 + * 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":922 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":925 + * 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":926 + * + * 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":927 + * 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":928 + * 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, 928, __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, 928, __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, 928, __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, 928, __pyx_L1_error) + + /* "View.MemoryView":927 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":925 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":930 + * 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":931 + * + * 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, 931, __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, 931, __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, 931, __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, 931, __pyx_L1_error) + + /* "View.MemoryView":930 + * 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":933 + * 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":934 + * + * 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":935 + * 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":934 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":937 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":910 + * + * @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":943 + * + * @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":944 + * @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":946 + * 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":947 + * + * 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":951 + * + * 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":952 + * 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":953 + * 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":954 + * 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":956 + * 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":957 + * + * 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, 957, __pyx_L1_error) + + /* "View.MemoryView":956 + * 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":959 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":943 + * + * @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":976 + * 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":977 + * + * 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":976 + * 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":979 + * __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":980 + * + * 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":981 + * 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, 981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":980 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":983 + * 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, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":979 + * __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":985 + * 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":986 + * + * 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":987 + * 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, 987, __pyx_L1_error) + + /* "View.MemoryView":986 + * + * 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":989 + * 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, 989, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":985 + * 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":992 + * + * @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":993 + * @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":992 + * + * @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":999 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_TypeInfo *__pyx_t_4; + Py_buffer __pyx_t_5; + Py_ssize_t *__pyx_t_6; + Py_ssize_t *__pyx_t_7; + Py_ssize_t *__pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1007 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1008 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1007 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1013 + * + * + * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice + */ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __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":1015 + * 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":1016 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1018 + * __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, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_result->from_object); + __Pyx_DECREF(__pyx_v_result->from_object); + __pyx_v_result->from_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":1019 + * + * result.from_object = ( memviewslice.memview).base + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view + */ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":1021 + * result.typeinfo = memviewslice.memview.typeinfo + * + * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + */ + __pyx_t_5 = __pyx_v_memviewslice.memview->view; + __pyx_v_result->__pyx_base.view = __pyx_t_5; + + /* "View.MemoryView":1022 + * + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + */ + __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); + + /* "View.MemoryView":1023 + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data + * result.view.ndim = ndim # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; + + /* "View.MemoryView":1024 + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; + + /* "View.MemoryView":1025 + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":1027 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1028 + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< + * else: + * result.flags = PyBUF_RECORDS_RO + */ + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; + + /* "View.MemoryView":1027 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1030 + * result.flags = PyBUF_RECORDS + * else: + * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< + * + * result.view.shape = result.from_slice.shape + */ + /*else*/ { + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; + } + __pyx_L4:; + + /* "View.MemoryView":1032 + * result.flags = PyBUF_RECORDS_RO + * + * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< + * result.view.strides = result.from_slice.strides + * + */ + __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); + + /* "View.MemoryView":1033 + * + * result.view.shape = result.from_slice.shape + * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); + + /* "View.MemoryView":1036 + * + * + * result.view.suboffsets = NULL # <<<<<<<<<<<<<< + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + */ + __pyx_v_result->__pyx_base.view.suboffsets = NULL; + + /* "View.MemoryView":1037 + * + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + */ + __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_v_suboffset = (__pyx_t_6[0]); + + /* "View.MemoryView":1038 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1039 + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); + + /* "View.MemoryView":1040 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1038 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + } + } + __pyx_L6_break:; + + /* "View.MemoryView":1042 + * break + * + * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< + * for length in result.view.shape[:ndim]: + * result.view.len *= length + */ + __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + + /* "View.MemoryView":1043 + * + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< + * result.view.len *= length + * + */ + __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1043, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1044 + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: + * result.view.len *= length # <<<<<<<<<<<<<< + * + * result.to_object_func = to_object_func + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1046 + * result.view.len *= length + * + * result.to_object_func = to_object_func # <<<<<<<<<<<<<< + * result.to_dtype_func = to_dtype_func + * + */ + __pyx_v_result->to_object_func = __pyx_v_to_object_func; + + /* "View.MemoryView":1047 + * + * result.to_object_func = to_object_func + * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; + + /* "View.MemoryView":1049 + * result.to_dtype_func = to_dtype_func + * + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":999 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1052 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + 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":1055 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1056 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1056, __pyx_L1_error) + __pyx_t_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":1057 + * if isinstance(memview, _memoryviewslice): + * obj = memview + * return &obj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, mslice) + */ + __pyx_r = (&__pyx_v_obj->from_slice); + goto __pyx_L0; + + /* "View.MemoryView":1055 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1059 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1060 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1052 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_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":1063 + * + * @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":1067 + * cdef (Py_ssize_t*) shape, strides, suboffsets + * + * shape = memview.view.shape # <<<<<<<<<<<<<< + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets + */ + __pyx_t_1 = __pyx_v_memview->view.shape; + __pyx_v_shape = __pyx_t_1; + + /* "View.MemoryView":1068 + * + * shape = memview.view.shape + * strides = memview.view.strides # <<<<<<<<<<<<<< + * suboffsets = memview.view.suboffsets + * + */ + __pyx_t_1 = __pyx_v_memview->view.strides; + __pyx_v_strides = __pyx_t_1; + + /* "View.MemoryView":1069 + * shape = memview.view.shape + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< + * + * dst.memview = <__pyx_memoryview *> memview + */ + __pyx_t_1 = __pyx_v_memview->view.suboffsets; + __pyx_v_suboffsets = __pyx_t_1; + + /* "View.MemoryView":1071 + * suboffsets = memview.view.suboffsets + * + * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< + * dst.data = memview.view.buf + * + */ + __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); + + /* "View.MemoryView":1072 + * + * dst.memview = <__pyx_memoryview *> memview + * dst.data = memview.view.buf # <<<<<<<<<<<<<< + * + * for dim in range(memview.view.ndim): + */ + __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); + + /* "View.MemoryView":1074 + * dst.data = memview.view.buf + * + * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + */ + __pyx_t_2 = __pyx_v_memview->view.ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_dim = __pyx_t_4; + + /* "View.MemoryView":1075 + * + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + */ + (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); + + /* "View.MemoryView":1076 + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + */ + (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); + + /* "View.MemoryView":1077 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') + */ + if ((__pyx_v_suboffsets != 0)) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":1063 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1080 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { + __Pyx_memviewslice __pyx_v_memviewslice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1083 + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< + * return memoryview_copy_from_slice(memview, &memviewslice) + * + */ + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); + + /* "View.MemoryView":1084 + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) + * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object_from_slice') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1080 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1087 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + 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":1094 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1095 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1096 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL + */ + __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1094 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1098 + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + * to_object_func = NULL # <<<<<<<<<<<<<< + * to_dtype_func = NULL + * + */ + /*else*/ { + __pyx_v_to_object_func = NULL; + + /* "View.MemoryView":1099 + * else: + * to_object_func = NULL + * to_dtype_func = NULL # <<<<<<<<<<<<<< + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + */ + __pyx_v_to_dtype_func = NULL; + } + __pyx_L3:; + + /* "View.MemoryView":1101 + * to_dtype_func = NULL + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< + * to_object_func, to_dtype_func, + * memview.dtype_is_object) + */ + __Pyx_XDECREF(__pyx_r); + + /* "View.MemoryView":1103 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_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, 1101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1087 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_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":1109 + * + * + * 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":1110 + * + * 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":1111 + * 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":1110 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1113 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1109 + * + * + * 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":1116 + * + * @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":1121 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1122 + * 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":1124 + * 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":1125 + * + * 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":1126 + * 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":1127 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1125 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1129 + * 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":1130 + * + * 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":1131 + * 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":1132 + * 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":1130 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1134 + * 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":1135 + * + * 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":1134 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1137 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1116 + * + * @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":1140 + * + * @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":1147 + * + * 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":1148 + * 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":1149 + * 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":1150 + * 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":1152 + * 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":1153 + * + * 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":1154 + * 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":1153 + * + * 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":1155 + * 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":1153 + * + * 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":1157 + * 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":1158 + * 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":1159 + * 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":1160 + * 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":1152 + * 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":1162 + * 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":1163 + * 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":1167 + * 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":1168 + * 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":1140 + * + * @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":1170 + * 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":1173 + * __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":1170 + * 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":1177 + * + * @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":1179 + * 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":1181 + * 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":1182 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1184 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1177 + * + * @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":1187 + * + * @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":1196 + * 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":1197 + * + * 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":1198 + * 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":1199 + * 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":1196 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1201 + * 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":1202 + * 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":1203 + * 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":1205 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1187 + * + * @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":1208 + * + * @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":1219 + * 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":1220 + * + * 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":1222 + * 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":1223 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1224 + * 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, 1224, __pyx_L1_error) + + /* "View.MemoryView":1223 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1227 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1228 + * + * 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":1229 + * 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":1230 + * 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":1231 + * 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":1233 + * 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":1237 + * + * + * 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":1238 + * + * 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":1239 + * 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":1238 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + } + } + + /* "View.MemoryView":1241 + * 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":1242 + * + * 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":1241 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":1244 + * 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":1246 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1208 + * + * @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":1251 + * + * @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":1254 + * 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, 1254, __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, 1254, __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, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1254, __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":1253 + * 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, 1253, __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, 1253, __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, 1253, __pyx_L1_error) + + /* "View.MemoryView":1251 + * + * @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":1257 + * + * @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":1258 + * @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, 1258, __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, 1258, __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, 1258, __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, 1258, __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, 1258, __pyx_L1_error) + + /* "View.MemoryView":1257 + * + * @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":1261 + * + * @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":1262 + * @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":1263 + * 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, 1263, __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, 1263, __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, 1263, __pyx_L1_error) + + /* "View.MemoryView":1262 + * @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":1265 + * 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, 1265, __pyx_L1_error) + } + + /* "View.MemoryView":1261 + * + * @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":1268 + * + * @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":1276 + * 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":1277 + * """ + * 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":1279 + * 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":1280 + * 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":1281 + * 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":1284 + * 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":1285 + * + * 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":1284 + * 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":1286 + * 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":1287 + * 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":1286 + * 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":1289 + * 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":1291 + * 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":1292 + * + * 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":1293 + * 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":1294 + * 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":1295 + * 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":1293 + * 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":1297 + * 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, 1297, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1292 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1299 + * _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":1300 + * + * 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, 1300, __pyx_L1_error) + + /* "View.MemoryView":1299 + * _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":1302 + * _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":1304 + * 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":1305 + * + * 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":1304 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1307 + * 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, 1307, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1308 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1302 + * _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":1310 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1313 + * + * + * 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":1314 + * + * 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":1313 + * + * + * 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":1315 + * 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":1316 + * 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":1315 + * 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":1318 + * 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":1320 + * 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":1321 + * + * 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":1322 + * 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":1323 + * 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":1324 + * 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":1318 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1310 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1326 + * 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":1329 + * + * + * 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, 1329, __pyx_L1_error) + + /* "View.MemoryView":1330 + * + * 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, 1330, __pyx_L1_error) + + /* "View.MemoryView":1326 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1332 + * 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":1333 + * + * 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":1334 + * 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":1336 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1337 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1268 + * + * @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":1340 + * + * @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":1344 + * 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":1346 + * 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":1347 + * + * 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":1348 + * 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":1349 + * 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":1351 + * 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":1352 + * + * 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":1353 + * 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":1354 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1340 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1362 + * + * @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":1366 + * + * + * 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":1367 + * + * 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":1366 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1362 + * + * @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":1371 + * + * @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":1374 + * 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":1371 + * + * @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":1377 + * + * @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":1381 + * 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":1382 + * + * 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":1383 + * 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":1384 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1383 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1386 + * 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":1382 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1388 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1389 + * 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":1391 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1377 + * + * @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":1397 + * + * @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":1400 + * 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":1401 + * 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":1403 + * _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":1397 + * + * @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":1407 + * + * @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":1411 + * 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":1412 + * 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":1414 + * 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":1415 + * + * 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":1416 + * 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":1417 + * 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":1414 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1419 + * 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":1420 + * 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":1422 + * _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":1407 + * + * @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 + 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_t_6; + 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 != 0xb068931: # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + */ + __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0); + if (__pyx_t_1) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_2); + __pyx_v___pyx_PickleError = __pyx_t_2; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (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_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v___pyx_result = __pyx_t_3; + __pyx_t_3 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (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_1 = (__pyx_v___pyx_state != Py_None); + __pyx_t_6 = (__pyx_t_1 != 0); + if (__pyx_t_6) { + + /* "(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_3 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __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) + "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 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #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) + "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 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #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) + "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 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #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) + "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 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"maximum_path_c", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_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_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 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, 133, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 148, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 151, __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, 404, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 613, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 832, __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":133 + * + * 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, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "View.MemoryView":136 + * + * 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, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "View.MemoryView":148 + * + * 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, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "View.MemoryView":176 + * 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, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "View.MemoryView":192 + * 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, 192, __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":418 + * 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, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":495 + * 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, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "View.MemoryView":520 + * 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, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "View.MemoryView":570 + * 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, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "View.MemoryView":577 + * 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, 577, __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":682 + * 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, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__16); + __Pyx_GIVEREF(__pyx_slice__16); + + /* "View.MemoryView":703 + * 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, 703, __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); + + /* "View.MemoryView":286 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + + /* "View.MemoryView":287 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); 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_indirect); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "View.MemoryView":291 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 291, __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_indirect); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__25 = 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__25)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __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 */ + #ifdef WITH_THREAD +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_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, 105, __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, 105, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __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, 279, __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, 330, __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, 330, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __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, 965, __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, 965, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __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(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #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_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, "monotonic_align.core")) { + if (unlikely(PyDict_SetItemString(modules, "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 + + /* "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); + + /* "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":209 + * 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, 209, __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, 209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":286 + * 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__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __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":287 + * + * 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(strided); + __Pyx_DECREF_SET(strided, __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(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":291 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __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":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(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":316 + * + * 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":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(), + * 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":549 + * 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, 549, __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, 549, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":995 + * 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, 995, __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, 995, __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 monotonic_align.core", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init 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]; +#ifdef 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 = func->ob_type->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 (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + 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_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 +} + +/* None */ +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 + +/* None */ +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_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; +#else + if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; +#endif +#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); +#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; + 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" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + 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); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + 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; + 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) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __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; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + 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); + } +} + +/* 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;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + 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); + } +} + +/* 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; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + 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; +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + 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) { + const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0; + 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[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + 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 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/talkingface/utils/vits_utils/monotonic_align/core.pyx b/talkingface/utils/vits_utils/monotonic_align/core.pyx new file mode 100644 index 00000000..bfaabd4d --- /dev/null +++ b/talkingface/utils/vits_utils/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/talkingface/utils/vits_utils/monotonic_align/setup.py b/talkingface/utils/vits_utils/monotonic_align/setup.py new file mode 100644 index 00000000..30c22480 --- /dev/null +++ b/talkingface/utils/vits_utils/monotonic_align/setup.py @@ -0,0 +1,9 @@ +from distutils.core import setup +from Cython.Build import cythonize +import numpy + +setup( + name = 'monotonic_align', + ext_modules = cythonize("core.pyx"), + include_dirs=[numpy.get_include()] +) diff --git a/talkingface/utils/vits_utils/text/LICENSE b/talkingface/utils/vits_utils/text/LICENSE new file mode 100644 index 00000000..4ad4ed1d --- /dev/null +++ b/talkingface/utils/vits_utils/text/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2017 Keith Ito + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/talkingface/utils/vits_utils/text/__init__.py b/talkingface/utils/vits_utils/text/__init__.py new file mode 100644 index 00000000..48ae82f3 --- /dev/null +++ b/talkingface/utils/vits_utils/text/__init__.py @@ -0,0 +1,56 @@ +""" from https://github.com/keithito/tacotron """ +from text import cleaners +from text.symbols import symbols + + +# Mappings from symbol to numeric ID and vice versa: +_symbol_to_id = {s: i for i, s in enumerate(symbols)} +_id_to_symbol = {i: s for i, s in enumerate(symbols)} + + +def text_to_sequence(text, cleaner_names): + '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text. + Args: + text: string to convert to a sequence + cleaner_names: names of the cleaner functions to run the text through + Returns: + List of integers corresponding to the symbols in the text + ''' + sequence = [] + + clean_text = _clean_text(text, cleaner_names) + for symbol in clean_text: + if symbol not in _symbol_to_id.keys(): + continue + symbol_id = _symbol_to_id[symbol] + sequence += [symbol_id] + return sequence + + +def cleaned_text_to_sequence(cleaned_text): + '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text. + Args: + text: string to convert to a sequence + Returns: + List of integers corresponding to the symbols in the text + ''' + sequence = [_symbol_to_id[symbol] for symbol in cleaned_text if symbol in _symbol_to_id.keys()] + return sequence + + +def sequence_to_text(sequence): + '''Converts a sequence of IDs back to a string''' + result = '' + for symbol_id in sequence: + s = _id_to_symbol[symbol_id] + result += s + return result + + +def _clean_text(text, cleaner_names): + for name in cleaner_names: + cleaner = getattr(cleaners, name) + if not cleaner: + raise Exception('Unknown cleaner: %s' % name) + text = cleaner(text) + return text diff --git a/talkingface/utils/vits_utils/text/cantonese.py b/talkingface/utils/vits_utils/text/cantonese.py new file mode 100644 index 00000000..b66d1213 --- /dev/null +++ b/talkingface/utils/vits_utils/text/cantonese.py @@ -0,0 +1,59 @@ +import re +import cn2an +import opencc + + +converter = opencc.OpenCC('jyutjyu') + +# List of (Latin alphabet, ipa) pairs: +_latin_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('A', 'ei˥'), + ('B', 'biː˥'), + ('C', 'siː˥'), + ('D', 'tiː˥'), + ('E', 'iː˥'), + ('F', 'e˥fuː˨˩'), + ('G', 'tsiː˥'), + ('H', 'ɪk̚˥tsʰyː˨˩'), + ('I', 'ɐi˥'), + ('J', 'tsei˥'), + ('K', 'kʰei˥'), + ('L', 'e˥llou˨˩'), + ('M', 'ɛːm˥'), + ('N', 'ɛːn˥'), + ('O', 'ou˥'), + ('P', 'pʰiː˥'), + ('Q', 'kʰiːu˥'), + ('R', 'aː˥lou˨˩'), + ('S', 'ɛː˥siː˨˩'), + ('T', 'tʰiː˥'), + ('U', 'juː˥'), + ('V', 'wiː˥'), + ('W', 'tʊk̚˥piː˥juː˥'), + ('X', 'ɪk̚˥siː˨˩'), + ('Y', 'waːi˥'), + ('Z', 'iː˨sɛːt̚˥') +]] + + +def number_to_cantonese(text): + return re.sub(r'\d+(?:\.?\d+)?', lambda x: cn2an.an2cn(x.group()), text) + + +def latin_to_ipa(text): + for regex, replacement in _latin_to_ipa: + text = re.sub(regex, replacement, text) + return text + + +def cantonese_to_ipa(text): + text = number_to_cantonese(text.upper()) + text = converter.convert(text).replace('-','').replace('$',' ') + text = re.sub(r'[A-Z]', lambda x: latin_to_ipa(x.group())+' ', text) + text = re.sub(r'[、；：]', '，', text) + text = re.sub(r'\s*，\s*', ', ', text) + text = re.sub(r'\s*。\s*', '. ', text) + text = re.sub(r'\s*？\s*', '? ', text) + text = re.sub(r'\s*！\s*', '! ', text) + text = re.sub(r'\s*$', '', text) + return text diff --git a/talkingface/utils/vits_utils/text/cleaners.py b/talkingface/utils/vits_utils/text/cleaners.py new file mode 100644 index 00000000..9cdf5493 --- /dev/null +++ b/talkingface/utils/vits_utils/text/cleaners.py @@ -0,0 +1,128 @@ +import re +# from text.japanese import japanese_to_romaji_with_accent, japanese_to_ipa, japanese_to_ipa2, japanese_to_ipa3 +from text.korean import latin_to_hangul, number_to_hangul, divide_hangul, korean_to_lazy_ipa, korean_to_ipa +from text.mandarin import number_to_chinese, chinese_to_bopomofo, latin_to_bopomofo, chinese_to_romaji, chinese_to_lazy_ipa, chinese_to_ipa, chinese_to_ipa2 +from text.sanskrit import devanagari_to_ipa +# from text.english import english_to_lazy_ipa, english_to_ipa2, english_to_lazy_ipa2 +from text.thai import num_to_thai, latin_to_thai +# from text.shanghainese import shanghainese_to_ipa +# from text.cantonese import cantonese_to_ipa +from text.ngu_dialect import ngu_dialect_to_ipa + + +def japanese_cleaners(text): + text = japanese_to_romaji_with_accent(text) + text = re.sub(r'([A-Za-z])$', r'\1.', text) + return text + + +def japanese_cleaners2(text): + return japanese_cleaners(text).replace('ts', 'ʦ').replace('...', '…') + + +def korean_cleaners(text): + '''Pipeline for Korean text''' + text = latin_to_hangul(text) + text = number_to_hangul(text) + text = divide_hangul(text) + text = re.sub(r'([\u3131-\u3163])$', r'\1.', text) + return text + + +def chinese_cleaners(text): + '''Pipeline for Chinese text''' + text = number_to_chinese(text) + text = chinese_to_bopomofo(text) + text = latin_to_bopomofo(text) + text = re.sub(r'([ˉˊˇˋ˙])$', r'\1。', text) + return text + + +def zh_ja_mixture_cleaners(text): + text = re.sub(r'\[ZH\](.*?)\[ZH\]', + lambda x: chinese_to_romaji(x.group(1))+' ', text) + text = re.sub(r'\[JA\](.*?)\[JA\]', lambda x: japanese_to_romaji_with_accent( + x.group(1)).replace('ts', 'ʦ').replace('u', 'ɯ').replace('...', '…')+' ', text) + text = re.sub(r'\s+$', '', text) + text = re.sub(r'([^\.,!\?\-…~])$', r'\1.', text) + return text + + +def sanskrit_cleaners(text): + text = text.replace('॥', '।').replace('ॐ', 'ओम्') + text = re.sub(r'([^।])$', r'\1।', text) + return text + + +def cjks_cleaners(text): + text = re.sub(r'\[ZH\](.*?)\[ZH\]', + lambda x: chinese_to_lazy_ipa(x.group(1))+' ', text) + text = re.sub(r'\[JA\](.*?)\[JA\]', + lambda x: japanese_to_ipa(x.group(1))+' ', text) + text = re.sub(r'\[KO\](.*?)\[KO\]', + lambda x: korean_to_lazy_ipa(x.group(1))+' ', text) + text = re.sub(r'\[SA\](.*?)\[SA\]', + lambda x: devanagari_to_ipa(x.group(1))+' ', text) + text = re.sub(r'\[EN\](.*?)\[EN\]', + lambda x: english_to_lazy_ipa(x.group(1))+' ', text) + text = re.sub(r'\s+$', '', text) + text = re.sub(r'([^\.,!\?\-…~])$', r'\1.', text) + return text + + +def cjke_cleaners(text): + text = re.sub(r'\[ZH\](.*?)\[ZH\]', lambda x: chinese_to_lazy_ipa(x.group(1)).replace( + 'ʧ', 'tʃ').replace('ʦ', 'ts').replace('ɥan', 'ɥæn')+' ', text) + text = re.sub(r'\[JA\](.*?)\[JA\]', lambda x: japanese_to_ipa(x.group(1)).replace('ʧ', 'tʃ').replace( + 'ʦ', 'ts').replace('ɥan', 'ɥæn').replace('ʥ', 'dz')+' ', text) + text = re.sub(r'\[KO\](.*?)\[KO\]', + lambda x: korean_to_ipa(x.group(1))+' ', text) + text = re.sub(r'\[EN\](.*?)\[EN\]', lambda x: english_to_ipa2(x.group(1)).replace('ɑ', 'a').replace( + 'ɔ', 'o').replace('ɛ', 'e').replace('ɪ', 'i').replace('ʊ', 'u')+' ', text) + text = re.sub(r'\s+$', '', text) + text = re.sub(r'([^\.,!\?\-…~])$', r'\1.', text) + return text + + +def cjke_cleaners2(text): + text = re.sub(r'\[ZH\](.*?)\[ZH\]', + lambda x: chinese_to_ipa(x.group(1))+' ', text) + text = re.sub(r'\[JA\](.*?)\[JA\]', + lambda x: japanese_to_ipa2(x.group(1))+' ', text) + text = re.sub(r'\[KO\](.*?)\[KO\]', + lambda x: korean_to_ipa(x.group(1))+' ', text) + text = re.sub(r'\[EN\](.*?)\[EN\]', + lambda x: english_to_ipa2(x.group(1))+' ', text) + text = re.sub(r'\s+$', '', text) + text = re.sub(r'([^\.,!\?\-…~])$', r'\1.', text) + return text + + +def thai_cleaners(text): + text = num_to_thai(text) + text = latin_to_thai(text) + return text + + +def shanghainese_cleaners(text): + text = shanghainese_to_ipa(text) + text = re.sub(r'([^\.,!\?\-…~])$', r'\1.', text) + return text + + +def chinese_dialect_cleaners(text): + text = re.sub(r'\[ZH\](.*?)\[ZH\]', + lambda x: chinese_to_ipa2(x.group(1))+' ', text) + text = re.sub(r'\[JA\](.*?)\[JA\]', + lambda x: japanese_to_ipa3(x.group(1)).replace('Q', 'ʔ')+' ', text) + text = re.sub(r'\[SH\](.*?)\[SH\]', lambda x: shanghainese_to_ipa(x.group(1)).replace('1', '˥˧').replace('5', + '˧˧˦').replace('6', '˩˩˧').replace('7', '˥').replace('8', '˩˨').replace('ᴀ', 'ɐ').replace('ᴇ', 'e')+' ', text) + text = re.sub(r'\[GD\](.*?)\[GD\]', + lambda x: cantonese_to_ipa(x.group(1))+' ', text) + text = re.sub(r'\[EN\](.*?)\[EN\]', + lambda x: english_to_lazy_ipa2(x.group(1))+' ', text) + text = re.sub(r'\[([A-Z]{2})\](.*?)\[\1\]', lambda x: ngu_dialect_to_ipa(x.group(2), x.group( + 1)).replace('ʣ', 'dz').replace('ʥ', 'dʑ').replace('ʦ', 'ts').replace('ʨ', 'tɕ')+' ', text) + text = re.sub(r'\s+$', '', text) + text = re.sub(r'([^\.,!\?\-…~])$', r'\1.', text) + return text diff --git a/talkingface/utils/vits_utils/text/english.py b/talkingface/utils/vits_utils/text/english.py new file mode 100644 index 00000000..6817392b --- /dev/null +++ b/talkingface/utils/vits_utils/text/english.py @@ -0,0 +1,188 @@ +""" from https://github.com/keithito/tacotron """ + +''' +Cleaners are transformations that run over the input text at both training and eval time. + +Cleaners can be selected by passing a comma-delimited list of cleaner names as the "cleaners" +hyperparameter. Some cleaners are English-specific. You'll typically want to use: + 1. "english_cleaners" for English text + 2. "transliteration_cleaners" for non-English text that can be transliterated to ASCII using + the Unidecode library (https://pypi.python.org/pypi/Unidecode) + 3. "basic_cleaners" if you do not want to transliterate (in this case, you should also update + the symbols in symbols.py to match your data). +''' + + +# Regular expression matching whitespace: + + +import re +import inflect +from unidecode import unidecode +import eng_to_ipa as ipa +_inflect = inflect.engine() +_comma_number_re = re.compile(r'([0-9][0-9\,]+[0-9])') +_decimal_number_re = re.compile(r'([0-9]+\.[0-9]+)') +_pounds_re = re.compile(r'£([0-9\,]*[0-9]+)') +_dollars_re = re.compile(r'\$([0-9\.\,]*[0-9]+)') +_ordinal_re = re.compile(r'[0-9]+(st|nd|rd|th)') +_number_re = re.compile(r'[0-9]+') + +# List of (regular expression, replacement) pairs for abbreviations: +_abbreviations = [(re.compile('\\b%s\\.' % x[0], re.IGNORECASE), x[1]) for x in [ + ('mrs', 'misess'), + ('mr', 'mister'), + ('dr', 'doctor'), + ('st', 'saint'), + ('co', 'company'), + ('jr', 'junior'), + ('maj', 'major'), + ('gen', 'general'), + ('drs', 'doctors'), + ('rev', 'reverend'), + ('lt', 'lieutenant'), + ('hon', 'honorable'), + ('sgt', 'sergeant'), + ('capt', 'captain'), + ('esq', 'esquire'), + ('ltd', 'limited'), + ('col', 'colonel'), + ('ft', 'fort'), +]] + + +# List of (ipa, lazy ipa) pairs: +_lazy_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('r', 'ɹ'), + ('æ', 'e'), + ('ɑ', 'a'), + ('ɔ', 'o'), + ('ð', 'z'), + ('θ', 's'), + ('ɛ', 'e'), + ('ɪ', 'i'), + ('ʊ', 'u'), + ('ʒ', 'ʥ'), + ('ʤ', 'ʥ'), + ('ˈ', '↓'), +]] + +# List of (ipa, lazy ipa2) pairs: +_lazy_ipa2 = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('r', 'ɹ'), + ('ð', 'z'), + ('θ', 's'), + ('ʒ', 'ʑ'), + ('ʤ', 'dʑ'), + ('ˈ', '↓'), +]] + +# List of (ipa, ipa2) pairs +_ipa_to_ipa2 = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('r', 'ɹ'), + ('ʤ', 'dʒ'), + ('ʧ', 'tʃ') +]] + + +def expand_abbreviations(text): + for regex, replacement in _abbreviations: + text = re.sub(regex, replacement, text) + return text + + +def collapse_whitespace(text): + return re.sub(r'\s+', ' ', text) + + +def _remove_commas(m): + return m.group(1).replace(',', '') + + +def _expand_decimal_point(m): + return m.group(1).replace('.', ' point ') + + +def _expand_dollars(m): + match = m.group(1) + parts = match.split('.') + if len(parts) > 2: + return match + ' dollars' # Unexpected format + dollars = int(parts[0]) if parts[0] else 0 + cents = int(parts[1]) if len(parts) > 1 and parts[1] else 0 + if dollars and cents: + dollar_unit = 'dollar' if dollars == 1 else 'dollars' + cent_unit = 'cent' if cents == 1 else 'cents' + return '%s %s, %s %s' % (dollars, dollar_unit, cents, cent_unit) + elif dollars: + dollar_unit = 'dollar' if dollars == 1 else 'dollars' + return '%s %s' % (dollars, dollar_unit) + elif cents: + cent_unit = 'cent' if cents == 1 else 'cents' + return '%s %s' % (cents, cent_unit) + else: + return 'zero dollars' + + +def _expand_ordinal(m): + return _inflect.number_to_words(m.group(0)) + + +def _expand_number(m): + num = int(m.group(0)) + if num > 1000 and num < 3000: + if num == 2000: + return 'two thousand' + elif num > 2000 and num < 2010: + return 'two thousand ' + _inflect.number_to_words(num % 100) + elif num % 100 == 0: + return _inflect.number_to_words(num // 100) + ' hundred' + else: + return _inflect.number_to_words(num, andword='', zero='oh', group=2).replace(', ', ' ') + else: + return _inflect.number_to_words(num, andword='') + + +def normalize_numbers(text): + text = re.sub(_comma_number_re, _remove_commas, text) + text = re.sub(_pounds_re, r'\1 pounds', text) + text = re.sub(_dollars_re, _expand_dollars, text) + text = re.sub(_decimal_number_re, _expand_decimal_point, text) + text = re.sub(_ordinal_re, _expand_ordinal, text) + text = re.sub(_number_re, _expand_number, text) + return text + + +def mark_dark_l(text): + return re.sub(r'l([^aeiouæɑɔəɛɪʊ ]*(?: |$))', lambda x: 'ɫ'+x.group(1), text) + + +def english_to_ipa(text): + text = unidecode(text).lower() + text = expand_abbreviations(text) + text = normalize_numbers(text) + phonemes = ipa.convert(text) + phonemes = collapse_whitespace(phonemes) + return phonemes + + +def english_to_lazy_ipa(text): + text = english_to_ipa(text) + for regex, replacement in _lazy_ipa: + text = re.sub(regex, replacement, text) + return text + + +def english_to_ipa2(text): + text = english_to_ipa(text) + text = mark_dark_l(text) + for regex, replacement in _ipa_to_ipa2: + text = re.sub(regex, replacement, text) + return text.replace('...', '…') + + +def english_to_lazy_ipa2(text): + text = english_to_ipa(text) + for regex, replacement in _lazy_ipa2: + text = re.sub(regex, replacement, text) + return text diff --git a/talkingface/utils/vits_utils/text/japanese.py b/talkingface/utils/vits_utils/text/japanese.py new file mode 100644 index 00000000..375e4d50 --- /dev/null +++ b/talkingface/utils/vits_utils/text/japanese.py @@ -0,0 +1,153 @@ +import re +from unidecode import unidecode +import pyopenjtalk + + +# Regular expression matching Japanese without punctuation marks: +_japanese_characters = re.compile( + r'[A-Za-z\d\u3005\u3040-\u30ff\u4e00-\u9fff\uff11-\uff19\uff21-\uff3a\uff41-\uff5a\uff66-\uff9d]') + +# Regular expression matching non-Japanese characters or punctuation marks: +_japanese_marks = re.compile( + r'[^A-Za-z\d\u3005\u3040-\u30ff\u4e00-\u9fff\uff11-\uff19\uff21-\uff3a\uff41-\uff5a\uff66-\uff9d]') + +# List of (symbol, Japanese) pairs for marks: +_symbols_to_japanese = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('％', 'パーセント') +]] + +# List of (romaji, ipa) pairs for marks: +_romaji_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('ts', 'ʦ'), + ('u', 'ɯ'), + ('j', 'ʥ'), + ('y', 'j'), + ('ni', 'n^i'), + ('nj', 'n^'), + ('hi', 'çi'), + ('hj', 'ç'), + ('f', 'ɸ'), + ('I', 'i*'), + ('U', 'ɯ*'), + ('r', 'ɾ') +]] + +# List of (romaji, ipa2) pairs for marks: +_romaji_to_ipa2 = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('u', 'ɯ'), + ('ʧ', 'tʃ'), + ('j', 'dʑ'), + ('y', 'j'), + ('ni', 'n^i'), + ('nj', 'n^'), + ('hi', 'çi'), + ('hj', 'ç'), + ('f', 'ɸ'), + ('I', 'i*'), + ('U', 'ɯ*'), + ('r', 'ɾ') +]] + +# List of (consonant, sokuon) pairs: +_real_sokuon = [(re.compile('%s' % x[0]), x[1]) for x in [ + (r'Q([↑↓]*[kg])', r'k#\1'), + (r'Q([↑↓]*[tdjʧ])', r't#\1'), + (r'Q([↑↓]*[sʃ])', r's\1'), + (r'Q([↑↓]*[pb])', r'p#\1') +]] + +# List of (consonant, hatsuon) pairs: +_real_hatsuon = [(re.compile('%s' % x[0]), x[1]) for x in [ + (r'N([↑↓]*[pbm])', r'm\1'), + (r'N([↑↓]*[ʧʥj])', r'n^\1'), + (r'N([↑↓]*[tdn])', r'n\1'), + (r'N([↑↓]*[kg])', r'ŋ\1') +]] + + +def symbols_to_japanese(text): + for regex, replacement in _symbols_to_japanese: + text = re.sub(regex, replacement, text) + return text + + +def japanese_to_romaji_with_accent(text): + '''Reference https://r9y9.github.io/ttslearn/latest/notebooks/ch10_Recipe-Tacotron.html''' + text = symbols_to_japanese(text) + sentences = re.split(_japanese_marks, text) + marks = re.findall(_japanese_marks, text) + text = '' + for i, sentence in enumerate(sentences): + if re.match(_japanese_characters, sentence): + if text != '': + text += ' ' + labels = pyopenjtalk.extract_fullcontext(sentence) + for n, label in enumerate(labels): + phoneme = re.search(r'\-([^\+]*)\+', label).group(1) + if phoneme not in ['sil', 'pau']: + text += phoneme.replace('ch', 'ʧ').replace('sh', + 'ʃ').replace('cl', 'Q') + else: + continue + # n_moras = int(re.search(r'/F:(\d+)_', label).group(1)) + a1 = int(re.search(r"/A:(\-?[0-9]+)\+", label).group(1)) + a2 = int(re.search(r"\+(\d+)\+", label).group(1)) + a3 = int(re.search(r"\+(\d+)/", label).group(1)) + if re.search(r'\-([^\+]*)\+', labels[n + 1]).group(1) in ['sil', 'pau']: + a2_next = -1 + else: + a2_next = int( + re.search(r"\+(\d+)\+", labels[n + 1]).group(1)) + # Accent phrase boundary + if a3 == 1 and a2_next == 1: + text += ' ' + # Falling + elif a1 == 0 and a2_next == a2 + 1: + text += '↓' + # Rising + elif a2 == 1 and a2_next == 2: + text += '↑' + if i < len(marks): + text += unidecode(marks[i]).replace(' ', '') + return text + + +def get_real_sokuon(text): + for regex, replacement in _real_sokuon: + text = re.sub(regex, replacement, text) + return text + + +def get_real_hatsuon(text): + for regex, replacement in _real_hatsuon: + text = re.sub(regex, replacement, text) + return text + + +def japanese_to_ipa(text): + text = japanese_to_romaji_with_accent(text).replace('...', '…') + text = re.sub( + r'([aiueo])\1+', lambda x: x.group(0)[0]+'ː'*(len(x.group(0))-1), text) + text = get_real_sokuon(text) + text = get_real_hatsuon(text) + for regex, replacement in _romaji_to_ipa: + text = re.sub(regex, replacement, text) + return text + + +def japanese_to_ipa2(text): + text = japanese_to_romaji_with_accent(text).replace('...', '…') + text = get_real_sokuon(text) + text = get_real_hatsuon(text) + for regex, replacement in _romaji_to_ipa2: + text = re.sub(regex, replacement, text) + return text + + +def japanese_to_ipa3(text): + text = japanese_to_ipa2(text).replace('n^', 'ȵ').replace( + 'ʃ', 'ɕ').replace('*', '\u0325').replace('#', '\u031a') + text = re.sub( + r'([aiɯeo])\1+', lambda x: x.group(0)[0]+'ː'*(len(x.group(0))-1), text) + text = re.sub(r'((?:^|\s)(?:ts|tɕ|[kpt]))', r'\1ʰ', text) + return text diff --git a/talkingface/utils/vits_utils/text/korean.py b/talkingface/utils/vits_utils/text/korean.py new file mode 100644 index 00000000..edee0742 --- /dev/null +++ b/talkingface/utils/vits_utils/text/korean.py @@ -0,0 +1,210 @@ +import re +from jamo import h2j, j2hcj +import ko_pron + + +# This is a list of Korean classifiers preceded by pure Korean numerals. +_korean_classifiers = '군데 권 개 그루 닢 대 두 마리 모 모금 뭇 발 발짝 방 번 벌 보루 살 수 술 시 쌈 움큼 정 짝 채 척 첩 축 켤레 톨 통' + +# List of (hangul, hangul divided) pairs: +_hangul_divided = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('ㄳ', 'ㄱㅅ'), + ('ㄵ', 'ㄴㅈ'), + ('ㄶ', 'ㄴㅎ'), + ('ㄺ', 'ㄹㄱ'), + ('ㄻ', 'ㄹㅁ'), + ('ㄼ', 'ㄹㅂ'), + ('ㄽ', 'ㄹㅅ'), + ('ㄾ', 'ㄹㅌ'), + ('ㄿ', 'ㄹㅍ'), + ('ㅀ', 'ㄹㅎ'), + ('ㅄ', 'ㅂㅅ'), + ('ㅘ', 'ㅗㅏ'), + ('ㅙ', 'ㅗㅐ'), + ('ㅚ', 'ㅗㅣ'), + ('ㅝ', 'ㅜㅓ'), + ('ㅞ', 'ㅜㅔ'), + ('ㅟ', 'ㅜㅣ'), + ('ㅢ', 'ㅡㅣ'), + ('ㅑ', 'ㅣㅏ'), + ('ㅒ', 'ㅣㅐ'), + ('ㅕ', 'ㅣㅓ'), + ('ㅖ', 'ㅣㅔ'), + ('ㅛ', 'ㅣㅗ'), + ('ㅠ', 'ㅣㅜ') +]] + +# List of (Latin alphabet, hangul) pairs: +_latin_to_hangul = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [ + ('a', '에이'), + ('b', '비'), + ('c', '시'), + ('d', '디'), + ('e', '이'), + ('f', '에프'), + ('g', '지'), + ('h', '에이치'), + ('i', '아이'), + ('j', '제이'), + ('k', '케이'), + ('l', '엘'), + ('m', '엠'), + ('n', '엔'), + ('o', '오'), + ('p', '피'), + ('q', '큐'), + ('r', '아르'), + ('s', '에스'), + ('t', '티'), + ('u', '유'), + ('v', '브이'), + ('w', '더블유'), + ('x', '엑스'), + ('y', '와이'), + ('z', '제트') +]] + +# List of (ipa, lazy ipa) pairs: +_ipa_to_lazy_ipa = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [ + ('t͡ɕ','ʧ'), + ('d͡ʑ','ʥ'), + ('ɲ','n^'), + ('ɕ','ʃ'), + ('ʷ','w'), + ('ɭ','l`'), + ('ʎ','ɾ'), + ('ɣ','ŋ'), + ('ɰ','ɯ'), + ('ʝ','j'), + ('ʌ','ə'), + ('ɡ','g'), + ('\u031a','#'), + ('\u0348','='), + ('\u031e',''), + ('\u0320',''), + ('\u0339','') +]] + + +def latin_to_hangul(text): + for regex, replacement in _latin_to_hangul: + text = re.sub(regex, replacement, text) + return text + + +def divide_hangul(text): + text = j2hcj(h2j(text)) + for regex, replacement in _hangul_divided: + text = re.sub(regex, replacement, text) + return text + + +def hangul_number(num, sino=True): + '''Reference https://github.com/Kyubyong/g2pK''' + num = re.sub(',', '', num) + + if num == '0': + return '영' + if not sino and num == '20': + return '스무' + + digits = '123456789' + names = '일이삼사오육칠팔구' + digit2name = {d: n for d, n in zip(digits, names)} + + modifiers = '한 두 세 네 다섯 여섯 일곱 여덟 아홉' + decimals = '열 스물 서른 마흔 쉰 예순 일흔 여든 아흔' + digit2mod = {d: mod for d, mod in zip(digits, modifiers.split())} + digit2dec = {d: dec for d, dec in zip(digits, decimals.split())} + + spelledout = [] + for i, digit in enumerate(num): + i = len(num) - i - 1 + if sino: + if i == 0: + name = digit2name.get(digit, '') + elif i == 1: + name = digit2name.get(digit, '') + '십' + name = name.replace('일십', '십') + else: + if i == 0: + name = digit2mod.get(digit, '') + elif i == 1: + name = digit2dec.get(digit, '') + if digit == '0': + if i % 4 == 0: + last_three = spelledout[-min(3, len(spelledout)):] + if ''.join(last_three) == '': + spelledout.append('') + continue + else: + spelledout.append('') + continue + if i == 2: + name = digit2name.get(digit, '') + '백' + name = name.replace('일백', '백') + elif i == 3: + name = digit2name.get(digit, '') + '천' + name = name.replace('일천', '천') + elif i == 4: + name = digit2name.get(digit, '') + '만' + name = name.replace('일만', '만') + elif i == 5: + name = digit2name.get(digit, '') + '십' + name = name.replace('일십', '십') + elif i == 6: + name = digit2name.get(digit, '') + '백' + name = name.replace('일백', '백') + elif i == 7: + name = digit2name.get(digit, '') + '천' + name = name.replace('일천', '천') + elif i == 8: + name = digit2name.get(digit, '') + '억' + elif i == 9: + name = digit2name.get(digit, '') + '십' + elif i == 10: + name = digit2name.get(digit, '') + '백' + elif i == 11: + name = digit2name.get(digit, '') + '천' + elif i == 12: + name = digit2name.get(digit, '') + '조' + elif i == 13: + name = digit2name.get(digit, '') + '십' + elif i == 14: + name = digit2name.get(digit, '') + '백' + elif i == 15: + name = digit2name.get(digit, '') + '천' + spelledout.append(name) + return ''.join(elem for elem in spelledout) + + +def number_to_hangul(text): + '''Reference https://github.com/Kyubyong/g2pK''' + tokens = set(re.findall(r'(\d[\d,]*)([\uac00-\ud71f]+)', text)) + for token in tokens: + num, classifier = token + if classifier[:2] in _korean_classifiers or classifier[0] in _korean_classifiers: + spelledout = hangul_number(num, sino=False) + else: + spelledout = hangul_number(num, sino=True) + text = text.replace(f'{num}{classifier}', f'{spelledout}{classifier}') + # digit by digit for remaining digits + digits = '0123456789' + names = '영일이삼사오육칠팔구' + for d, n in zip(digits, names): + text = text.replace(d, n) + return text + + +def korean_to_lazy_ipa(text): + text = latin_to_hangul(text) + text = number_to_hangul(text) + text=re.sub('[\uac00-\ud7af]+',lambda x:ko_pron.romanise(x.group(0),'ipa').split('] ~ [')[0],text) + for regex, replacement in _ipa_to_lazy_ipa: + text = re.sub(regex, replacement, text) + return text + + +def korean_to_ipa(text): + text = korean_to_lazy_ipa(text) + return text.replace('ʧ','tʃ').replace('ʥ','dʑ') diff --git a/talkingface/utils/vits_utils/text/mandarin.py b/talkingface/utils/vits_utils/text/mandarin.py new file mode 100644 index 00000000..162e1b91 --- /dev/null +++ b/talkingface/utils/vits_utils/text/mandarin.py @@ -0,0 +1,326 @@ +import os +import sys +import re +from pypinyin import lazy_pinyin, BOPOMOFO +import jieba +import cn2an +import logging + + +# List of (Latin alphabet, bopomofo) pairs: +_latin_to_bopomofo = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [ + ('a', 'ㄟˉ'), + ('b', 'ㄅㄧˋ'), + ('c', 'ㄙㄧˉ'), + ('d', 'ㄉㄧˋ'), + ('e', 'ㄧˋ'), + ('f', 'ㄝˊㄈㄨˋ'), + ('g', 'ㄐㄧˋ'), + ('h', 'ㄝˇㄑㄩˋ'), + ('i', 'ㄞˋ'), + ('j', 'ㄐㄟˋ'), + ('k', 'ㄎㄟˋ'), + ('l', 'ㄝˊㄛˋ'), + ('m', 'ㄝˊㄇㄨˋ'), + ('n', 'ㄣˉ'), + ('o', 'ㄡˉ'), + ('p', 'ㄆㄧˉ'), + ('q', 'ㄎㄧㄡˉ'), + ('r', 'ㄚˋ'), + ('s', 'ㄝˊㄙˋ'), + ('t', 'ㄊㄧˋ'), + ('u', 'ㄧㄡˉ'), + ('v', 'ㄨㄧˉ'), + ('w', 'ㄉㄚˋㄅㄨˋㄌㄧㄡˋ'), + ('x', 'ㄝˉㄎㄨˋㄙˋ'), + ('y', 'ㄨㄞˋ'), + ('z', 'ㄗㄟˋ') +]] + +# List of (bopomofo, romaji) pairs: +_bopomofo_to_romaji = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('ㄅㄛ', 'p⁼wo'), + ('ㄆㄛ', 'pʰwo'), + ('ㄇㄛ', 'mwo'), + ('ㄈㄛ', 'fwo'), + ('ㄅ', 'p⁼'), + ('ㄆ', 'pʰ'), + ('ㄇ', 'm'), + ('ㄈ', 'f'), + ('ㄉ', 't⁼'), + ('ㄊ', 'tʰ'), + ('ㄋ', 'n'), + ('ㄌ', 'l'), + ('ㄍ', 'k⁼'), + ('ㄎ', 'kʰ'), + ('ㄏ', 'h'), + ('ㄐ', 'ʧ⁼'), + ('ㄑ', 'ʧʰ'), + ('ㄒ', 'ʃ'), + ('ㄓ', 'ʦ`⁼'), + ('ㄔ', 'ʦ`ʰ'), + ('ㄕ', 's`'), + ('ㄖ', 'ɹ`'), + ('ㄗ', 'ʦ⁼'), + ('ㄘ', 'ʦʰ'), + ('ㄙ', 's'), + ('ㄚ', 'a'), + ('ㄛ', 'o'), + ('ㄜ', 'ə'), + ('ㄝ', 'e'), + ('ㄞ', 'ai'), + ('ㄟ', 'ei'), + ('ㄠ', 'au'), + ('ㄡ', 'ou'), + ('ㄧㄢ', 'yeNN'), + ('ㄢ', 'aNN'), + ('ㄧㄣ', 'iNN'), + ('ㄣ', 'əNN'), + ('ㄤ', 'aNg'), + ('ㄧㄥ', 'iNg'), + ('ㄨㄥ', 'uNg'), + ('ㄩㄥ', 'yuNg'), + ('ㄥ', 'əNg'), + ('ㄦ', 'əɻ'), + ('ㄧ', 'i'), + ('ㄨ', 'u'), + ('ㄩ', 'ɥ'), + ('ˉ', '→'), + ('ˊ', '↑'), + ('ˇ', '↓↑'), + ('ˋ', '↓'), + ('˙', ''), + ('，', ','), + ('。', '.'), + ('！', '!'), + ('？', '?'), + ('—', '-') +]] + +# List of (romaji, ipa) pairs: +_romaji_to_ipa = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [ + ('ʃy', 'ʃ'), + ('ʧʰy', 'ʧʰ'), + ('ʧ⁼y', 'ʧ⁼'), + ('NN', 'n'), + ('Ng', 'ŋ'), + ('y', 'j'), + ('h', 'x') +]] + +# List of (bopomofo, ipa) pairs: +_bopomofo_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('ㄅㄛ', 'p⁼wo'), + ('ㄆㄛ', 'pʰwo'), + ('ㄇㄛ', 'mwo'), + ('ㄈㄛ', 'fwo'), + ('ㄅ', 'p⁼'), + ('ㄆ', 'pʰ'), + ('ㄇ', 'm'), + ('ㄈ', 'f'), + ('ㄉ', 't⁼'), + ('ㄊ', 'tʰ'), + ('ㄋ', 'n'), + ('ㄌ', 'l'), + ('ㄍ', 'k⁼'), + ('ㄎ', 'kʰ'), + ('ㄏ', 'x'), + ('ㄐ', 'tʃ⁼'), + ('ㄑ', 'tʃʰ'), + ('ㄒ', 'ʃ'), + ('ㄓ', 'ts`⁼'), + ('ㄔ', 'ts`ʰ'), + ('ㄕ', 's`'), + ('ㄖ', 'ɹ`'), + ('ㄗ', 'ts⁼'), + ('ㄘ', 'tsʰ'), + ('ㄙ', 's'), + ('ㄚ', 'a'), + ('ㄛ', 'o'), + ('ㄜ', 'ə'), + ('ㄝ', 'ɛ'), + ('ㄞ', 'aɪ'), + ('ㄟ', 'eɪ'), + ('ㄠ', 'ɑʊ'), + ('ㄡ', 'oʊ'), + ('ㄧㄢ', 'jɛn'), + ('ㄩㄢ', 'ɥæn'), + ('ㄢ', 'an'), + ('ㄧㄣ', 'in'), + ('ㄩㄣ', 'ɥn'), + ('ㄣ', 'ən'), + ('ㄤ', 'ɑŋ'), + ('ㄧㄥ', 'iŋ'), + ('ㄨㄥ', 'ʊŋ'), + ('ㄩㄥ', 'jʊŋ'), + ('ㄥ', 'əŋ'), + ('ㄦ', 'əɻ'), + ('ㄧ', 'i'), + ('ㄨ', 'u'), + ('ㄩ', 'ɥ'), + ('ˉ', '→'), + ('ˊ', '↑'), + ('ˇ', '↓↑'), + ('ˋ', '↓'), + ('˙', ''), + ('，', ','), + ('。', '.'), + ('！', '!'), + ('？', '?'), + ('—', '-') +]] + +# List of (bopomofo, ipa2) pairs: +_bopomofo_to_ipa2 = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('ㄅㄛ', 'pwo'), + ('ㄆㄛ', 'pʰwo'), + ('ㄇㄛ', 'mwo'), + ('ㄈㄛ', 'fwo'), + ('ㄅ', 'p'), + ('ㄆ', 'pʰ'), + ('ㄇ', 'm'), + ('ㄈ', 'f'), + ('ㄉ', 't'), + ('ㄊ', 'tʰ'), + ('ㄋ', 'n'), + ('ㄌ', 'l'), + ('ㄍ', 'k'), + ('ㄎ', 'kʰ'), + ('ㄏ', 'h'), + ('ㄐ', 'tɕ'), + ('ㄑ', 'tɕʰ'), + ('ㄒ', 'ɕ'), + ('ㄓ', 'tʂ'), + ('ㄔ', 'tʂʰ'), + ('ㄕ', 'ʂ'), + ('ㄖ', 'ɻ'), + ('ㄗ', 'ts'), + ('ㄘ', 'tsʰ'), + ('ㄙ', 's'), + ('ㄚ', 'a'), + ('ㄛ', 'o'), + ('ㄜ', 'ɤ'), + ('ㄝ', 'ɛ'), + ('ㄞ', 'aɪ'), + ('ㄟ', 'eɪ'), + ('ㄠ', 'ɑʊ'), + ('ㄡ', 'oʊ'), + ('ㄧㄢ', 'jɛn'), + ('ㄩㄢ', 'yæn'), + ('ㄢ', 'an'), + ('ㄧㄣ', 'in'), + ('ㄩㄣ', 'yn'), + ('ㄣ', 'ən'), + ('ㄤ', 'ɑŋ'), + ('ㄧㄥ', 'iŋ'), + ('ㄨㄥ', 'ʊŋ'), + ('ㄩㄥ', 'jʊŋ'), + ('ㄥ', 'ɤŋ'), + ('ㄦ', 'əɻ'), + ('ㄧ', 'i'), + ('ㄨ', 'u'), + ('ㄩ', 'y'), + ('ˉ', '˥'), + ('ˊ', '˧˥'), + ('ˇ', '˨˩˦'), + ('ˋ', '˥˩'), + ('˙', ''), + ('，', ','), + ('。', '.'), + ('！', '!'), + ('？', '?'), + ('—', '-') +]] + + +def number_to_chinese(text): + numbers = re.findall(r'\d+(?:\.?\d+)?', text) + for number in numbers: + text = text.replace(number, cn2an.an2cn(number), 1) + return text + + +def chinese_to_bopomofo(text): + text = text.replace('、', '，').replace('；', '，').replace('：', '，') + words = jieba.lcut(text, cut_all=False) + text = '' + for word in words: + bopomofos = lazy_pinyin(word, BOPOMOFO) + if not re.search('[\u4e00-\u9fff]', word): + text += word + continue + for i in range(len(bopomofos)): + bopomofos[i] = re.sub(r'([\u3105-\u3129])$', r'\1ˉ', bopomofos[i]) + if text != '': + text += ' ' + text += ''.join(bopomofos) + return text + + +def latin_to_bopomofo(text): + for regex, replacement in _latin_to_bopomofo: + text = re.sub(regex, replacement, text) + return text + + +def bopomofo_to_romaji(text): + for regex, replacement in _bopomofo_to_romaji: + text = re.sub(regex, replacement, text) + return text + + +def bopomofo_to_ipa(text): + for regex, replacement in _bopomofo_to_ipa: + text = re.sub(regex, replacement, text) + return text + + +def bopomofo_to_ipa2(text): + for regex, replacement in _bopomofo_to_ipa2: + text = re.sub(regex, replacement, text) + return text + + +def chinese_to_romaji(text): + text = number_to_chinese(text) + text = chinese_to_bopomofo(text) + text = latin_to_bopomofo(text) + text = bopomofo_to_romaji(text) + text = re.sub('i([aoe])', r'y\1', text) + text = re.sub('u([aoəe])', r'w\1', text) + text = re.sub('([ʦsɹ]`[⁼ʰ]?)([→↓↑ ]+|$)', + r'\1ɹ`\2', text).replace('ɻ', 'ɹ`') + text = re.sub('([ʦs][⁼ʰ]?)([→↓↑ ]+|$)', r'\1ɹ\2', text) + return text + + +def chinese_to_lazy_ipa(text): + text = chinese_to_romaji(text) + for regex, replacement in _romaji_to_ipa: + text = re.sub(regex, replacement, text) + return text + + +def chinese_to_ipa(text): + text = number_to_chinese(text) + text = chinese_to_bopomofo(text) + text = latin_to_bopomofo(text) + text = bopomofo_to_ipa(text) + text = re.sub('i([aoe])', r'j\1', text) + text = re.sub('u([aoəe])', r'w\1', text) + text = re.sub('([sɹ]`[⁼ʰ]?)([→↓↑ ]+|$)', + r'\1ɹ`\2', text).replace('ɻ', 'ɹ`') + text = re.sub('([s][⁼ʰ]?)([→↓↑ ]+|$)', r'\1ɹ\2', text) + return text + + +def chinese_to_ipa2(text): + text = number_to_chinese(text) + text = chinese_to_bopomofo(text) + text = latin_to_bopomofo(text) + text = bopomofo_to_ipa2(text) + text = re.sub(r'i([aoe])', r'j\1', text) + text = re.sub(r'u([aoəe])', r'w\1', text) + text = re.sub(r'([ʂɹ]ʰ?)([˩˨˧˦˥ ]+|$)', r'\1ʅ\2', text) + text = re.sub(r'(sʰ?)([˩˨˧˦˥ ]+|$)', r'\1ɿ\2', text) + return text diff --git a/talkingface/utils/vits_utils/text/ngu_dialect.py b/talkingface/utils/vits_utils/text/ngu_dialect.py new file mode 100644 index 00000000..ce3e12bb --- /dev/null +++ b/talkingface/utils/vits_utils/text/ngu_dialect.py @@ -0,0 +1,30 @@ +import re +import opencc + + +dialects = {'SZ': 'suzhou', 'WX': 'wuxi', 'CZ': 'changzhou', 'HZ': 'hangzhou', + 'SX': 'shaoxing', 'NB': 'ningbo', 'JJ': 'jingjiang', 'YX': 'yixing', + 'JD': 'jiading', 'ZR': 'zhenru', 'PH': 'pinghu', 'TX': 'tongxiang', + 'JS': 'jiashan', 'HN': 'xiashi', 'LP': 'linping', 'XS': 'xiaoshan', + 'FY': 'fuyang', 'RA': 'ruao', 'CX': 'cixi', 'SM': 'sanmen', + 'TT': 'tiantai', 'WZ': 'wenzhou', 'SC': 'suichang', 'YB': 'youbu'} + +converters = {} + +for dialect in dialects.values(): + try: + converters[dialect] = opencc.OpenCC(dialect) + except: + pass + + +def ngu_dialect_to_ipa(text, dialect): + dialect = dialects[dialect] + text = converters[dialect].convert(text).replace('-','').replace('$',' ') + text = re.sub(r'[、；：]', '，', text) + text = re.sub(r'\s*，\s*', ', ', text) + text = re.sub(r'\s*。\s*', '. ', text) + text = re.sub(r'\s*？\s*', '? ', text) + text = re.sub(r'\s*！\s*', '! ', text) + text = re.sub(r'\s*$', '', text) + return text diff --git a/talkingface/utils/vits_utils/text/sanskrit.py b/talkingface/utils/vits_utils/text/sanskrit.py new file mode 100644 index 00000000..0223aaac --- /dev/null +++ b/talkingface/utils/vits_utils/text/sanskrit.py @@ -0,0 +1,62 @@ +import re +from indic_transliteration import sanscript + + +# List of (iast, ipa) pairs: +_iast_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('a', 'ə'), + ('ā', 'aː'), + ('ī', 'iː'), + ('ū', 'uː'), + ('ṛ', 'ɹ`'), + ('ṝ', 'ɹ`ː'), + ('ḷ', 'l`'), + ('ḹ', 'l`ː'), + ('e', 'eː'), + ('o', 'oː'), + ('k', 'k⁼'), + ('k⁼h', 'kʰ'), + ('g', 'g⁼'), + ('g⁼h', 'gʰ'), + ('ṅ', 'ŋ'), + ('c', 'ʧ⁼'), + ('ʧ⁼h', 'ʧʰ'), + ('j', 'ʥ⁼'), + ('ʥ⁼h', 'ʥʰ'), + ('ñ', 'n^'), + ('ṭ', 't`⁼'), + ('t`⁼h', 't`ʰ'), + ('ḍ', 'd`⁼'), + ('d`⁼h', 'd`ʰ'), + ('ṇ', 'n`'), + ('t', 't⁼'), + ('t⁼h', 'tʰ'), + ('d', 'd⁼'), + ('d⁼h', 'dʰ'), + ('p', 'p⁼'), + ('p⁼h', 'pʰ'), + ('b', 'b⁼'), + ('b⁼h', 'bʰ'), + ('y', 'j'), + ('ś', 'ʃ'), + ('ṣ', 's`'), + ('r', 'ɾ'), + ('l̤', 'l`'), + ('h', 'ɦ'), + ("'", ''), + ('~', '^'), + ('ṃ', '^') +]] + + +def devanagari_to_ipa(text): + text = text.replace('ॐ', 'ओम्') + text = re.sub(r'\s*।\s*$', '.', text) + text = re.sub(r'\s*।\s*', ', ', text) + text = re.sub(r'\s*॥', '.', text) + text = sanscript.transliterate(text, sanscript.DEVANAGARI, sanscript.IAST) + for regex, replacement in _iast_to_ipa: + text = re.sub(regex, replacement, text) + text = re.sub('(.)[`ː]*ḥ', lambda x: x.group(0) + [:-1]+'h'+x.group(1)+'*', text) + return text diff --git a/talkingface/utils/vits_utils/text/shanghainese.py b/talkingface/utils/vits_utils/text/shanghainese.py new file mode 100644 index 00000000..cb29c24a --- /dev/null +++ b/talkingface/utils/vits_utils/text/shanghainese.py @@ -0,0 +1,64 @@ +import re +import cn2an +import opencc + + +converter = opencc.OpenCC('zaonhe') + +# List of (Latin alphabet, ipa) pairs: +_latin_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [ + ('A', 'ᴇ'), + ('B', 'bi'), + ('C', 'si'), + ('D', 'di'), + ('E', 'i'), + ('F', 'ᴇf'), + ('G', 'dʑi'), + ('H', 'ᴇtɕʰ'), + ('I', 'ᴀi'), + ('J', 'dʑᴇ'), + ('K', 'kʰᴇ'), + ('L', 'ᴇl'), + ('M', 'ᴇm'), + ('N', 'ᴇn'), + ('O', 'o'), + ('P', 'pʰi'), + ('Q', 'kʰiu'), + ('R', 'ᴀl'), + ('S', 'ᴇs'), + ('T', 'tʰi'), + ('U', 'ɦiu'), + ('V', 'vi'), + ('W', 'dᴀbɤliu'), + ('X', 'ᴇks'), + ('Y', 'uᴀi'), + ('Z', 'zᴇ') +]] + + +def _number_to_shanghainese(num): + num = cn2an.an2cn(num).replace('一十','十').replace('二十', '廿').replace('二', '两') + return re.sub(r'((?:^|[^三四五六七八九])十|廿)两', r'\1二', num) + + +def number_to_shanghainese(text): + return re.sub(r'\d+(?:\.?\d+)?', lambda x: _number_to_shanghainese(x.group()), text) + + +def latin_to_ipa(text): + for regex, replacement in _latin_to_ipa: + text = re.sub(regex, replacement, text) + return text + + +def shanghainese_to_ipa(text): + text = number_to_shanghainese(text.upper()) + text = converter.convert(text).replace('-','').replace('$',' ') + text = re.sub(r'[A-Z]', lambda x: latin_to_ipa(x.group())+' ', text) + text = re.sub(r'[、；：]', '，', text) + text = re.sub(r'\s*，\s*', ', ', text) + text = re.sub(r'\s*。\s*', '. ', text) + text = re.sub(r'\s*？\s*', '? ', text) + text = re.sub(r'\s*！\s*', '! ', text) + text = re.sub(r'\s*$', '', text) + return text diff --git a/talkingface/utils/vits_utils/text/symbols.py b/talkingface/utils/vits_utils/text/symbols.py new file mode 100644 index 00000000..77e33df3 --- /dev/null +++ b/talkingface/utils/vits_utils/text/symbols.py @@ -0,0 +1,75 @@ +''' +Defines the set of symbols used in text input to the model. +''' + +'''# japanese_cleaners +_pad = '_' +_punctuation = ',.!?-' +_letters = 'AEINOQUabdefghijkmnoprstuvwyzʃʧ↓↑ ' +''' + +'''# japanese_cleaners2 +_pad = '_' +_punctuation = ',.!?-~…' +_letters = 'AEINOQUabdefghijkmnoprstuvwyzʃʧʦ↓↑ ' +''' + +'''# korean_cleaners +_pad = '_' +_punctuation = ',.!?…~' +_letters = 'ㄱㄴㄷㄹㅁㅂㅅㅇㅈㅊㅋㅌㅍㅎㄲㄸㅃㅆㅉㅏㅓㅗㅜㅡㅣㅐㅔ ' +''' + +'''# chinese_cleaners +_pad = '_' +_punctuation = '，。！？—…' +_letters = 'ㄅㄆㄇㄈㄉㄊㄋㄌㄍㄎㄏㄐㄑㄒㄓㄔㄕㄖㄗㄘㄙㄚㄛㄜㄝㄞㄟㄠㄡㄢㄣㄤㄥㄦㄧㄨㄩˉˊˇˋ˙ ' +''' + +'''# zh_ja_mixture_cleaners +_pad = '_' +_punctuation = ',.!?-~…' +_letters = 'AEINOQUabdefghijklmnoprstuvwyzʃʧʦɯɹəɥ⁼ʰ`→↓↑ ' +''' + +'''# sanskrit_cleaners +_pad = '_' +_punctuation = '।' +_letters = 'ँंःअआइईउऊऋएऐओऔकखगघङचछजझञटठडढणतथदधनपफबभमयरलळवशषसहऽािीुूृॄेैोौ्ॠॢ ' +''' + +'''# cjks_cleaners +_pad = '_' +_punctuation = ',.!?-~…' +_letters = 'NQabdefghijklmnopstuvwxyzʃʧʥʦɯɹəɥçɸɾβŋɦː⁼ʰ`^#*=→↓↑ ' +''' + +'''# thai_cleaners +_pad = '_' +_punctuation = '.!? ' +_letters = 'กขฃคฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลวศษสหฬอฮฯะัาำิีึืุูเแโใไๅๆ็่้๊๋์' +''' + +# cjke_cleaners2 +_pad = '_' +_punctuation = ',.!?-~…' +_letters = 'NQabdefghijklmnopstuvwxyzɑæʃʑçɯɪɔɛɹðəɫɥɸʊɾʒθβŋɦ⁼ʰ`^#*=ˈˌ→↓↑ ' + + +'''# shanghainese_cleaners +_pad = '_' +_punctuation = ',.!?…' +_letters = 'abdfghiklmnopstuvyzøŋȵɑɔɕəɤɦɪɿʑʔʰ̩̃ᴀᴇ15678 ' +''' + +'''# chinese_dialect_cleaners +_pad = '_' +_punctuation = ',.!?~…─' +_letters = '#Nabdefghijklmnoprstuvwxyzæçøŋœȵɐɑɒɓɔɕɗɘəɚɛɜɣɤɦɪɭɯɵɷɸɻɾɿʂʅʊʋʌʏʑʔʦʮʰʷˀː˥˦˧˨˩̥̩̃̚ᴀᴇ↑↓∅ⱼ ' +''' + +# Export all symbols: +symbols = [_pad] + list(_punctuation) + list(_letters) + +# Special symbol ids +SPACE_ID = symbols.index(" ") diff --git a/talkingface/utils/vits_utils/text/thai.py b/talkingface/utils/vits_utils/text/thai.py new file mode 100644 index 00000000..998207c0 --- /dev/null +++ b/talkingface/utils/vits_utils/text/thai.py @@ -0,0 +1,44 @@ +import re +from num_thai.thainumbers import NumThai + + +num = NumThai() + +# List of (Latin alphabet, Thai) pairs: +_latin_to_thai = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [ + ('a', 'เอ'), + ('b','บี'), + ('c','ซี'), + ('d','ดี'), + ('e','อี'), + ('f','เอฟ'), + ('g','จี'), + ('h','เอช'), + ('i','ไอ'), + ('j','เจ'), + ('k','เค'), + ('l','แอล'), + ('m','เอ็ม'), + ('n','เอ็น'), + ('o','โอ'), + ('p','พี'), + ('q','คิว'), + ('r','แอร์'), + ('s','เอส'), + ('t','ที'), + ('u','ยู'), + ('v','วี'), + ('w','ดับเบิลยู'), + ('x','เอ็กซ์'), + ('y','วาย'), + ('z','ซี') +]] + + +def num_to_thai(text): + return re.sub(r'(?:\d+(?:,?\d+)?)+(?:\.\d+(?:,?\d+)?)?', lambda x: ''.join(num.NumberToTextThai(float(x.group(0).replace(',', '')))), text) + +def latin_to_thai(text): + for regex, replacement in _latin_to_thai: + text = re.sub(regex, replacement, text) + return text diff --git a/talkingface/utils/vits_utils/transforms.py b/talkingface/utils/vits_utils/transforms.py new file mode 100644 index 00000000..4793d67c --- /dev/null +++ b/talkingface/utils/vits_utils/transforms.py @@ -0,0 +1,193 @@ +import torch +from torch.nn import functional as F + +import numpy as np + + +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., + 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 + 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., + 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 + + 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., right=1., bottom=0., top=1., + 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 + 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 + 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() + + 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 + else: + 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/talkingface/utils/vits_utils/utils.py b/talkingface/utils/vits_utils/utils.py new file mode 100644 index 00000000..2daf3c6f --- /dev/null +++ b/talkingface/utils/vits_utils/utils.py @@ -0,0 +1,258 @@ +import os +import glob +import sys +import argparse +import logging +import json +import subprocess +import numpy as np +from scipy.io.wavfile import read +import torch + +MATPLOTLIB_FLAG = False + +logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) +logger = logging + + +def load_checkpoint(checkpoint_path, model, optimizer=None): + assert os.path.isfile(checkpoint_path) + checkpoint_dict = torch.load(checkpoint_path, map_location='cpu') + iteration = checkpoint_dict['iteration'] + learning_rate = checkpoint_dict['learning_rate'] + if optimizer is not None: + optimizer.load_state_dict(checkpoint_dict['optimizer']) + saved_state_dict = checkpoint_dict['model'] + if hasattr(model, 'module'): + state_dict = model.module.state_dict() + else: + state_dict = model.state_dict() + new_state_dict= {} + for k, v in state_dict.items(): + try: + new_state_dict[k] = saved_state_dict[k] + except: + logger.info("%s is not in the checkpoint" % k) + new_state_dict[k] = v + if hasattr(model, 'module'): + model.module.load_state_dict(new_state_dict) + else: + model.load_state_dict(new_state_dict) + logger.info("Loaded checkpoint '{}' (iteration {})" .format( + checkpoint_path, iteration)) + return model, optimizer, learning_rate, iteration + + +def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path): + logger.info("Saving model and optimizer state at iteration {} to {}".format( + iteration, checkpoint_path)) + if hasattr(model, 'module'): + state_dict = model.module.state_dict() + else: + state_dict = model.state_dict() + torch.save({'model': state_dict, + 'iteration': iteration, + 'optimizer': optimizer.state_dict(), + 'learning_rate': learning_rate}, checkpoint_path) + + +def summarize(writer, global_step, scalars={}, histograms={}, images={}, audios={}, audio_sampling_rate=22050): + for k, v in scalars.items(): + writer.add_scalar(k, v, global_step) + for k, v in histograms.items(): + writer.add_histogram(k, v, global_step) + for k, v in images.items(): + writer.add_image(k, v, global_step, dataformats='HWC') + for k, v in audios.items(): + writer.add_audio(k, v, global_step, audio_sampling_rate) + + +def latest_checkpoint_path(dir_path, regex="G_*.pth"): + f_list = glob.glob(os.path.join(dir_path, regex)) + f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f)))) + x = f_list[-1] + print(x) + return x + + +def plot_spectrogram_to_numpy(spectrogram): + global MATPLOTLIB_FLAG + if not MATPLOTLIB_FLAG: + import matplotlib + matplotlib.use("Agg") + MATPLOTLIB_FLAG = True + mpl_logger = logging.getLogger('matplotlib') + mpl_logger.setLevel(logging.WARNING) + import matplotlib.pylab as plt + import numpy as np + + fig, ax = plt.subplots(figsize=(10,2)) + im = ax.imshow(spectrogram, aspect="auto", origin="lower", + interpolation='none') + plt.colorbar(im, ax=ax) + plt.xlabel("Frames") + plt.ylabel("Channels") + plt.tight_layout() + + fig.canvas.draw() + data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='') + data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,)) + plt.close() + return data + + +def plot_alignment_to_numpy(alignment, info=None): + global MATPLOTLIB_FLAG + if not MATPLOTLIB_FLAG: + import matplotlib + matplotlib.use("Agg") + MATPLOTLIB_FLAG = True + mpl_logger = logging.getLogger('matplotlib') + mpl_logger.setLevel(logging.WARNING) + import matplotlib.pylab as plt + import numpy as np + + fig, ax = plt.subplots(figsize=(6, 4)) + im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower', + interpolation='none') + fig.colorbar(im, ax=ax) + xlabel = 'Decoder timestep' + if info is not None: + xlabel += '\n\n' + info + plt.xlabel(xlabel) + plt.ylabel('Encoder timestep') + plt.tight_layout() + + fig.canvas.draw() + data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='') + data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,)) + plt.close() + return data + + +def load_wav_to_torch(full_path): + sampling_rate, data = read(full_path) + return torch.FloatTensor(data.astype(np.float32)), sampling_rate + + +def load_filepaths_and_text(filename, split="|"): + with open(filename, encoding='utf-8') as f: + filepaths_and_text = [line.strip().split(split) for line in f] + return filepaths_and_text + + +def get_hparams(init=True): + parser = argparse.ArgumentParser() + parser.add_argument('-c', '--config', type=str, default="./configs/tony.json", + help='JSON file for configuration') + parser.add_argument('-m', '--model', type=str, default='tony.pth', + help='Model name') + + args = parser.parse_args() + model_dir = os.path.join("../drive/MyDrive", args.model) + + if not os.path.exists(model_dir): + os.makedirs(model_dir) + + config_path = args.config + config_save_path = os.path.join(model_dir, "config.json") + if init: + with open(config_path, "r") as f: + data = f.read() + with open(config_save_path, "w") as f: + f.write(data) + else: + with open(config_save_path, "r") as f: + data = f.read() + config = json.loads(data) + + hparams = HParams(**config) + hparams.model_dir = model_dir + return hparams + + +def get_hparams_from_dir(model_dir): + config_save_path = os.path.join(model_dir, "config.json") + with open(config_save_path, "r") as f: + data = f.read() + config = json.loads(data) + + hparams =HParams(**config) + hparams.model_dir = model_dir + return hparams + + +def get_hparams_from_file(config_path): + with open(config_path, "r") as f: + data = f.read() + config = json.loads(data) + + hparams =HParams(**config) + return hparams + + +def check_git_hash(model_dir): + source_dir = os.path.dirname(os.path.realpath(__file__)) + if not os.path.exists(os.path.join(source_dir, ".git")): + logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format( + source_dir + )) + return + + cur_hash = subprocess.getoutput("git rev-parse HEAD") + + path = os.path.join(model_dir, "githash") + if os.path.exists(path): + saved_hash = open(path).read() + if saved_hash != cur_hash: + logger.warn("git hash values are different. {}(saved) != {}(current)".format( + saved_hash[:8], cur_hash[:8])) + else: + open(path, "w").write(cur_hash) + + +def get_logger(model_dir, filename="train.log"): + global logger + logger = logging.getLogger(os.path.basename(model_dir)) + logger.setLevel(logging.DEBUG) + + formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s") + if not os.path.exists(model_dir): + os.makedirs(model_dir) + h = logging.FileHandler(os.path.join(model_dir, filename)) + h.setLevel(logging.DEBUG) + h.setFormatter(formatter) + logger.addHandler(h) + return logger + + +class HParams(): + def __init__(self, **kwargs): + for k, v in kwargs.items(): + if type(v) == dict: + v = HParams(**v) + self[k] = v + + def keys(self): + return self.__dict__.keys() + + def items(self): + return self.__dict__.items() + + def values(self): + return self.__dict__.values() + + def __len__(self): + return len(self.__dict__) + + def __getitem__(self, key): + return getattr(self, key) + + def __setitem__(self, key, value): + return setattr(self, key, value) + + def __contains__(self, key): + return key in self.__dict__ + + def __repr__(self): + return self.__dict__.__repr__() From f33b62922b408ab26537b59ffecd47978417a6e5 Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sat, 23 Dec 2023 16:21:09 +0800 Subject: [PATCH 02/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/evaluator/__init__.py | 1 - talkingface/evaluator/metrics_vits.py | 58 ---------- .../audio_driven_talkingface/model_vits.py | 80 +++++++++++--- .../properties/dataset/LJSpeech_vits.yaml | 4 +- talkingface/quick_start/quick_start.py | 7 +- talkingface/trainer/trainer.py | 103 +++++++++++++++++- 6 files changed, 169 insertions(+), 84 deletions(-) delete mode 100644 talkingface/evaluator/metrics_vits.py diff --git a/talkingface/evaluator/__init__.py b/talkingface/evaluator/__init__.py index 142c482b..947cf89e 100644 --- a/talkingface/evaluator/__init__.py +++ b/talkingface/evaluator/__init__.py @@ -1,5 +1,4 @@ from talkingface.evaluator.metric_models import * from talkingface.evaluator.metrics import * -from talkingface.evaluator.metrics_vits import * from talkingface.evaluator.register import * from talkingface.evaluator.evaluator import * diff --git a/talkingface/evaluator/metrics_vits.py b/talkingface/evaluator/metrics_vits.py deleted file mode 100644 index 0b5816eb..00000000 --- a/talkingface/evaluator/metrics_vits.py +++ /dev/null @@ -1,58 +0,0 @@ -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 = torch.mean((1-dg)**2) - gen_losses.append(l) - loss += l - - return loss, gen_losses - - -def kl_loss(z_p, logs_q, m_p, logs_p, z_mask): - """ - z_p, logs_q: [b, h, t_t] - m_p, logs_p: [b, h, t_t] - """ - z_p = z_p.float() - logs_q = logs_q.float() - m_p = m_p.float() - logs_p = logs_p.float() - z_mask = z_mask.float() - - kl = logs_p - logs_q - 0.5 - kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p) - kl = torch.sum(kl * z_mask) - l = kl / torch.sum(z_mask) - return l diff --git a/talkingface/model/audio_driven_talkingface/model_vits.py b/talkingface/model/audio_driven_talkingface/model_vits.py index 9c67f5c4..8c8e0a31 100644 --- a/talkingface/model/audio_driven_talkingface/model_vits.py +++ b/talkingface/model/audio_driven_talkingface/model_vits.py @@ -11,16 +11,17 @@ import torch from torch import nn from torch.nn import functional as F +from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d +from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm +from torch.utils.data import DataLoader from talkingface.utils.vits_utils import commons from talkingface.utils.vits_utils import monotonic_align -from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d -from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm - from talkingface.utils.vits_utils.commons import init_weights, get_padding from talkingface.utils.vits_utils.transforms import piecewise_rational_quadratic_transform from talkingface.model.abstract_talkingface import AbstractTalkingFace +from talkingface.data.dataset.vits_dataset import TextAudioLoader, TextAudioCollate, DistributedBucketSampler class StochasticDurationPredictor(nn.Module): @@ -419,20 +420,34 @@ def calculate_loss(self, interaction): """ Calculate the training loss for a batch data. Args: - interaction: interaction在此处应该是一个元组，里面是self.forward里面的前两个返回值(y_d_rs, y_d_gs) + interaction: interaction在此处应该是一个元组batch Returns: {"loss": loss, "r_losses": r_losses, "g_losses": g_losses} """ - from talkingface.evaluator.metrics_vits import discriminator_loss y_d_hat_r, y_d_hat_g = interaction - loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g) + loss_disc, losses_disc_r, losses_disc_g = self.discriminator_loss(y_d_hat_r, y_d_hat_g) return {"loss": loss_disc, "r_losses": losses_disc_r, "g_losses": losses_disc_g} def generate_batch(self): pass + def discriminator_loss(self, 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 + class SynthesizerTrn(AbstractTalkingFace): """ @@ -566,29 +581,24 @@ def predict(self, interaction): def calculate_loss(self, interaction, valid=False): """ Calculate the training loss for a batch data. - interaction参数里面的结构是： - (hps, (y_mel, y_hat_mel), \ - (y_d_hat_r, y_d_hat_g, fmap_r, fmap_g), \ - (l_length, z_mask, (z, z_p, m_p, logs_p, m_q, logs_q))) + trainer通过调用这个函数进行网络的前向传递，一个interaction是一个batch Args: - interaction: 一个元组 + interaction: 一个step中的一个batch valid: 是否是valid Returns: {"loss": loss_gen_all, "loss_gen": loss_gen, "loss_fm": loss_fm, "loss_mel": loss_mel, "loss_dur": loss_dur, "loss_kl": loss_kl} """ - from talkingface.evaluator.metrics_vits import kl_loss, feature_loss, generator_loss - hps, (y_mel, y_hat_mel), \ (y_d_hat_r, y_d_hat_g, fmap_r, fmap_g), \ (l_length, z_mask, (z, z_p, m_p, logs_p, m_q, logs_q)) = interaction loss_dur = torch.sum(l_length.float()) loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel - loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl + loss_kl = self.kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl - loss_fm = feature_loss(fmap_r, fmap_g) - loss_gen, losses_gen = generator_loss(y_d_hat_g) + loss_fm = self.feature_loss(fmap_r, fmap_g) + loss_gen, losses_gen = self.generator_loss(y_d_hat_g) loss_gen_all = loss_gen + loss_fm + loss_mel + loss_dur + loss_kl return {"loss": loss_gen_all, "loss_gen": loss_gen, "loss_fm": loss_fm, "loss_mel": loss_mel, "loss_dur": loss_dur, "loss_kl": loss_kl} @@ -596,6 +606,44 @@ def calculate_loss(self, interaction, valid=False): def generate_batch(self): pass + def kl_loss(self, z_p, logs_q, m_p, logs_p, z_mask): + """ + z_p, logs_q: [b, h, t_t] + m_p, logs_p: [b, h, t_t] + """ + z_p = z_p.float() + logs_q = logs_q.float() + m_p = m_p.float() + logs_p = logs_p.float() + z_mask = z_mask.float() + + kl = logs_p - logs_q - 0.5 + kl += 0.5 * ((z_p - m_p) ** 2) * torch.exp(-2. * logs_p) + kl = torch.sum(kl * z_mask) + l = kl / torch.sum(z_mask) + return l + + def generator_loss(self, disc_outputs): + loss = 0 + gen_losses = [] + for dg in disc_outputs: + dg = dg.float() + l = torch.mean((1 - dg) ** 2) + gen_losses.append(l) + loss += l + + return loss, gen_losses + + def feature_loss(self, 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 infer(self, x, x_lengths, sid=None, noise_scale=1, length_scale=1, noise_scale_w=1., max_len=None): x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths) if self.n_speakers > 0: diff --git a/talkingface/properties/dataset/LJSpeech_vits.yaml b/talkingface/properties/dataset/LJSpeech_vits.yaml index 9a23199a..be7f980a 100644 --- a/talkingface/properties/dataset/LJSpeech_vits.yaml +++ b/talkingface/properties/dataset/LJSpeech_vits.yaml @@ -1,5 +1,5 @@ -training_files: "filelists/list.txt.cleaned", # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 -validation_files: "filelists/list_val.txt.cleaned", # 当前数据划分为测试机的文件名列表存放位置 +training_files: "dataset/LJSpeech/filelists/list.txt.cleaned", # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 +validation_files: "dataset/LJSpeech/filelists/list_val.txt.cleaned", # 当前数据划分为测试机的文件名列表存放位置 text_cleaners: ["cjke_cleaners2"], # 选择合适的cleaner，具体可以参考talkingface/utils/vits_utils/text/cleaners.py中的代码 max_wav_value: 32768.0, sampling_rate: 22050, diff --git a/talkingface/quick_start/quick_start.py b/talkingface/quick_start/quick_start.py index 3ff2e889..41a0cc0a 100644 --- a/talkingface/quick_start/quick_start.py +++ b/talkingface/quick_start/quick_start.py @@ -76,11 +76,14 @@ def run_talkingface( get_preprocess(config['dataset'])(config).run() train_dataset, val_dataset = create_dataset(config) + + from talkingface.data.dataset.vits_dataset import TextAudioCollate + collate_fn = TextAudioCollate() if config["model"] == "vits" else None train_data_loader = data_utils.DataLoader( - train_dataset, batch_size=config["batch_size"], shuffle=True + train_dataset, batch_size=config["batch_size"], shuffle=True, collate_fn=collate_fn, ) val_data_loader = data_utils.DataLoader( - val_dataset, batch_size=config["batch_size"], shuffle=False + val_dataset, batch_size=config["batch_size"], shuffle=False, collate_fn=collate_fn, ) # load model diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index 7d6838c8..3cfc918a 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -365,10 +365,10 @@ def fit(self, train_data, valid_data=None, verbose=True, saved=True, show_progre Returns: best result """ - if saved and self.start_epoch >= self.epochs: + if saved and self.start_epoch >= self.epochs: # 为什么最开始要检查一下是否保存模型？ self._save_checkpoint(-1, verbose=verbose) - if not (self.config['resume_checkpoint_path'] == None ) and self.config['resume']: + if not (self.config['resume_checkpoint_path'] == None ) and self.config['resume']: # 使用之前的模型继续训练 self.resume_checkpoint(self.config['resume_checkpoint_path']) for epoch_idx in range(self.start_epoch, self.epochs): @@ -381,7 +381,7 @@ def fit(self, train_data, valid_data=None, verbose=True, saved=True, show_progre train_loss_output = self._generate_train_loss_output( epoch_idx, training_start_time, training_end_time, train_loss) - if verbose: + if verbose: # 记录此次的日志 self.logger.info(train_loss_output) # self._add_train_loss_to_tensorboard(epoch_idx, train_loss) @@ -561,8 +561,101 @@ def __init__(self, config, model): super(VITSTrainer, self).__init__(config, model) def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=False): - pass + from torch.cuda.amp import autocast, GradScaler + from talkingface.utils.vits_utils.mel_processing import mel_spectrogram_torch, spec_to_mel_torch + from talkingface.utils.vits_utils import commons + from talkingface.utils.vits_utils import utils + + + self.model.train() + + loss_func = loss_func or self.model.calculate_loss + total_loss_dict = {} + iter_data = ( + tqdm( + train_data, + total=len(train_data), + ncols=None, + ) + if show_progress + else train_data + ) + step = 0 + + for batch_idx, (x, x_lengths, spec, spec_lengths, y, y_lengths) in enumerate(iter_data): + x, x_lengths = x.cuda(0, non_blocking=True), x_lengths.cuda(0, non_blocking=True) + spec, spec_lengths = spec.cuda(0, non_blocking=True), spec_lengths.cuda(0, non_blocking=True) + y, y_lengths = y.cuda(0, non_blocking=True), y_lengths.cuda(0, non_blocking=True) + + with autocast(enabled=True): + y_hat, l_length, attn, ids_slice, x_mask, z_mask, \ + (z, z_p, m_p, logs_p, m_q, logs_q) = net_g(x, x_lengths, spec, spec_lengths) + + mel = spec_to_mel_torch( + spec=spec, + n_fft=1024, + num_mels=80, + sampling_rate=22050, + fmin=0.0, + fmax=None) + y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length) + y_hat_mel = mel_spectrogram_torch( + y=y_hat.squeeze(1), + n_fft=1024, + num_mels=80, + sampling_rate=22050, + hop_size=256, + win_size=1024, + fmin=0.0, + fmax=None + ) + + y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size) # slice + + # Discriminator + y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach()) + with autocast(enabled=False): + loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g) + loss_disc_all = loss_disc + optim_d.zero_grad() + scaler.scale(loss_disc_all).backward() + scaler.unscale_(optim_d) + grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None) + scaler.step(optim_d) + + with autocast(enabled=True): + # Generator + y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat) + with autocast(enabled=False): + loss_dur = torch.sum(l_length.float()) + loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel + loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.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 + optim_g.zero_grad() + scaler.scale(loss_gen_all).backward() + scaler.unscale_(optim_g) + grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None) + scaler.step(optim_g) + scaler.update() + + step += 1 + return average_loss_dict + def _valid_epoch(self, valid_data, show_progress=False): - pass + print('Valid'.format(self.eval_step)) + self.model.eval() + total_loss_dict = {} + iter_data = ( + tqdm(valid_data, + total=len(valid_data), + ncols=None, + desc=set_color("Valid", "pink") + ) + if show_progress + else valid_data + ) \ No newline at end of file From 94f86ebb347f26037ff22b5b08550f0622f57174 Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sat, 23 Dec 2023 18:24:30 +0800 Subject: [PATCH 03/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/config/configurator.py | 2 +- talkingface/data/dataset/vits_dataset.py | 19 +- .../audio_driven_talkingface/model_vits.py | 84 +++++++-- .../properties/dataset/LJSpeech_vits.yaml | 26 +-- talkingface/properties/model/VITS.yaml | 34 ++-- talkingface/quick_start/quick_start.py | 2 +- talkingface/trainer/trainer.py | 175 +++++++++++------- 7 files changed, 220 insertions(+), 122 deletions(-) diff --git a/talkingface/config/configurator.py b/talkingface/config/configurator.py index 7b6e21d8..c833f10a 100644 --- a/talkingface/config/configurator.py +++ b/talkingface/config/configurator.py @@ -3,7 +3,7 @@ import sys import yaml from logging import getLogger -from typing import Literal +# from typing import Literal from talkingface.utils import( get_model, diff --git a/talkingface/data/dataset/vits_dataset.py b/talkingface/data/dataset/vits_dataset.py index 03cb6a7a..dc2dbe56 100644 --- a/talkingface/data/dataset/vits_dataset.py +++ b/talkingface/data/dataset/vits_dataset.py @@ -100,7 +100,9 @@ def __len__(self): class TextAudioCollate(): - """ Zero-pads model inputs and targets + """ + Zero-pads model inputs and targets \n + 对batch进行处理，进行长度上的补齐 """ def __init__(self, return_ids=False): @@ -147,8 +149,19 @@ def __call__(self, batch): wav_lengths[i] = wav.size(1) if self.return_ids: - return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, ids_sorted_decreasing - return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths + return {"text_padded": text_padded, + "text_lengths": text_lengths, + "spec_padded": spec_padded, + "spec_lengths": spec_lengths, + "wav_padded": wav_padded, + "wav_lengths": wav_lengths, + "ids_sorted_decreasing": ids_sorted_decreasing} + return {"text": text_padded, + "text_lengths": text_lengths, + "spec": spec_padded, + "spec_lengths": spec_lengths, + "wav": wav_padded, + "wav_lengths": wav_lengths} class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler): diff --git a/talkingface/model/audio_driven_talkingface/model_vits.py b/talkingface/model/audio_driven_talkingface/model_vits.py index 8c8e0a31..2a7241e1 100644 --- a/talkingface/model/audio_driven_talkingface/model_vits.py +++ b/talkingface/model/audio_driven_talkingface/model_vits.py @@ -425,10 +425,25 @@ def calculate_loss(self, interaction): Returns: {"loss": loss, "r_losses": r_losses, "g_losses": g_losses} """ - - y_d_hat_r, y_d_hat_g = interaction - loss_disc, losses_disc_r, losses_disc_g = self.discriminator_loss(y_d_hat_r, y_d_hat_g) - return {"loss": loss_disc, "r_losses": losses_disc_r, "g_losses": losses_disc_g} + from torch.cuda.amp import autocast + + _interaction, net_g = interaction + (y, y_hat), l_length, (y_mel, y_hat_mel), (z_p, logs_q, m_p, logs_p, z_mask) = _interaction + with autocast(enabled=False): + # Generator + y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = self.forward(y, y_hat) + with autocast(enabled=False): + loss_dur = torch.sum(l_length.float()) + # loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel + loss_mel = F.l1_loss(y_mel, y_hat_mel) * 45 + # loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl + loss_kl = net_g.kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * 1.0 + + loss_fm = net_g.feature_loss(fmap_r, fmap_g) + loss_gen, losses_gen = net_g.generator_loss(y_d_hat_g) + loss_gen_all = loss_gen + loss_fm + loss_mel + loss_dur + loss_kl + return {"loss_gen_all": loss_gen_all, "loss_gen": loss_gen, "loss_fm": loss_fm, + "loss_mel": loss_mel, "loss_dur": loss_dur, "loss_kl": loss_kl} def generate_batch(self): pass @@ -590,18 +605,55 @@ def calculate_loss(self, interaction, valid=False): "loss_mel": loss_mel, "loss_dur": loss_dur, "loss_kl": loss_kl} """ - hps, (y_mel, y_hat_mel), \ - (y_d_hat_r, y_d_hat_g, fmap_r, fmap_g), \ - (l_length, z_mask, (z, z_p, m_p, logs_p, m_q, logs_q)) = interaction - loss_dur = torch.sum(l_length.float()) - loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel - loss_kl = self.kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl - - loss_fm = self.feature_loss(fmap_r, fmap_g) - loss_gen, losses_gen = self.generator_loss(y_d_hat_g) - loss_gen_all = loss_gen + loss_fm + loss_mel + loss_dur + loss_kl - return {"loss": loss_gen_all, "loss_gen": loss_gen, "loss_fm": loss_fm, - "loss_mel": loss_mel, "loss_dur": loss_dur, "loss_kl": loss_kl} + from torch.cuda.amp import autocast, GradScaler + from talkingface.utils.vits_utils.mel_processing import mel_spectrogram_torch, spec_to_mel_torch + from talkingface.utils.vits_utils import commons + + _interaction, net_d = interaction + x, x_lengths = _interaction["text"], _interaction["text_lengths"] + spec, spec_lengths = _interaction["spec"], _interaction["spec_lengths"] + y, y_lengths = _interaction["wav"], _interaction["wav_lengths"] + x, x_lengths = x.cuda(0, non_blocking=True), x_lengths.cuda(0, non_blocking=True) + spec, spec_lengths = spec.cuda(0, non_blocking=True), spec_lengths.cuda(0, non_blocking=True) + y, y_lengths = y.cuda(0, non_blocking=True), y_lengths.cuda(0, non_blocking=True) + + with autocast(enabled=True): + y_hat, l_length, attn, ids_slice, x_mask, z_mask, \ + (z, z_p, m_p, logs_p, m_q, logs_q) = self.forward(x, x_lengths, spec, spec_lengths) + + mel = spec_to_mel_torch( + spec=spec, + n_fft=1024, + num_mels=80, + sampling_rate=22050, + fmin=0.0, + fmax=None) + # y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length) + y_mel = commons.slice_segments(mel, ids_slice, segment_size=8192 // 256) + y_hat_mel = mel_spectrogram_torch( + y=y_hat.squeeze(1), + n_fft=1024, + num_mels=80, + sampling_rate=22050, + hop_size=256, + win_size=1024, + fmin=0.0, + fmax=None + ) + + # y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size) # slice + y = commons.slice_segments(y, ids_slice * 256, segment_size=8192) # slice + + # Discriminator + y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach()) + with autocast(enabled=False): + loss_disc, losses_disc_r, losses_disc_g = net_d.discriminator_loss(y_d_hat_r, y_d_hat_g) + loss_disc_all = loss_disc + + net_d_feature = ((y, y_hat), l_length, (y_mel, y_hat_mel), (z_p, logs_q, m_p, logs_p, z_mask)) + + return {"loss_disc_all": loss_disc_all, "losses_disc_r": losses_disc_r, "losses_disc_g": losses_disc_g}, net_d_feature + def generate_batch(self): pass diff --git a/talkingface/properties/dataset/LJSpeech_vits.yaml b/talkingface/properties/dataset/LJSpeech_vits.yaml index be7f980a..68ca8c06 100644 --- a/talkingface/properties/dataset/LJSpeech_vits.yaml +++ b/talkingface/properties/dataset/LJSpeech_vits.yaml @@ -1,14 +1,14 @@ -training_files: "dataset/LJSpeech/filelists/list.txt.cleaned", # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 -validation_files: "dataset/LJSpeech/filelists/list_val.txt.cleaned", # 当前数据划分为测试机的文件名列表存放位置 -text_cleaners: ["cjke_cleaners2"], # 选择合适的cleaner，具体可以参考talkingface/utils/vits_utils/text/cleaners.py中的代码 -max_wav_value: 32768.0, -sampling_rate: 22050, -filter_length: 1024, -hop_length: 256, -win_length: 1024, -n_mel_channels: 80, -mel_fmin: 0.0, -mel_fmax: null, -add_blank: true, -n_speakers: 0, # 数据集中的说话人数，如果是一个人填0 +training_files: "dataset/LJSpeech/filelists/list.txt.cleaned" # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 +validation_files: "dataset/LJSpeech/filelists/list_val.txt.cleaned" # 当前数据划分为测试机的文件名列表存放位置 +text_cleaners: ["cjke_cleaners2"] # 选择合适的cleaner，具体可以参考talkingface/utils/vits_utils/text/cleaners.py中的代码 +max_wav_value: 32768.0 +sampling_rate: 22050 +filter_length: 1024 +hop_length: 256 +win_length: 1024 +n_mel_channels: 80 +mel_fmin: 0.0 +mel_fmax: null +add_blank: true +n_speakers: 0 # 数据集中的说话人数，如果是一个人填0 cleaned_text: true # 因为数据处理过后就有cleaned后缀，这里就是true \ No newline at end of file diff --git a/talkingface/properties/model/VITS.yaml b/talkingface/properties/model/VITS.yaml index 85bfd6fc..a6d642db 100644 --- a/talkingface/properties/model/VITS.yaml +++ b/talkingface/properties/model/VITS.yaml @@ -1,16 +1,18 @@ -inter_channels: 192, -hidden_channels: 192, -filter_channels: 768, -n_heads: 2, -n_layers: 6, -kernel_size: 3, -p_dropout: 0.1, -resblock: "1", -resblock_kernel_sizes: [3,7,11], -resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]], -upsample_rates: [8,8,2,2], -upsample_initial_channel: 512, -upsample_kernel_sizes: [16,16,4,4], -n_layers_q: 3, -use_spectral_norm: false, -gin_channels: 256 \ No newline at end of file +inter_channels: 192 +hidden_channels: 192 +filter_channels: 768 +n_heads: 2 +n_layers: 6 +kernel_size: 3 +p_dropout: 0.1 +resblock: "1" +resblock_kernel_sizes: [3,7,11] +resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]] +upsample_rates: [8,8,2,2] +upsample_initial_channel: 512 +upsample_kernel_sizes: [16,16,4,4] +n_layers_q: 3 +use_spectral_norm: false +gin_channels: 256 + +batch_size: 64 \ No newline at end of file diff --git a/talkingface/quick_start/quick_start.py b/talkingface/quick_start/quick_start.py index 41a0cc0a..02df3d95 100644 --- a/talkingface/quick_start/quick_start.py +++ b/talkingface/quick_start/quick_start.py @@ -5,7 +5,7 @@ from logging import getLogger import os from torch.utils import data as data_utils -from ray import tune +# from ray import tune from talkingface.config import Config diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index 3cfc918a..7ac4b152 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -2,7 +2,7 @@ from logging import getLogger from time import time -import dlib, json, subprocess +# import dlib, json, subprocess import torch.nn.functional as F import glob import numpy as np @@ -14,6 +14,7 @@ from torch import nn from pathlib import Path +import talkingface.model.audio_driven_talkingface.model_vits from talkingface.utils import( ensure_dir, get_local_time, @@ -557,19 +558,24 @@ def _valid_epoch(self, valid_data, loss_func=None, show_progress=False): class VITSTrainer(Trainer): - def __init__(self, config, model): + def __init__(self, config, model, + decoder=talkingface.model.audio_driven_talkingface.model_vits.MultiPeriodDiscriminator, + decoder_optimizer=torch.optim.AdamW): super(VITSTrainer, self).__init__(config, model) - def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=False): - from torch.cuda.amp import autocast, GradScaler - from talkingface.utils.vits_utils.mel_processing import mel_spectrogram_torch, spec_to_mel_torch - from talkingface.utils.vits_utils import commons - from talkingface.utils.vits_utils import utils + self.net_g = self.model + self.optim_g = self.optimizer + self.net_d = decoder(use_spectral_norm=False).cuda(0) + self.optim_d = decoder_optimizer(self.net_d.parameters(), lr=2e-4, betas=(0.8, 0.99), eps=1e-9) + from torch.cuda.amp import GradScaler - self.model.train() + self.scaler = GradScaler(enabled=True) - loss_func = loss_func or self.model.calculate_loss + def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=False): + self.net_g.train() + self.net_d.train() + loss_func = loss_func or self.net_g.calculate_loss total_loss_dict = {} iter_data = ( tqdm( @@ -582,73 +588,64 @@ def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=Fals ) step = 0 - for batch_idx, (x, x_lengths, spec, spec_lengths, y, y_lengths) in enumerate(iter_data): - x, x_lengths = x.cuda(0, non_blocking=True), x_lengths.cuda(0, non_blocking=True) - spec, spec_lengths = spec.cuda(0, non_blocking=True), spec_lengths.cuda(0, non_blocking=True) - y, y_lengths = y.cuda(0, non_blocking=True), y_lengths.cuda(0, non_blocking=True) - - with autocast(enabled=True): - y_hat, l_length, attn, ids_slice, x_mask, z_mask, \ - (z, z_p, m_p, logs_p, m_q, logs_q) = net_g(x, x_lengths, spec, spec_lengths) - - mel = spec_to_mel_torch( - spec=spec, - n_fft=1024, - num_mels=80, - sampling_rate=22050, - fmin=0.0, - fmax=None) - y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length) - y_hat_mel = mel_spectrogram_torch( - y=y_hat.squeeze(1), - n_fft=1024, - num_mels=80, - sampling_rate=22050, - hop_size=256, - win_size=1024, - fmin=0.0, - fmax=None - ) - - y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size) # slice - - # Discriminator - y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach()) - with autocast(enabled=False): - loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g) - loss_disc_all = loss_disc - optim_d.zero_grad() - scaler.scale(loss_disc_all).backward() - scaler.unscale_(optim_d) - grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None) - scaler.step(optim_d) - - with autocast(enabled=True): - # Generator - y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat) - with autocast(enabled=False): - loss_dur = torch.sum(l_length.float()) - loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel - loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.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 - optim_g.zero_grad() - scaler.scale(loss_gen_all).backward() - scaler.unscale_(optim_g) - grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None) - scaler.step(optim_g) - scaler.update() - + for batch_idx, interaction in enumerate(iter_data): + self.optim_g.zero_grad() + self.optim_d.zero_grad() step += 1 - return average_loss_dict - + # 计算第一部分loss + interaction_box = (interaction, self.net_d) + g_losses_dict, net_d_feature = loss_func(interaction_box) + loss_disc_all = g_losses_dict["loss_disc_all"] + + # 计算第二部分loss + interaction_box = (net_d_feature, self.net_g) + d_losses_dict = self.net_d.calculate_loss(interaction_box) + loss_gen_all = d_losses_dict["loss_gen_all"] + + for losses_dict in [g_losses_dict, d_losses_dict]: + for key, value in losses_dict.items(): # 对所有返回的loss值都看一遍 + if key in total_loss_dict: + if not torch.is_tensor(value): + total_loss_dict[key] += value + # 如果键已经在总和字典中，累加当前值 + else: + losses_dict[key] = value.item() + total_loss_dict[key] += value.item() + else: + if not torch.is_tensor(value): + total_loss_dict[key] = value + # 否则，是新的键，将当前值添加到字典中 + else: + losses_dict[key] = value.item() + total_loss_dict[key] = value.item() + iter_data.set_description(set_color(f"train {epoch_idx} {g_losses_dict} {d_losses_dict}", "pink")) + + # self._check_nan(loss) + # loss.backward() + + self.scaler.scale(loss_disc_all).backward() + self.scaler.unscale_(self.optim_d) + # grad_norm_d = commons.clip_grad_value_(self.net_d.parameters(), None) + self.scaler.step(self.optim_d) + + self.scaler.scale(loss_gen_all).backward() + self.scaler.unscale_(self.optim_g) + # grad_norm_g = commons.clip_grad_value_(self.net_g.parameters(), None) + self.scaler.step(self.optim_g) + self.scaler.update() + + # self.optim_g.step() + # self.optim_d.step() + average_loss_dict = {} + for key, value in total_loss_dict.items(): + average_loss_dict[key] = value / step + return average_loss_dict def _valid_epoch(self, valid_data, show_progress=False): print('Valid'.format(self.eval_step)) - self.model.eval() + self.net_g.eval() + self.net_d.eval() total_loss_dict = {} iter_data = ( tqdm(valid_data, @@ -658,4 +655,38 @@ def _valid_epoch(self, valid_data, show_progress=False): ) if show_progress else valid_data - ) \ No newline at end of file + ) + step = 0 + with torch.no_grad(): + for batch_idx, interaction in enumerate(iter_data): + step += 1 + # 计算第一部分loss + interaction_box = (interaction, self.net_d) + g_losses_dict, net_d_feature = self.net_g.calculate_loss(interaction_box) + + # 计算第二部分loss + interaction_box = (net_d_feature, self.net_g) + d_losses_dict = self.net_d.calculate_loss(interaction_box) + + for losses_dict in [g_losses_dict, d_losses_dict]: + for key, value in losses_dict.items(): + if key in total_loss_dict: + if not torch.is_tensor(value): + total_loss_dict[key] += value + # 如果键已经在总和字典中，累加当前值 + else: + losses_dict[key] = value.item() + total_loss_dict[key] += value.item() + else: + if not torch.is_tensor(value): + total_loss_dict[key] = value + # 否则，将当前值添加到字典中 + else: + losses_dict[key] = value.item() + total_loss_dict[key] = value.item() + average_loss_dict = {} + for key, value in total_loss_dict.items(): + average_loss_dict[key] = value / step + if losses_dict["sync_loss"] < .75: + self.model.config["syncnet_wt"] = 0.01 + return average_loss_dict From 5a0217a6382dc52244993ee54152134372ffe82d Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sat, 23 Dec 2023 19:03:44 +0800 Subject: [PATCH 04/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/model/text_to_speech/__init__.py | 1 + .../model_vits.py | 0 talkingface/model/voice_conversion/__init__.py | 0 talkingface/trainer/trainer.py | 13 ++----------- 4 files changed, 3 insertions(+), 11 deletions(-) create mode 100644 talkingface/model/text_to_speech/__init__.py rename talkingface/model/{audio_driven_talkingface => text_to_speech}/model_vits.py (100%) create mode 100644 talkingface/model/voice_conversion/__init__.py diff --git a/talkingface/model/text_to_speech/__init__.py b/talkingface/model/text_to_speech/__init__.py new file mode 100644 index 00000000..9b95adf5 --- /dev/null +++ b/talkingface/model/text_to_speech/__init__.py @@ -0,0 +1 @@ +from talkingface.model.text_to_speech.model_vits import SynthesizerTrn, MultiPeriodDiscriminator diff --git a/talkingface/model/audio_driven_talkingface/model_vits.py b/talkingface/model/text_to_speech/model_vits.py similarity index 100% rename from talkingface/model/audio_driven_talkingface/model_vits.py rename to talkingface/model/text_to_speech/model_vits.py diff --git a/talkingface/model/voice_conversion/__init__.py b/talkingface/model/voice_conversion/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index 7ac4b152..7088284d 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -3,30 +3,21 @@ from logging import getLogger from time import time # import dlib, json, subprocess -import torch.nn.functional as F -import glob import numpy as np import torch import torch.optim as optim -from torch.nn.utils.clip_grad import clip_grad_norm_ from tqdm import tqdm -import torch.cuda.amp as amp -from torch import nn -from pathlib import Path -import talkingface.model.audio_driven_talkingface.model_vits +import talkingface.model.text_to_speech.model_vits from talkingface.utils import( ensure_dir, get_local_time, early_stopping, - calculate_valid_score, dict2str, get_tensorboard, set_color, - get_gpu_usage, WandbLogger ) -from talkingface.data.dataprocess.wav2lip_process import Wav2LipAudio from talkingface.evaluator import Evaluator @@ -559,7 +550,7 @@ def _valid_epoch(self, valid_data, loss_func=None, show_progress=False): class VITSTrainer(Trainer): def __init__(self, config, model, - decoder=talkingface.model.audio_driven_talkingface.model_vits.MultiPeriodDiscriminator, + decoder=talkingface.model.text_to_speech.model_vits.MultiPeriodDiscriminator, decoder_optimizer=torch.optim.AdamW): super(VITSTrainer, self).__init__(config, model) From 39ad888362fee38029a4b9fe1e0e857e3ba505aa Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 00:14:52 +0800 Subject: [PATCH 05/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/data/dataset/wav2lip_dataset.py | 2 +- talkingface/utils/vits_utils/text/__init__.py | 4 ++-- talkingface/utils/vits_utils/text/cleaners.py | 21 +++++++++++-------- 3 files changed, 15 insertions(+), 12 deletions(-) diff --git a/talkingface/data/dataset/wav2lip_dataset.py b/talkingface/data/dataset/wav2lip_dataset.py index e52ae28d..f205dca8 100644 --- a/talkingface/data/dataset/wav2lip_dataset.py +++ b/talkingface/data/dataset/wav2lip_dataset.py @@ -1,7 +1,7 @@ from os.path import dirname, join, basename, isfile from tqdm import tqdm from talkingface.data.dataprocess.wav2lip_process import Wav2LipAudio -import python_speech_features +# import python_speech_features import torch from torch import nn diff --git a/talkingface/utils/vits_utils/text/__init__.py b/talkingface/utils/vits_utils/text/__init__.py index 48ae82f3..f24f94f0 100644 --- a/talkingface/utils/vits_utils/text/__init__.py +++ b/talkingface/utils/vits_utils/text/__init__.py @@ -1,6 +1,6 @@ """ from https://github.com/keithito/tacotron """ -from text import cleaners -from text.symbols import symbols +from talkingface.utils.vits_utils.text import cleaners +from talkingface.utils.vits_utils.text.symbols import symbols # Mappings from symbol to numeric ID and vice versa: diff --git a/talkingface/utils/vits_utils/text/cleaners.py b/talkingface/utils/vits_utils/text/cleaners.py index 9cdf5493..ebdf7579 100644 --- a/talkingface/utils/vits_utils/text/cleaners.py +++ b/talkingface/utils/vits_utils/text/cleaners.py @@ -1,13 +1,16 @@ import re -# from text.japanese import japanese_to_romaji_with_accent, japanese_to_ipa, japanese_to_ipa2, japanese_to_ipa3 -from text.korean import latin_to_hangul, number_to_hangul, divide_hangul, korean_to_lazy_ipa, korean_to_ipa -from text.mandarin import number_to_chinese, chinese_to_bopomofo, latin_to_bopomofo, chinese_to_romaji, chinese_to_lazy_ipa, chinese_to_ipa, chinese_to_ipa2 -from text.sanskrit import devanagari_to_ipa -# from text.english import english_to_lazy_ipa, english_to_ipa2, english_to_lazy_ipa2 -from text.thai import num_to_thai, latin_to_thai -# from text.shanghainese import shanghainese_to_ipa -# from text.cantonese import cantonese_to_ipa -from text.ngu_dialect import ngu_dialect_to_ipa +# from talkingface.utils.vits_utils.text.japanese import japanese_to_romaji_with_accent, +# japanese_to_ipa, japanese_to_ipa2, japanese_to_ipa3 +from talkingface.utils.vits_utils.text.korean import latin_to_hangul, number_to_hangul, divide_hangul, \ + korean_to_lazy_ipa, korean_to_ipa +from talkingface.utils.vits_utils.text.mandarin import number_to_chinese, chinese_to_bopomofo, latin_to_bopomofo, \ + chinese_to_romaji, chinese_to_lazy_ipa, chinese_to_ipa, chinese_to_ipa2 +from talkingface.utils.vits_utils.text.sanskrit import devanagari_to_ipa +# from talkingface.utils.vits_utils.text.english import english_to_lazy_ipa, english_to_ipa2, english_to_lazy_ipa2 +from talkingface.utils.vits_utils.text.thai import num_to_thai, latin_to_thai +# from talkingface.utils.vits_utils.text.shanghainese import shanghainese_to_ipa +# from talkingface.utils.vits_utils.text.cantonese import cantonese_to_ipa +from talkingface.utils.vits_utils.text.ngu_dialect import ngu_dialect_to_ipa def japanese_cleaners(text): From 1558b49fa1f71f9e2faead5343be6bb4c370a15b Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 00:23:16 +0800 Subject: [PATCH 06/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/model/text_to_speech/__init__.py | 2 +- talkingface/model/text_to_speech/{model_vits.py => vits.py} | 5 +++-- .../dataset/{LJSpeech_vits.yaml => LJSpeech.yaml} | 0 talkingface/properties/model/VITS.yaml | 6 +++++- talkingface/trainer/trainer.py | 2 +- 5 files changed, 10 insertions(+), 5 deletions(-) rename talkingface/model/text_to_speech/{model_vits.py => vits.py} (99%) rename talkingface/properties/dataset/{LJSpeech_vits.yaml => LJSpeech.yaml} (100%) diff --git a/talkingface/model/text_to_speech/__init__.py b/talkingface/model/text_to_speech/__init__.py index 9b95adf5..bdc1c4e4 100644 --- a/talkingface/model/text_to_speech/__init__.py +++ b/talkingface/model/text_to_speech/__init__.py @@ -1 +1 @@ -from talkingface.model.text_to_speech.model_vits import SynthesizerTrn, MultiPeriodDiscriminator +from talkingface.model.text_to_speech.vits import VITS, MultiPeriodDiscriminator diff --git a/talkingface/model/text_to_speech/model_vits.py b/talkingface/model/text_to_speech/vits.py similarity index 99% rename from talkingface/model/text_to_speech/model_vits.py rename to talkingface/model/text_to_speech/vits.py index 2a7241e1..94d17989 100644 --- a/talkingface/model/text_to_speech/model_vits.py +++ b/talkingface/model/text_to_speech/vits.py @@ -464,7 +464,8 @@ def discriminator_loss(self, disc_real_outputs, disc_generated_outputs): return loss, r_losses, g_losses -class SynthesizerTrn(AbstractTalkingFace): +# class SynthesizerTrn(AbstractTalkingFace): +class VITS(AbstractTalkingFace): """ Synthesizer for Training @@ -493,7 +494,7 @@ def __init__(self, use_sdp=True, **kwargs): - super(SynthesizerTrn, self).__init__() + super(VITS, self).__init__() self.n_vocab = n_vocab self.spec_channels = spec_channels self.inter_channels = inter_channels diff --git a/talkingface/properties/dataset/LJSpeech_vits.yaml b/talkingface/properties/dataset/LJSpeech.yaml similarity index 100% rename from talkingface/properties/dataset/LJSpeech_vits.yaml rename to talkingface/properties/dataset/LJSpeech.yaml diff --git a/talkingface/properties/model/VITS.yaml b/talkingface/properties/model/VITS.yaml index a6d642db..c5d612de 100644 --- a/talkingface/properties/model/VITS.yaml +++ b/talkingface/properties/model/VITS.yaml @@ -15,4 +15,8 @@ n_layers_q: 3 use_spectral_norm: false gin_channels: 256 -batch_size: 64 \ No newline at end of file +batch_size: 64 + +# Train +checkpoint_sub_dir: "/vits" # 和overall.yaml里checkpoint_dir拼起来作为最终目录 +temp_sub_dir: "/vits" # 和overall.yaml里temp_dir拼起来作为最终目录 \ No newline at end of file diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index 7088284d..bb3d9046 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -8,7 +8,7 @@ import torch.optim as optim from tqdm import tqdm -import talkingface.model.text_to_speech.model_vits +import talkingface.model.text_to_speech.vits from talkingface.utils import( ensure_dir, get_local_time, From 1420c85b338021080ad727cfe56301c023164e20 Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 08:46:52 +0800 Subject: [PATCH 07/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/data/dataset/vits_dataset.py | 25 +++++++++++++++++--- talkingface/properties/dataset/LJSpeech.yaml | 12 +++++++--- talkingface/properties/model/VITS.yaml | 10 ++++++-- talkingface/properties/overall_vits.yaml | 2 +- 4 files changed, 40 insertions(+), 9 deletions(-) diff --git a/talkingface/data/dataset/vits_dataset.py b/talkingface/data/dataset/vits_dataset.py index dc2dbe56..127075f0 100644 --- a/talkingface/data/dataset/vits_dataset.py +++ b/talkingface/data/dataset/vits_dataset.py @@ -12,15 +12,34 @@ from talkingface.utils.vits_utils.text import text_to_sequence, cleaned_text_to_sequence -class TextAudioLoader(Dataset): +class VITSDataset(Dataset): + def __init__(self, config, datasplit): + """ + 初始化vits数据集 + Args: + config: 数据集相关参数，调用父类构造函数后在self.config中 + datasplit: 找到train_filelist的路径或val_filelist的路径 + """ + super().__init__(config, datasplit) + self.dataset = TextAudioLoader(audiopaths_and_text=datasplit, hparams=config) + + def __getitem__(self, index): + return self.dataset.__getitem__(index) + + def __len__(self): + return self.dataset.__len__() + + +class TextAudioLoader(torch.utils.data.Dataset): """ 1) loads audio, text pairs 2) normalizes text and converts them to sequences of integers 3) computes spectrograms from audio files. """ - def __init__(self, config, datasplit, audiopaths_and_text, hparams): - super().__init__(config, datasplit) + def __init__(self, audiopaths_and_text, hparams): + print(audiopaths_and_text) + print(hparams) self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text) self.text_cleaners = hparams.text_cleaners self.max_wav_value = hparams.max_wav_value diff --git a/talkingface/properties/dataset/LJSpeech.yaml b/talkingface/properties/dataset/LJSpeech.yaml index 68ca8c06..f3bd993f 100644 --- a/talkingface/properties/dataset/LJSpeech.yaml +++ b/talkingface/properties/dataset/LJSpeech.yaml @@ -1,5 +1,11 @@ -training_files: "dataset/LJSpeech/filelists/list.txt.cleaned" # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 -validation_files: "dataset/LJSpeech/filelists/list_val.txt.cleaned" # 当前数据划分为测试机的文件名列表存放位置 +train_filelist: "dataset/LJSpeech/filelist/list.txt" # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 +val_filelist: "dataset/LJSpeech/filelist/list_val.txt" # 当前数据划分为测试机的文件名列表存放位置 +data_root: "dataset/LJSpeech/data" # 当前数据集的数据根目录 +preprocessed_root: 'dataset/LJSpeech/preprocessed_data' # 当前数据集的预处理数据根目录 + +need_preprocess: True # 数据集是否需要预处理，如抽帧、抽音频等 +preprocess_batch_size: 32 + text_cleaners: ["cjke_cleaners2"] # 选择合适的cleaner，具体可以参考talkingface/utils/vits_utils/text/cleaners.py中的代码 max_wav_value: 32768.0 sampling_rate: 22050 @@ -11,4 +17,4 @@ mel_fmin: 0.0 mel_fmax: null add_blank: true n_speakers: 0 # 数据集中的说话人数，如果是一个人填0 -cleaned_text: true # 因为数据处理过后就有cleaned后缀，这里就是true \ No newline at end of file +cleaned_text: false # 因为数据处理过后就有cleaned后缀，这里就是true \ No newline at end of file diff --git a/talkingface/properties/model/VITS.yaml b/talkingface/properties/model/VITS.yaml index c5d612de..9e69f56f 100644 --- a/talkingface/properties/model/VITS.yaml +++ b/talkingface/properties/model/VITS.yaml @@ -15,8 +15,14 @@ n_layers_q: 3 use_spectral_norm: false gin_channels: 256 -batch_size: 64 +# 如果你不了解cleaner的工作机制，请不要动symbols，这里的Unicode是与talkingface.utils.vits_utils.text.symbols.py保持一致 +symbols: ["_", ",", ".", "!", "?", "-", "~", "\u2026", "N", "Q", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "s", "t", "u", "v", "w", "x", "y", "z", "\u0251", "\u00e6", "\u0283", "\u0291", "\u00e7", "\u026f", "\u026a", "\u0254", "\u025b", "\u0279", "\u00f0", "\u0259", "\u026b", "\u0265", "\u0278", "\u028a", "\u027e", "\u0292", "\u03b8", "\u03b2", "\u014b", "\u0266", "\u207c", "\u02b0", "`", "^", "#", "*", "=", "\u02c8", "\u02cc", "\u2192", "\u2193", "\u2191", " "] # Train checkpoint_sub_dir: "/vits" # 和overall.yaml里checkpoint_dir拼起来作为最终目录 -temp_sub_dir: "/vits" # 和overall.yaml里temp_dir拼起来作为最终目录 \ No newline at end of file +temp_sub_dir: "/vits" # 和overall.yaml里temp_dir拼起来作为最终目录 +log_interval: 200 # 生成日志的间隔 +eval_interval: 1000 # 模型保存和测试的间隔 +betas: [0.8, 0.99] +eps: 1e-9 +batch_size: 64 diff --git a/talkingface/properties/overall_vits.yaml b/talkingface/properties/overall_vits.yaml index 1b1fc51d..bc5d9b9c 100644 --- a/talkingface/properties/overall_vits.yaml +++ b/talkingface/properties/overall_vits.yaml @@ -14,4 +14,4 @@ warmup_epochs: 0, c_mel: 45, c_kl: 1.0 # 如果你不了解cleaner的工作机制，请不要动symbols，这里的Unicode是与talkingface.utils.vits_utils.text.symbols.py保持一致 -"symbols": ["_", ",", ".", "!", "?", "-", "~", "\u2026", "N", "Q", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "s", "t", "u", "v", "w", "x", "y", "z", "\u0251", "\u00e6", "\u0283", "\u0291", "\u00e7", "\u026f", "\u026a", "\u0254", "\u025b", "\u0279", "\u00f0", "\u0259", "\u026b", "\u0265", "\u0278", "\u028a", "\u027e", "\u0292", "\u03b8", "\u03b2", "\u014b", "\u0266", "\u207c", "\u02b0", "`", "^", "#", "*", "=", "\u02c8", "\u02cc", "\u2192", "\u2193", "\u2191", " "] \ No newline at end of file +symbols: ["_", ",", ".", "!", "?", "-", "~", "\u2026", "N", "Q", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "s", "t", "u", "v", "w", "x", "y", "z", "\u0251", "\u00e6", "\u0283", "\u0291", "\u00e7", "\u026f", "\u026a", "\u0254", "\u025b", "\u0279", "\u00f0", "\u0259", "\u026b", "\u0265", "\u0278", "\u028a", "\u027e", "\u0292", "\u03b8", "\u03b2", "\u014b", "\u0266", "\u207c", "\u02b0", "`", "^", "#", "*", "=", "\u02c8", "\u02cc", "\u2192", "\u2193", "\u2191", " "] \ No newline at end of file From 26fecc74f774bb1c9caa4f0b29d4fec3d12af725 Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 09:20:30 +0800 Subject: [PATCH 08/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/model/text_to_speech/__init__.py | 2 +- talkingface/model/text_to_speech/vits.py | 95 ++++++++++++++------ talkingface/properties/model/VITS.yaml | 8 ++ talkingface/properties/overall_vits.yaml | 17 ---- talkingface/trainer/trainer.py | 4 +- 5 files changed, 79 insertions(+), 47 deletions(-) delete mode 100644 talkingface/properties/overall_vits.yaml diff --git a/talkingface/model/text_to_speech/__init__.py b/talkingface/model/text_to_speech/__init__.py index bdc1c4e4..5ee85d11 100644 --- a/talkingface/model/text_to_speech/__init__.py +++ b/talkingface/model/text_to_speech/__init__.py @@ -1 +1 @@ -from talkingface.model.text_to_speech.vits import VITS, MultiPeriodDiscriminator +from talkingface.model.text_to_speech.vits import VITS, SynthesizerTrn, MultiPeriodDiscriminator diff --git a/talkingface/model/text_to_speech/vits.py b/talkingface/model/text_to_speech/vits.py index 94d17989..e0479283 100644 --- a/talkingface/model/text_to_speech/vits.py +++ b/talkingface/model/text_to_speech/vits.py @@ -208,7 +208,7 @@ def __init__(self, for i in range(n_flows): self.flows.append( ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, - gin_channels=gin_channels, mean_only=True)) + gin_channels=gin_channels, mean_only=True)) self.flows.append(Flip()) def forward(self, x, x_mask, g=None, reverse=False): @@ -376,8 +376,9 @@ def forward(self, x): class MultiPeriodDiscriminator(AbstractTalkingFace): """ - vits的decoder + vits的net_d """ + def __init__(self, use_spectral_norm=False): super(MultiPeriodDiscriminator, self).__init__() periods = [2, 3, 5, 7, 11] @@ -427,17 +428,17 @@ def calculate_loss(self, interaction): """ from torch.cuda.amp import autocast - _interaction, net_g = interaction + _interaction, net_g, hps = interaction (y, y_hat), l_length, (y_mel, y_hat_mel), (z_p, logs_q, m_p, logs_p, z_mask) = _interaction - with autocast(enabled=False): + with autocast(enabled=hps["fp16_run"]): # Generator y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = self.forward(y, y_hat) with autocast(enabled=False): loss_dur = torch.sum(l_length.float()) # loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel - loss_mel = F.l1_loss(y_mel, y_hat_mel) * 45 + loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps["c_mel"] # loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl - loss_kl = net_g.kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * 1.0 + loss_kl = net_g.kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps["c_kl"] loss_fm = net_g.feature_loss(fmap_r, fmap_g) loss_gen, losses_gen = net_g.generator_loss(y_d_hat_g) @@ -465,7 +466,7 @@ def discriminator_loss(self, disc_real_outputs, disc_generated_outputs): # class SynthesizerTrn(AbstractTalkingFace): -class VITS(AbstractTalkingFace): +class SynthesizerTrn(AbstractTalkingFace): """ Synthesizer for Training @@ -494,7 +495,7 @@ def __init__(self, use_sdp=True, **kwargs): - super(VITS, self).__init__() + super(SynthesizerTrn, self).__init__() self.n_vocab = n_vocab self.spec_channels = spec_channels self.inter_channels = inter_channels @@ -610,7 +611,7 @@ def calculate_loss(self, interaction, valid=False): from talkingface.utils.vits_utils.mel_processing import mel_spectrogram_torch, spec_to_mel_torch from talkingface.utils.vits_utils import commons - _interaction, net_d = interaction + _interaction, net_d, hps = interaction x, x_lengths = _interaction["text"], _interaction["text_lengths"] spec, spec_lengths = _interaction["spec"], _interaction["spec_lengths"] y, y_lengths = _interaction["wav"], _interaction["wav_lengths"] @@ -618,32 +619,32 @@ def calculate_loss(self, interaction, valid=False): spec, spec_lengths = spec.cuda(0, non_blocking=True), spec_lengths.cuda(0, non_blocking=True) y, y_lengths = y.cuda(0, non_blocking=True), y_lengths.cuda(0, non_blocking=True) - with autocast(enabled=True): + with autocast(enabled=hps["fp16_run"]): y_hat, l_length, attn, ids_slice, x_mask, z_mask, \ (z, z_p, m_p, logs_p, m_q, logs_q) = self.forward(x, x_lengths, spec, spec_lengths) mel = spec_to_mel_torch( spec=spec, - n_fft=1024, - num_mels=80, - sampling_rate=22050, - fmin=0.0, - fmax=None) + n_fft=hps["filter_length"], + num_mels=hps["n_mel_channels"], + sampling_rate=hps["sampling_rate"], + fmin=hps["mel_fmin"], + fmax=hps["mel_fmax"]) # y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length) - y_mel = commons.slice_segments(mel, ids_slice, segment_size=8192 // 256) + y_mel = commons.slice_segments(mel, ids_slice, segment_size=hps["segment_size"] // hps["hop_length"]) y_hat_mel = mel_spectrogram_torch( y=y_hat.squeeze(1), - n_fft=1024, - num_mels=80, - sampling_rate=22050, - hop_size=256, - win_size=1024, - fmin=0.0, - fmax=None + n_fft=hps["filter_length"], + num_mels=hps["n_mel_channels"], + sampling_rate=hps["sampling_rate"], + hop_size=hps["hop_length"], + win_size=hps["win_length"], + fmin=hps["mel_fmin"], + fmax=hps["mel_fmax"] ) # y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size) # slice - y = commons.slice_segments(y, ids_slice * 256, segment_size=8192) # slice + y = commons.slice_segments(y, ids_slice * hps["hop_length"], segment_size=hps["segment_size"]) # slice # Discriminator y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach()) @@ -653,8 +654,8 @@ def calculate_loss(self, interaction, valid=False): net_d_feature = ((y, y_hat), l_length, (y_mel, y_hat_mel), (z_p, logs_q, m_p, logs_p, z_mask)) - return {"loss_disc_all": loss_disc_all, "losses_disc_r": losses_disc_r, "losses_disc_g": losses_disc_g}, net_d_feature - + return {"loss_disc_all": loss_disc_all, "losses_disc_r": losses_disc_r, + "losses_disc_g": losses_disc_g}, net_d_feature def generate_batch(self): pass @@ -735,13 +736,53 @@ def voice_conversion(self, y, y_lengths, sid_src, sid_tgt): return o_hat, y_mask, (z, z_p, z_hat) +class VITS(AbstractTalkingFace): + """ + 基于talkingface框架的结构，是SynthesizerTrn的抽象 + """ + def __init__(self, config): + from talkingface.utils.vits_utils.text.symbols import symbols + + super(VITS, self).__init__() + self.config = config + self.net_g = SynthesizerTrn( + n_vocab=len(symbols), + spec_channels=self.config["filter_length"] // 2 + 1, + segment_size=self.config["segment_size"] // self.config["hop_length"], + inter_channels=self.config["inter_channels"], + hidden_channels=self.config["hidden_channels"], + filter_channels=self.config["filter_channels"], + n_heads=self.config["n_heads"], + n_layers=self.config["n_layers"], + kernel_size=self.config["kernel_size"], + p_dropout=self.config["p_dropout"], + resblock=self.config["resblock"], + resblock_kernel_sizes=self.config["resblock_kernel_sizes"], + resblock_dilation_sizes=self.config["resblock_dilation_sizes"], + upsample_rates=self.config["upsample_rates"], + upsample_initial_channel=self.config["upsample_initial_channel"], + upsample_kernel_sizes=self.config["upsample_kernel_sizes"], + n_layers_q=self.config["n_layers_q"], + use_spectral_norm=self.config["use_spectral_norm"], + gin_channels=self.config["gin_channels"] + ).cuda(0) + + def calculate_loss(self, interaction): + return self.net_g.calculate_loss(interaction=interaction) + + def predict(self, interaction): + return self.net_g.predict(interaction=interaction) + + def generate_batch(self): + return self.net_g.generate_batch() + + """ ################################### ###### 原仓库modules.py的代码 ####### ################################### """ - LRELU_SLOPE = 0.1 diff --git a/talkingface/properties/model/VITS.yaml b/talkingface/properties/model/VITS.yaml index 9e69f56f..1142a4c1 100644 --- a/talkingface/properties/model/VITS.yaml +++ b/talkingface/properties/model/VITS.yaml @@ -1,3 +1,4 @@ +# SynthesizerTrn(g_net) inter_channels: 192 hidden_channels: 192 filter_channels: 768 @@ -26,3 +27,10 @@ eval_interval: 1000 # 模型保存和测试的间隔 betas: [0.8, 0.99] eps: 1e-9 batch_size: 64 +fp16_run: true +lr_decay: 0.999875 +segment_size: 8192 +init_lr_ratio: 1 +warmup_epochs: 0 +c_mel: 45 +c_kl: 1.0 diff --git a/talkingface/properties/overall_vits.yaml b/talkingface/properties/overall_vits.yaml deleted file mode 100644 index bc5d9b9c..00000000 --- a/talkingface/properties/overall_vits.yaml +++ /dev/null @@ -1,17 +0,0 @@ -log_interval: 200, # 生成日志的间隔 -eval_interval: 1000, # 模型保存和测试的间隔 -seed: 1234, # 随机数种子 -epochs: 20000, # 要训练的epoch轮数 -learning_rate: 2e-4, # 学习率设置 -betas: [0.8, 0.99], -eps: 1e-9, -batch_size: 64, -fp16_run: true, -lr_decay: 0.999875, -segment_size: 8192, -init_lr_ratio: 1, -warmup_epochs: 0, -c_mel: 45, -c_kl: 1.0 -# 如果你不了解cleaner的工作机制，请不要动symbols，这里的Unicode是与talkingface.utils.vits_utils.text.symbols.py保持一致 -symbols: ["_", ",", ".", "!", "?", "-", "~", "\u2026", "N", "Q", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "s", "t", "u", "v", "w", "x", "y", "z", "\u0251", "\u00e6", "\u0283", "\u0291", "\u00e7", "\u026f", "\u026a", "\u0254", "\u025b", "\u0279", "\u00f0", "\u0259", "\u026b", "\u0265", "\u0278", "\u028a", "\u027e", "\u0292", "\u03b8", "\u03b2", "\u014b", "\u0266", "\u207c", "\u02b0", "`", "^", "#", "*", "=", "\u02c8", "\u02cc", "\u2192", "\u2193", "\u2191", " "] \ No newline at end of file diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index bb3d9046..298178ce 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -584,12 +584,12 @@ def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=Fals self.optim_d.zero_grad() step += 1 # 计算第一部分loss - interaction_box = (interaction, self.net_d) + interaction_box = (interaction, self.net_d, self.config) g_losses_dict, net_d_feature = loss_func(interaction_box) loss_disc_all = g_losses_dict["loss_disc_all"] # 计算第二部分loss - interaction_box = (net_d_feature, self.net_g) + interaction_box = (net_d_feature, self.net_g, self.config) d_losses_dict = self.net_d.calculate_loss(interaction_box) loss_gen_all = d_losses_dict["loss_gen_all"] From 43194bfd70ffe465735fca0ef44afa0e889536b4 Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 10:25:31 +0800 Subject: [PATCH 09/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/data/dataprocess/vits_porcess.py | 46 ++++++++++++++------ talkingface/data/dataset/vits_dataset.py | 2 + talkingface/model/text_to_speech/vits.py | 8 ++-- talkingface/properties/dataset/LJSpeech.yaml | 8 ++-- talkingface/properties/overall.yaml | 5 ++- talkingface/quick_start/quick_start.py | 2 +- talkingface/trainer/trainer.py | 4 +- 7 files changed, 49 insertions(+), 26 deletions(-) diff --git a/talkingface/data/dataprocess/vits_porcess.py b/talkingface/data/dataprocess/vits_porcess.py index 51a3d5d9..f8f07933 100644 --- a/talkingface/data/dataprocess/vits_porcess.py +++ b/talkingface/data/dataprocess/vits_porcess.py @@ -2,23 +2,41 @@ from talkingface.utils.vits_utils import text from talkingface.utils.vits_utils.utils import load_filepaths_and_text -if __name__ == '__main__': - parser = argparse.ArgumentParser() - parser.add_argument("--out_extension", default="cleaned") - parser.add_argument("--text_index", default=1, type=int) - parser.add_argument("--filelists", nargs="+", default=["filelists/list.txt", "filelists/list_val.txt"]) - parser.add_argument("--text_cleaners", nargs="+", default=["cjke_cleaners2"]) - args = parser.parse_args() - - for filelist in args.filelists: +def vits_process(config, out_extension="cleaned", text_index=1): + # filelists = ["filelists/list.txt", "filelists/list_val.txt"] + text_cleaners = config["text_cleaners"] + filelists = [config["train_filelist_raw"], config["val_filelist_raw"]] + for filelist in filelists: print("START:", filelist) filepaths_and_text = load_filepaths_and_text(filelist) for i in range(len(filepaths_and_text)): - original_text = filepaths_and_text[i][args.text_index] - cleaned_text = text._clean_text(original_text, args.text_cleaners) - filepaths_and_text[i][args.text_index] = cleaned_text + original_text = filepaths_and_text[i][text_index] + cleaned_text = text._clean_text(original_text, text_cleaners) + filepaths_and_text[i][text_index] = cleaned_text - new_filelist = filelist + "." + args.out_extension - with open(new_filelist, "w", encoding="utf-8") as f: + new_filelist = filelist + "." + out_extension + with open(new_filelist, "w", encoding="utf-8") as f: # 每次都是清空后从头写入 f.writelines(["|".join(x) + "\n" for x in filepaths_and_text]) + + +# if __name__ == '__main__': +# parser = argparse.ArgumentParser() +# parser.add_argument("--out_extension", default="cleaned") +# parser.add_argument("--text_index", default=1, type=int) +# parser.add_argument("--filelists", nargs="+", default=["filelists/list.txt", "filelists/list_val.txt"]) +# parser.add_argument("--text_cleaners", nargs="+", default=["cjke_cleaners2"]) +# +# args = parser.parse_args() +# +# for filelist in args.filelists: +# print("START:", filelist) +# filepaths_and_text = load_filepaths_and_text(filelist) +# for i in range(len(filepaths_and_text)): +# original_text = filepaths_and_text[i][args.text_index] +# cleaned_text = text._clean_text(original_text, args.text_cleaners) +# filepaths_and_text[i][args.text_index] = cleaned_text +# +# new_filelist = filelist + "." + args.out_extension +# with open(new_filelist, "w", encoding="utf-8") as f: +# f.writelines(["|".join(x) + "\n" for x in filepaths_and_text]) diff --git a/talkingface/data/dataset/vits_dataset.py b/talkingface/data/dataset/vits_dataset.py index 127075f0..902a1839 100644 --- a/talkingface/data/dataset/vits_dataset.py +++ b/talkingface/data/dataset/vits_dataset.py @@ -6,6 +6,7 @@ import torch.utils.data from talkingface.data.dataset.dataset import Dataset +from talkingface.data.dataprocess.vits_porcess import vits_process from talkingface.utils.vits_utils import commons from talkingface.utils.vits_utils.mel_processing import spectrogram_torch from talkingface.utils.vits_utils.utils import load_wav_to_torch, load_filepaths_and_text @@ -21,6 +22,7 @@ def __init__(self, config, datasplit): datasplit: 找到train_filelist的路径或val_filelist的路径 """ super().__init__(config, datasplit) + vits_process(config=config) self.dataset = TextAudioLoader(audiopaths_and_text=datasplit, hparams=config) def __getitem__(self, index): diff --git a/talkingface/model/text_to_speech/vits.py b/talkingface/model/text_to_speech/vits.py index e0479283..f0d340b0 100644 --- a/talkingface/model/text_to_speech/vits.py +++ b/talkingface/model/text_to_speech/vits.py @@ -615,9 +615,9 @@ def calculate_loss(self, interaction, valid=False): x, x_lengths = _interaction["text"], _interaction["text_lengths"] spec, spec_lengths = _interaction["spec"], _interaction["spec_lengths"] y, y_lengths = _interaction["wav"], _interaction["wav_lengths"] - x, x_lengths = x.cuda(0, non_blocking=True), x_lengths.cuda(0, non_blocking=True) - spec, spec_lengths = spec.cuda(0, non_blocking=True), spec_lengths.cuda(0, non_blocking=True) - y, y_lengths = y.cuda(0, non_blocking=True), y_lengths.cuda(0, non_blocking=True) + x, x_lengths = x.cuda(non_blocking=True), x_lengths.cuda(non_blocking=True) + spec, spec_lengths = spec.cuda(non_blocking=True), spec_lengths.cuda(non_blocking=True) + y, y_lengths = y.cuda(non_blocking=True), y_lengths.cuda(non_blocking=True) with autocast(enabled=hps["fp16_run"]): y_hat, l_length, attn, ids_slice, x_mask, z_mask, \ @@ -765,7 +765,7 @@ def __init__(self, config): n_layers_q=self.config["n_layers_q"], use_spectral_norm=self.config["use_spectral_norm"], gin_channels=self.config["gin_channels"] - ).cuda(0) + ).cuda() def calculate_loss(self, interaction): return self.net_g.calculate_loss(interaction=interaction) diff --git a/talkingface/properties/dataset/LJSpeech.yaml b/talkingface/properties/dataset/LJSpeech.yaml index f3bd993f..94c9a541 100644 --- a/talkingface/properties/dataset/LJSpeech.yaml +++ b/talkingface/properties/dataset/LJSpeech.yaml @@ -1,5 +1,7 @@ -train_filelist: "dataset/LJSpeech/filelist/list.txt" # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 -val_filelist: "dataset/LJSpeech/filelist/list_val.txt" # 当前数据划分为测试机的文件名列表存放位置 +train_filelist: "dataset/LJSpeech/filelist/list.txt.cleaned" # 当前数据划分为训练集的文件名列表存放位置，该文件的末尾是.txt，至于这里的.cleaned末尾是因为在数据预处理的时候会自动加上 +train_filelist_raw: "dataset/LJSpeech/filelist/list.txt" +val_filelist: "dataset/LJSpeech/filelist/list_val.txt.cleaned" # 当前数据划分为测试机的文件名列表存放位置 +val_filelist_raw: "dataset/LJSpeech/filelist/list_val.txt" data_root: "dataset/LJSpeech/data" # 当前数据集的数据根目录 preprocessed_root: 'dataset/LJSpeech/preprocessed_data' # 当前数据集的预处理数据根目录 @@ -17,4 +19,4 @@ mel_fmin: 0.0 mel_fmax: null add_blank: true n_speakers: 0 # 数据集中的说话人数，如果是一个人填0 -cleaned_text: false # 因为数据处理过后就有cleaned后缀，这里就是true \ No newline at end of file +cleaned_text: true # 因为数据处理过后就有cleaned后缀，这里就是true \ No newline at end of file diff --git a/talkingface/properties/overall.yaml b/talkingface/properties/overall.yaml index 81ac51ae..f5c41a8d 100644 --- a/talkingface/properties/overall.yaml +++ b/talkingface/properties/overall.yaml @@ -1,5 +1,6 @@ # Enviroment Settings -gpu_id: '3, 4, 5' # (str) The id of GPU device(s). +# gpu_id: '3, 4, 5' # (str) The id of GPU device(s). +gpu_id: '0' # (str) The id of GPU device(s). worker: 0 # (int) The number of workers processing the data. use_gpu: True # (bool) Whether or not to use GPU. seed: 2023 # (int) Random seed. @@ -12,7 +13,7 @@ reproducibility: True # (bool) Whether or not to make results reproduc # Training Settings epochs: 300 # (int) The number of training epochs. -train_batch_size: 2048 # (int) The training batch size. +train_batch_size: 4 # (int) The training batch size. learner: adam # (str) The name of used optimizer. learning_rate: 0.0001 # (float) Learning rate. eval_step: 1 # (int) The number of training epochs before an evaluation on the valid dataset. diff --git a/talkingface/quick_start/quick_start.py b/talkingface/quick_start/quick_start.py index 02df3d95..4ebcc5ae 100644 --- a/talkingface/quick_start/quick_start.py +++ b/talkingface/quick_start/quick_start.py @@ -78,7 +78,7 @@ def run_talkingface( train_dataset, val_dataset = create_dataset(config) from talkingface.data.dataset.vits_dataset import TextAudioCollate - collate_fn = TextAudioCollate() if config["model"] == "vits" else None + collate_fn = TextAudioCollate() if config["model"] == "VITS" else None train_data_loader = data_utils.DataLoader( train_dataset, batch_size=config["batch_size"], shuffle=True, collate_fn=collate_fn, ) diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index 298178ce..4d6a3967 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -550,13 +550,13 @@ def _valid_epoch(self, valid_data, loss_func=None, show_progress=False): class VITSTrainer(Trainer): def __init__(self, config, model, - decoder=talkingface.model.text_to_speech.model_vits.MultiPeriodDiscriminator, + decoder=talkingface.model.text_to_speech.vits.MultiPeriodDiscriminator, decoder_optimizer=torch.optim.AdamW): super(VITSTrainer, self).__init__(config, model) self.net_g = self.model self.optim_g = self.optimizer - self.net_d = decoder(use_spectral_norm=False).cuda(0) + self.net_d = decoder(use_spectral_norm=False).cuda() self.optim_d = decoder_optimizer(self.net_d.parameters(), lr=2e-4, betas=(0.8, 0.99), eps=1e-9) from torch.cuda.amp import GradScaler From 793090c3a8ff15c933e8a9ee0aefbb5bbda9a8ec Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 11:50:18 +0800 Subject: [PATCH 10/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- talkingface/data/dataset/vits_dataset.py | 12 +++++---- talkingface/model/text_to_speech/vits.py | 9 +++++++ talkingface/properties/overall.yaml | 2 +- talkingface/trainer/trainer.py | 33 ++++++++++++------------ 4 files changed, 34 insertions(+), 22 deletions(-) diff --git a/talkingface/data/dataset/vits_dataset.py b/talkingface/data/dataset/vits_dataset.py index 902a1839..c8893f4e 100644 --- a/talkingface/data/dataset/vits_dataset.py +++ b/talkingface/data/dataset/vits_dataset.py @@ -40,8 +40,8 @@ class TextAudioLoader(torch.utils.data.Dataset): """ def __init__(self, audiopaths_and_text, hparams): - print(audiopaths_and_text) - print(hparams) + # print(audiopaths_and_text) + # print(hparams) self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text) self.text_cleaners = hparams.text_cleaners self.max_wav_value = hparams.max_wav_value @@ -57,8 +57,8 @@ def __init__(self, audiopaths_and_text, hparams): self.min_text_len = getattr(hparams, "min_text_len", 1) self.max_text_len = getattr(hparams, "max_text_len", 190) - random.seed(1234) - random.shuffle(self.audiopaths_and_text) + # random.seed(1234) + # random.shuffle(self.audiopaths_and_text) self._filter() def _filter(self): @@ -83,7 +83,8 @@ def get_audio_text_pair(self, audiopath_and_text): audiopath, text = audiopath_and_text[0], audiopath_and_text[1] text = self.get_text(text) spec, wav = self.get_audio(audiopath) - return {"text": text, "spec": spec, "wav": wav} + # return {"text": text, "spec": spec, "wav": wav} + return (text, spec, wav) def get_audio(self, filename): audio, sampling_rate = load_wav_to_torch(filename) @@ -135,6 +136,7 @@ def __call__(self, batch): ------ batch: [text_normalized, spec_normalized, wav_normalized] """ + # batch = [batch["text"], batch["spec"], batch["wav"]] # Right zero-pad all one-hot text sequences to max input length _, ids_sorted_decreasing = torch.sort( torch.LongTensor([x[1].size(1) for x in batch]), diff --git a/talkingface/model/text_to_speech/vits.py b/talkingface/model/text_to_speech/vits.py index f0d340b0..e610ee23 100644 --- a/talkingface/model/text_to_speech/vits.py +++ b/talkingface/model/text_to_speech/vits.py @@ -776,6 +776,15 @@ def predict(self, interaction): def generate_batch(self): return self.net_g.generate_batch() + def kl_loss(self, z_p, logs_q, m_p, logs_p, z_mask): + return self.net_g.kl_loss(z_p, logs_q, m_p, logs_p, z_mask) + + def generator_loss(self, disc_outputs): + return self.net_g.generator_loss(disc_outputs) + + def feature_loss(self, fmap_r, fmap_g): + return self.net_g.feature_loss(fmap_r, fmap_g) + """ ################################### diff --git a/talkingface/properties/overall.yaml b/talkingface/properties/overall.yaml index f5c41a8d..f9e859b4 100644 --- a/talkingface/properties/overall.yaml +++ b/talkingface/properties/overall.yaml @@ -13,7 +13,7 @@ reproducibility: True # (bool) Whether or not to make results reproduc # Training Settings epochs: 300 # (int) The number of training epochs. -train_batch_size: 4 # (int) The training batch size. +train_batch_size: 16 # (int) The training batch size. learner: adam # (str) The name of used optimizer. learning_rate: 0.0001 # (float) Learning rate. eval_step: 1 # (int) The number of training epochs before an evaluation on the valid dataset. diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py index 4d6a3967..32b6a317 100644 --- a/talkingface/trainer/trainer.py +++ b/talkingface/trainer/trainer.py @@ -559,9 +559,8 @@ def __init__(self, config, model, self.net_d = decoder(use_spectral_norm=False).cuda() self.optim_d = decoder_optimizer(self.net_d.parameters(), lr=2e-4, betas=(0.8, 0.99), eps=1e-9) - from torch.cuda.amp import GradScaler - - self.scaler = GradScaler(enabled=True) + # from torch.cuda.amp import GradScaler + # self.scaler = GradScaler(enabled=True) def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=False): self.net_g.train() @@ -614,19 +613,21 @@ def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=Fals # self._check_nan(loss) # loss.backward() - self.scaler.scale(loss_disc_all).backward() - self.scaler.unscale_(self.optim_d) - # grad_norm_d = commons.clip_grad_value_(self.net_d.parameters(), None) - self.scaler.step(self.optim_d) - - self.scaler.scale(loss_gen_all).backward() - self.scaler.unscale_(self.optim_g) - # grad_norm_g = commons.clip_grad_value_(self.net_g.parameters(), None) - self.scaler.step(self.optim_g) - self.scaler.update() - - # self.optim_g.step() - # self.optim_d.step() + # self.scaler.scale(loss_disc_all).backward() + # self.scaler.unscale_(self.optim_d) + # # grad_norm_d = commons.clip_grad_value_(self.net_d.parameters(), None) + # self.scaler.step(self.optim_d) + # + # self.scaler.scale(loss_gen_all).backward() + # self.scaler.unscale_(self.optim_g) + # # grad_norm_g = commons.clip_grad_value_(self.net_g.parameters(), None) + # self.scaler.step(self.optim_g) + # self.scaler.update() + + loss_disc_all.backward() + loss_gen_all.backward() + self.optim_g.step() + self.optim_d.step() average_loss_dict = {} for key, value in total_loss_dict.items(): From 6d2b693de79cb5acd3eff55f3d47b6ec537796c2 Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 12:00:06 +0800 Subject: [PATCH 11/16] =?UTF-8?q?=E6=9A=82=E5=AD=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README_VITS.md | 20 +++++ environment_vits.yml | 180 +++++++++++++++++++++++++++++++++++++++++++ readme_img/img.png | Bin 0 -> 243471 bytes 3 files changed, 200 insertions(+) create mode 100644 README_VITS.md create mode 100644 environment_vits.yml create mode 100644 readme_img/img.png diff --git a/README_VITS.md b/README_VITS.md new file mode 100644 index 00000000..9926e8fd --- /dev/null +++ b/README_VITS.md @@ -0,0 +1,20 @@ +# Variational Inference with adversarial learning for end-to-end Text-to-Speech (VITS) + +原论文链接：https://arxiv.org/abs/2106.06103 + +原仓库链接：https://github.com/jaywalnut310/vits + +## 完成的功能 + +对VITS的训练整合到talkingface-toolkit的框架中，实现训练功能 + +## 最终实现的训练 +![img.png](readme_img/img.png) + +## 验证截图 + + +## 所使用的依赖 + + +## 成员分工 diff --git a/environment_vits.yml b/environment_vits.yml new file mode 100644 index 00000000..ed5d4c28 --- /dev/null +++ b/environment_vits.yml @@ -0,0 +1,180 @@ +name: vits +channels: + - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r + - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main + - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free + - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/ + - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r/ + - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ + - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ + - defaults +dependencies: + - blas=1.0=mkl + - blosc=1.21.3=h6c2663c_0 + - bottleneck=1.3.5=py37h080aedc_0 + - brotli=1.0.9=h2bbff1b_7 + - brotli-bin=1.0.9=h2bbff1b_7 + - bzip2=1.0.8=he774522_0 + - ca-certificates=2023.12.12=haa95532_0 + - certifi=2022.12.7=py37haa95532_0 + - cfitsio=3.470=h2bbff1b_7 + - charls=2.2.0=h6c2663c_0 + - cloudpickle=2.0.0=pyhd3eb1b0_0 + - colorama=0.4.6=py37haa95532_0 + - colorlog=5.0.1=py37haa95532_1 + - cytoolz=0.12.0=py37h2bbff1b_0 + - dask-core=2021.3.0=pyhd3eb1b0_0 + - eigen=3.4.0=h59b6b97_0 + - ffmpeg=4.2.2=he774522_0 + - freetype=2.12.1=ha860e81_0 + - giflib=5.2.1=h8cc25b3_3 + - glib=2.69.1=h5dc1a3c_2 + - gst-plugins-base=1.18.5=h9e645db_0 + - gstreamer=1.18.5=hd78058f_0 + - hdf5=1.10.6=h1756f20_1 + - icc_rt=2022.1.0=h6049295_2 + - icu=58.2=ha925a31_3 + - imagecodecs=2021.8.26=py37h319e4f4_2 + - imageio=2.19.3=py37haa95532_0 + - intel-openmp=2023.1.0=h59b6b97_46320 + - jpeg=9e=h2bbff1b_1 + - jxrlib=1.1=he774522_2 + - krb5=1.20.1=h5b6d351_1 + - lcms2=2.12=h83e58a3_0 + - lerc=3.0=hd77b12b_0 + - libaec=1.0.4=h33f27b4_1 + - libbrotlicommon=1.0.9=h2bbff1b_7 + - libbrotlidec=1.0.9=h2bbff1b_7 + - libbrotlienc=1.0.9=h2bbff1b_7 + - libclang=14.0.6=default_hb5a9fac_1 + - libclang13=14.0.6=default_h8e68704_1 + - libdeflate=1.17=h2bbff1b_1 + - libffi=3.4.4=hd77b12b_0 + - libiconv=1.16=h2bbff1b_2 + - libogg=1.3.5=h2bbff1b_1 + - libpng=1.6.39=h8cc25b3_0 + - libpq=12.15=hb652d5d_1 + - libprotobuf=3.20.3=h23ce68f_0 + - libtiff=4.5.1=hd77b12b_0 + - libvorbis=1.3.7=he774522_0 + - libwebp=1.3.2=hbc33d0d_0 + - libwebp-base=1.3.2=h2bbff1b_0 + - libxml2=2.10.4=h0ad7f3c_1 + - libxslt=1.1.37=h2bbff1b_1 + - libzopfli=1.0.3=ha925a31_0 + - lz4-c=1.9.4=h2bbff1b_0 + - mkl=2019.4=245 + - mkl-service=2.3.0=py37h196d8e1_0 + - mkl_fft=1.0.14=py37h6288b17_0 + - mkl_random=1.0.4=py37h343c172_0 + - networkx=2.6.3=pyhd3eb1b0_0 + - numexpr=2.7.3=py37hcbcaa1e_0 + - numpy-base=1.19.2=py37ha3acd2a_0 + - opencv=4.6.0=py37hf11a4ad_3 + - openjpeg=2.4.0=h4fc8c34_0 + - openssl=1.1.1w=h2bbff1b_0 + - pandas=1.3.5=py37h6214cd6_0 + - pcre=8.45=hd77b12b_0 + - python=3.7.16=h6244533_0 + - python-dateutil=2.8.2=pyhd3eb1b0_0 + - pytz=2022.7=py37haa95532_0 + - pywavelets=1.3.0=py37h2bbff1b_0 + - pyyaml=6.0=py37h2bbff1b_1 + - qt-main=5.15.2=h6072711_9 + - qt-webengine=5.15.9=h5bd16bc_7 + - qtwebkit=5.212=h2bbfb41_5 + - scikit-image=0.19.3=py37hd77b12b_1 + - setuptools=65.6.3=py37haa95532_0 + - six=1.16.0=pyhd3eb1b0_1 + - snappy=1.1.10=h6c2663c_1 + - sqlite=3.41.2=h2bbff1b_0 + - texttable=1.6.4=pyhd3eb1b0_0 + - tifffile=2021.7.2=pyhd3eb1b0_2 + - tk=8.6.12=h2bbff1b_0 + - toolz=0.12.0=py37haa95532_0 + - tqdm=4.64.1=py37haa95532_0 + - vc=14.2=h21ff451_1 + - vs2015_runtime=14.27.29016=h5e58377_2 + - wheel=0.38.4=py37haa95532_0 + - wincertstore=0.2=py37haa95532_2 + - xz=5.4.5=h8cc25b3_0 + - yaml=0.2.5=he774522_0 + - zfp=0.5.5=hd77b12b_6 + - zlib=1.2.13=h8cc25b3_0 + - zstd=1.5.5=hd43e919_0 + - pip: + - absl-py==2.0.0 + - annotated-types==0.5.0 + - audioread==3.0.1 + - backports-functools-lru-cache==1.6.6 + - cachetools==4.2.4 + - cffi==1.15.1 + - charset-normalizer==3.3.2 + - click==8.1.7 + - cn2an==0.5.17 + - cycler==0.11.0 + - cython==0.29.21 + - decorator==5.1.1 + - eng-to-ipa==0.0.2 + - google-auth==1.35.0 + - google-auth-oauthlib==0.4.6 + - grpcio==1.60.0 + - idna==3.6 + - importlib-metadata==6.7.0 + - indic-transliteration==2.3.37 + - inflect==6.0.0 + - jamo==0.4.1 + - jieba==0.42.1 + - joblib==1.3.2 + - kiwisolver==1.4.5 + - ko-pron==1.3 + - librosa==0.8.0 + - llvmlite==0.39.1 + - markdown==3.4.4 + - markupsafe==2.1.3 + - matplotlib==3.3.1 + - num-thai==0.0.5 + - numba==0.56.4 + - numpy==1.21.6 + - oauthlib==3.2.2 + - opencc==1.1.1 + - packaging==23.2 + - pillow==9.5.0 + - pip==23.3.1 + - platformdirs==4.0.0 + - pooch==1.8.0 + - proces==0.1.7 + - protobuf==3.19.0 + - pyasn1==0.5.1 + - pyasn1-modules==0.3.0 + - pycparser==2.21 + - pydantic==2.5.2 + - pydantic-core==2.14.5 + - pynacl==1.5.0 + - pyparsing==3.1.1 + - pypinyin==0.44.0 + - python-speech-features==0.6 + - regex==2023.10.3 + - requests==2.31.0 + - requests-oauthlib==1.3.1 + - resampy==0.4.2 + - roman==4.1 + - rsa==4.9 + - ruamel-yaml==0.18.5 + - ruamel-yaml-clib==0.2.8 + - scikit-learn==1.0.2 + - scipy==1.5.2 + - soundfile==0.12.1 + - tensorboard==2.3.0 + - tensorboard-plugin-wit==1.8.1 + - threadpoolctl==3.1.0 + - toml==0.10.2 + - torch==1.13.1+cu117 + - torchaudio==0.13.1+cu117 + - torchvision==0.14.1+cu117 + - typer==0.9.0 + - typing-extensions==4.7.1 + - unidecode==1.3.4 + - urllib3==2.0.7 + - werkzeug==2.2.3 + - zipp==3.15.0 diff --git a/readme_img/img.png b/readme_img/img.png new file mode 100644 index 0000000000000000000000000000000000000000..9a141ddb7f3a5be37d6b8aecc735c08dc6e30211 GIT binary patch literal 243471 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 I3vN&T2dFbBkN^Mx literal 0 HcmV?d00001 From 51f58186e1552ab3d60f90665ac5a91d948d464a Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 12:44:49 +0800 Subject: [PATCH 12/16] =?UTF-8?q?=E7=BC=96=E5=86=99README=5FVITS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README_VITS.md | 49 ++++++++++++++++++++++++-- readme_img/{img.png => train_img.png} | Bin readme_img/val_img.png | Bin 0 -> 118287 bytes 3 files changed, 47 insertions(+), 2 deletions(-) rename readme_img/{img.png => train_img.png} (100%) create mode 100644 readme_img/val_img.png diff --git a/README_VITS.md b/README_VITS.md index 9926e8fd..e0b39903 100644 --- a/README_VITS.md +++ b/README_VITS.md @@ -6,15 +6,60 @@ ## 完成的功能 -对VITS的训练整合到talkingface-toolkit的框架中，实现训练功能 +对VITS的训练整合到talkingface的框架中，实现训练功能。 ## 最终实现的训练 -![img.png](readme_img/img.png) + +目前实现的是单人说话，使用的是LJSpeech英文演讲数据集，因为训练需要的时间过久，而且将代码放到talkingface，缩减了一些训练加速相关的代码，移除了部分多gpu分布式训练相关代码，因而训练速度极慢…… + +使用当前的代码，在我的电脑上运行了半个小时1个epoch都没有结束…… + +### 下面看看如何在这里进行训练吧： + +在最终训练之前，需要先初始化环境下载LJSpeech数据集，可以从[百度网盘下载]()，里面有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 + +假设下载的是处理过可以直接用的，将压缩包放到文件夹`dataset`下面，将压缩包中的内容解压到当前文件夹即可。 + +下载好数据集后，还有一步很重要的操作：Build monotonic alignment search。 + +首先开启当前虚拟环境，在`talkingface/utils/vits_utils/monotonic_align`目录下的终端中运行如下代码： + +```bash +python setup.py build_ext --inplace +``` + +linux会直接成功，windows一般会报错。 + +如果出现“可能丢失数据”字样，并且该文件夹没有再嵌套一个monotonic_align文件夹，但是多出来了build文件夹，将build文件夹中的lib开头的文件夹中的monotonic_align文件夹移动到最外层的monotonic_align文件夹即可。 + +注意：Windows下build后的core不与Linux通用，如果更换平台需要重新build。 + +之后在仓库的根路径下打开终端，复制下面的指令即可进行训练。如果想要测试，可以将模型放入[MoeGoe](https://github.com/CjangCjengh/MoeGoe)中进行语音的生成 + +```bash +python run_talkingface.py --model=VITS --dataset=LJSpeech +``` + +![img.png](readme_img/train_img.png) ## 验证截图 +通过原来的代码仓库给出的一个软件可以进行验证生成语音： + +![img.png](readme_img/val_img.png) ## 所使用的依赖 +因为VITS用的是python3.7，所以就也用了同样的版本，别的依赖和原仓库略有不同，具体可以看[environment_vits.yml](environment_vits.yml) + +- `python=3.8` +- `torch==1.13.1+cu117` +- `librosa==0.8.0` + +通过下面的方式安装环境（这是windows环境）： + +``` +conda env create -f environment_vits.yml +``` ## 成员分工 diff --git a/readme_img/img.png b/readme_img/train_img.png similarity index 100% rename from readme_img/img.png rename to readme_img/train_img.png diff --git a/readme_img/val_img.png b/readme_img/val_img.png new file mode 100644 index 0000000000000000000000000000000000000000..55875cfc154e21a46b622ab29654b75161fe4a06 GIT binary patch literal 118287 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 Date: Sun, 24 Dec 2023 12:55:05 +0800 Subject: [PATCH 13/16] =?UTF-8?q?=E7=BC=96=E5=86=99README=5FVITS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README_VITS.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/README_VITS.md b/README_VITS.md index e0b39903..d726ffe3 100644 --- a/README_VITS.md +++ b/README_VITS.md @@ -14,7 +14,7 @@ 使用当前的代码，在我的电脑上运行了半个小时1个epoch都没有结束…… -### 下面看看如何在这里进行训练吧： +### 如何在这里进行训练： 在最终训练之前，需要先初始化环境下载LJSpeech数据集，可以从[百度网盘下载]()，里面有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 @@ -56,10 +56,14 @@ python run_talkingface.py --model=VITS --dataset=LJSpeech - `torch==1.13.1+cu117` - `librosa==0.8.0` -通过下面的方式安装环境（这是windows环境）： +通过下面的方式安装环境（这个environment_vits.yml是windows环境下导出的，linux可能用不了，不过可以参考vits源码中的requirements.txt下载）： -``` +```bash conda env create -f environment_vits.yml ``` ## 成员分工 + +- 柳绍祯：阅读vits源码，对代码重构做出理解，让最终的代码成功运行 +- 尹祯：整合数据集、参数配置、模型方面的代码 +- 白宇：整合训练和测试过程相关代码 \ No newline at end of file From c75d4c43cb93289ae7521741a49c916cea70f2cb Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 14:14:51 +0800 Subject: [PATCH 14/16] =?UTF-8?q?=E7=BC=96=E5=86=99README=5FVITS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README_VITS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README_VITS.md b/README_VITS.md index d726ffe3..eb68b677 100644 --- a/README_VITS.md +++ b/README_VITS.md @@ -16,7 +16,7 @@ ### 如何在这里进行训练： -在最终训练之前，需要先初始化环境下载LJSpeech数据集，可以从[百度网盘下载]()，里面有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 +在最终训练之前，需要先初始化环境下载LJSpeech数据集，可以从[百度网盘下载](链接：https://pan.baidu.com/s/1oTBcZawH7YpysQeYk8-5fw?pwd=706s)，里面有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 假设下载的是处理过可以直接用的，将压缩包放到文件夹`dataset`下面，将压缩包中的内容解压到当前文件夹即可。 From fb1443c425a8bcfb8db4b1c0260c0a4a65d6114c Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Sun, 24 Dec 2023 14:16:23 +0800 Subject: [PATCH 15/16] =?UTF-8?q?=E7=BC=96=E5=86=99README=5FVITS?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README_VITS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README_VITS.md b/README_VITS.md index eb68b677..532199f1 100644 --- a/README_VITS.md +++ b/README_VITS.md @@ -16,7 +16,7 @@ ### 如何在这里进行训练： -在最终训练之前，需要先初始化环境下载LJSpeech数据集，可以从[百度网盘下载](链接：https://pan.baidu.com/s/1oTBcZawH7YpysQeYk8-5fw?pwd=706s)，里面有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 +在最终训练之前，需要先初始化环境下载LJSpeech数据集，可以从[百度网盘下载](https://pan.baidu.com/s/1oTBcZawH7YpysQeYk8-5fw?pwd=706s)，里面有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 假设下载的是处理过可以直接用的，将压缩包放到文件夹`dataset`下面，将压缩包中的内容解压到当前文件夹即可。 From 3b242b84e4812566c64830e9a32d126d828cce0c Mon Sep 17 00:00:00 2001 From: ShaoZhenLiu <1326330421@qq.com> Date: Mon, 29 Jan 2024 12:18:03 +0800 Subject: [PATCH 16/16] =?UTF-8?q?=E6=9B=B4=E6=96=B0readme?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 272 +- README_VITS.md | 69 - environment.yml | 138 - ...t_vits.yml => environment_vits_windows.yml | 0 readme_img/train_img_linux.png | Bin 0 -> 149197 bytes .../{train_img.png => train_img_windows.png} | Bin requirements.txt | 114 - requirements_vits_linux.txt | 82 + talkingface/properties/model/VITS.yaml | 2 +- talkingface/properties/overall.yaml | 2 +- talkingface/trainer/trainer.py | 3 +- .../core.cpython-37m-x86_64-linux-gnu.so | Bin 0 -> 1323528 bytes .../build/temp.linux-x86_64-cpython-37/core.o | Bin 0 -> 3192968 bytes .../utils/vits_utils/monotonic_align/core.c | 23816 ++++++++++------ .../core.cpython-37m-x86_64-linux-gnu.so | Bin 0 -> 1323528 bytes .../core.cpython-37m-x86_64-linux-gnu.so | Bin 0 -> 1323528 bytes 16 files changed, 15213 insertions(+), 9285 deletions(-) delete mode 100644 README_VITS.md delete mode 100644 environment.yml rename environment_vits.yml => environment_vits_windows.yml (100%) create mode 100644 readme_img/train_img_linux.png rename readme_img/{train_img.png => train_img_windows.png} (100%) delete mode 100644 requirements.txt create mode 100644 requirements_vits_linux.txt create mode 100644 talkingface/utils/vits_utils/monotonic_align/build/lib.linux-x86_64-cpython-37/talkingface/utils/vits_utils/monotonic_align/core.cpython-37m-x86_64-linux-gnu.so create mode 100644 talkingface/utils/vits_utils/monotonic_align/build/temp.linux-x86_64-cpython-37/core.o create mode 100644 talkingface/utils/vits_utils/monotonic_align/core.cpython-37m-x86_64-linux-gnu.so create mode 100644 talkingface/utils/vits_utils/monotonic_align/monotonic_align/core.cpython-37m-x86_64-linux-gnu.so diff --git a/README.md b/README.md index 7cd82328..71997365 100644 --- a/README.md +++ b/README.md @@ -1,210 +1,172 @@ -# talkingface-toolkit -## 框架整体介绍 -### checkpoints -主要保存的是训练和评估模型所需要的额外的预训练模型，在对应文件夹的[README](https://github.com/Academic-Hammer/talkingface-toolkit/blob/main/checkpoints/README.md)有更详细的介绍 +# Variational Inference with adversarial learning for end-to-end Text-to-Speech (VITS) -### datset -存放数据集以及数据集预处理之后的数据，详细内容见dataset里的[README](https://github.com/Academic-Hammer/talkingface-toolkit/blob/main/dataset/README.md) +原论文链接：https://arxiv.org/abs/2106.06103 -### saved -存放训练过程中保存的模型checkpoint, 训练过程中保存模型时自动创建 +原仓库链接：https://github.com/jaywalnut310/vits -### talkingface -主要功能模块，包括所有核心代码 +## 完成的功能 -#### config -根据模型和数据集名称自动生成所有模型、数据集、训练、评估等相关的配置信息 -``` -config/ +1. 对VITS的训练整合到talkingface的框架中 -├── configurator.py +2. 实现训练功能 -``` -#### data -- dataprocess：模型特有的数据处理代码，（可以是对方仓库自己实现的音频特征提取、推理时的数据处理）。如果实现的模型有这个需求，就要建立一对应的文件 -- dataset：每个模型都要重载`torch.utils.data.Dataset` 用于加载数据。每个模型都要有一个`model_name+'_dataset.py'`文件. `__getitem__()`方法的返回值应处理成字典类型的数据。 (核心部分) -``` -data/ +3. 推理部分通过使用MoeGoe实现 -├── dataprocess -| ├── wav2lip_process.py -| ├── xxxx_process.py +## 最终实现的训练 -├── dataset +目前实现的是单人说话，使用的是LJSpeech英文演讲数据集，因为训练需要的时间过久，而且将代码放到talkingface，缩减了一些训练加速相关的代码，移除了部分多gpu分布式训练相关代码，因而训练速度极慢…… -| ├── wav2lip_dataset.py +使用当前的代码，在windows笔记本上运行了半个小时1个epoch都没有结束…… -| ├── xxx_dataset.py -``` +另外，本代码已经经过linux运行验证，并不会出现移植后训练代码错误的情况，部署具有可靠性。 -#### evaluate -主要涉及模型评估的代码 -LSE metric 需要的数据是生成的视频列表 -SSIM metric 需要的数据是生成的视频和真实的视频列表 -#### model -实现的模型的网络和对应的方法 （核心部分） -主要分三类： -- audio-driven (音频驱动) -- image-driven （图像驱动） -- nerf-based （基于神经辐射场的方法） +### 如何在这里进行训练： -``` -model/ +#### 1. 创建虚拟环境 -├── audio_driven_talkingface +首先创建虚拟环境： -| ├── wav2lip.py +```bash +conda create -n vits_linux python=3.7 -y +conda activate vits_linux + +# PyTorch 1.13.1 +# CUDA 11.6 +pip install torch==1.13.1+cu116 torchvision==0.14.1+cu116 torchaudio==0.13.1 --extra-index-url https://download.pytorch.org/whl/cu116 + +pip install librosa==0.8.0 + +pip install cython + +pip install pyyaml +pip install colorlog +pip install pandas +pip install tensorboard +pip install texttable +pip install colorama +pip install tqdm +pip install opencv-python +pip install jamo +pip install ko_pron +pip install pypinyin +pip install jieba +pip install cn2an +pip install indic_transliteration +pip install num_thai +pip install opencc +pip install python_speech_features +pip install scikit-image +``` -├── image_driven_talkingface +上面的流程在linux下成功运行，遵守上面的安装步骤应该可以成功运行本代码。 -| ├── xxxx.py +如果没有成功运行本代码，大部分的错误应当是缺少某些库，可以直接使用pip install进行下载安装。 -├── nerf_based_talkingface +除了上面的安装环境方式，还可以使用下面的命令直接安装： -| ├── xxxx.py +* 假如是linux： -├── abstract_talkingface.py + ```bash + conda create -n vits_linux python=3.7 -y + conda activate vits_linux + pip install -r requirements_vits_linux.txt + ``` -``` +* 假如是windows： -#### properties -保存默认配置文件，包括： -- 数据集配置文件 -- 模型配置文件 -- 通用配置文件 + ```bash + conda env create -f environment_vits_windows.yml + ``` -需要根据对应模型和数据集增加对应的配置文件，通用配置文件`overall.yaml`一般不做修改 -``` -properties/ -├── dataset -| ├── xxx.yaml +#### 2. 下载并解压数据集 -├── model +在最终训练之前，需要先初始化环境下载LJSpeech数据集，既可以从[官网下载](https://keithito.com/LJ-Speech-Dataset/)，也可以从[百度网盘下载](https://pan.baidu.com/s/1oTBcZawH7YpysQeYk8-5fw?pwd=706s)。 -| ├── xxx.yaml +百度网盘中有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 -├── overall.yaml +假设下载的是处理过可以直接用的，**将压缩包放到文件夹`dataset`下面**，将压缩包中的内容解压到当前文件夹即可： +```bash +cd ./dataset +unzip LJSpeech_processed.zip +cd .. ``` -#### quick_start -通用的启动文件，根据传入参数自动配置数据集和模型，然后训练和评估（一般不需要修改） -``` -quick_start/ -├── quick_start.py -``` +#### 3. Build monotonic alignment search -#### trainer -训练、评估函数的主类。在trainer中，如果可以使用基类`Trainer`实现所有功能，则不需要写一个新的。如果模型训练有一些特有部分，则需要重载`Trainer`。需要重载部分可能主要集中于: `_train_epoch()`, `_valid_epoch()`。 重载的`Trainer`应该命名为：`{model_name}Trainer` -``` -trainer/ +下载好数据集后，还有一步很重要的操作：Build monotonic alignment search。 + +首先开启当前虚拟环境，运行如下代码： -├── trainer.py +```bash +# 需要先到talkingface/utils/vits_utils/monotonic_align/文件夹下 +cd ./talkingface/utils/vits_utils/monotonic_align/ +# 然后build +python setup.py build_ext --inplace ``` -#### utils -公用的工具类，包括`s3fd`人脸检测，视频抽帧、视频抽音频方法。还包括根据参数配置找对应的模型类、数据类等方法。 -一般不需要修改，但可以适当添加一些必须的且相对普遍的数据处理文件。 +linux会直接成功，windows一般会报错。 -## 使用方法 -### 环境要求 -- `python=3.8` -- `torch==1.13.1+cu116`（gpu版，若设备不支持cuda可以使用cpu版） -- `numpy==1.20.3` -- `librosa==0.10.1` +如果出现“可能丢失数据”字样，并且该文件夹没有再嵌套一个monotonic_align文件夹，但是多出来了build文件夹，将build文件夹中的lib开头的文件夹中的monotonic_align文件夹移动到最外层的monotonic_align文件夹即可。 -尽量保证上面几个包的版本一致 +**注意：Windows下build后的core不与Linux通用，如果更换平台需要重新build。** -提供了两种配置其他环境的方法： -``` -pip install -r requirements.txt -or -conda env create -f environment.yml -``` +#### 4. 调整训练参数 + +在文件夹`talkingface/properties/`下是模型的参数设置，比较重要的设置有两个： + +1. `overall.yaml`中的第一个`gpu_id`设置，设置其在哪个gpu上训练，训练前请不要忘记选择正确的gpu进行训练 +2. `model/VITS.yaml`中存储的是有关模型训练时的设置，其中的`batch_size`参数和gpu内存占用高度相关，请调整其到合适的大小 + -建议使用conda虚拟环境！！！ -### 训练和评估 +#### 5. 运行训练代码 + +之后在仓库的根路径下打开终端，复制下面的指令即可进行训练。如果想要测试，可以将模型放入[MoeGoe](https://github.com/CjangCjengh/MoeGoe)中进行语音的生成 ```bash -python run_talkingface.py --model=xxxx --dataset=xxxx (--other_parameters=xxxxxx) +python run_talkingface.py --model=VITS --dataset=LJSpeech ``` -### 权重文件 - -- LSE评估需要的权重: syncnet_v2.model [百度网盘下载](https://pan.baidu.com/s/1vQoL9FuKlPyrHOGKihtfVA?pwd=32hc) -- wav2lip需要的lip expert 权重：lipsync_expert.pth [百度网下载](https://pan.baidu.com/s/1vQoL9FuKlPyrHOGKihtfVA?pwd=32hc) - -## 可选论文： -### Aduio_driven talkingface -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| MakeItTalk | [paper](https://arxiv.org/abs/2004.12992) | [code](https://github.com/yzhou359/MakeItTalk) | -| MEAD | [paper](https://wywu.github.io/projects/MEAD/support/MEAD.pdf) | [code](https://github.com/uniBruce/Mead) | -| RhythmicHead | [paper](https://arxiv.org/pdf/2007.08547v1.pdf) | [code](https://github.com/lelechen63/Talking-head-Generation-with-Rhythmic-Head-Motion) | -| PC-AVS | [paper](https://arxiv.org/abs/2104.11116) | [code](https://github.com/Hangz-nju-cuhk/Talking-Face_PC-AVS) | -| EVP | [paper](https://openaccess.thecvf.com/content/CVPR2021/papers/Ji_Audio-Driven_Emotional_Video_Portraits_CVPR_2021_paper.pdf) | [code](https://github.com/jixinya/EVP) | -| LSP | [paper](https://arxiv.org/abs/2109.10595) | [code](https://github.com/YuanxunLu/LiveSpeechPortraits) | -| EAMM | [paper](https://arxiv.org/pdf/2205.15278.pdf) | [code](https://github.com/jixinya/EAMM/) | -| DiffTalk | [paper](https://arxiv.org/abs/2301.03786) | [code](https://github.com/sstzal/DiffTalk) | -| TalkLip | [paper](https://arxiv.org/pdf/2303.17480.pdf) | [code](https://github.com/Sxjdwang/TalkLip) | -| EmoGen | [paper](https://arxiv.org/pdf/2303.11548.pdf) | [code](https://github.com/sahilg06/EmoGen) | -| SadTalker | [paper](https://arxiv.org/abs/2211.12194) | [code](https://github.com/OpenTalker/SadTalker) | -| HyperLips | [paper](https://arxiv.org/abs/2310.05720) | [code](https://github.com/semchan/HyperLips) | -| PHADTF | [paper](http://arxiv.org/abs/2002.10137) | [code](https://github.com/yiranran/Audio-driven-TalkingFace-HeadPose) | -| VideoReTalking | [paper](https://arxiv.org/abs/2211.14758) | [code](https://github.com/OpenTalker/video-retalking#videoretalking--audio-based-lip-synchronization-for-talking-head-video-editing-in-the-wild-) -| | - - - -### Image_driven talkingface -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| PIRenderer | [paper](https://arxiv.org/pdf/2109.08379.pdf) | [code](https://github.com/RenYurui/PIRender) | -| StyleHEAT | [paper](https://arxiv.org/pdf/2203.04036.pdf) | [code](https://github.com/OpenTalker/StyleHEAT) | -| MetaPortrait | [paper](https://arxiv.org/abs/2212.08062) | [code](https://github.com/Meta-Portrait/MetaPortrait) | -| | -### Nerf-based talkingface -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| AD-NeRF | [paper](https://arxiv.org/abs/2103.11078) | [code](https://github.com/YudongGuo/AD-NeRF) | -| GeneFace | [paper](https://arxiv.org/abs/2301.13430) | [code](https://github.com/yerfor/GeneFace) | -| DFRF | [paper](https://arxiv.org/abs/2207.11770) | [code](https://github.com/sstzal/DFRF) | -| | -### text_to_speech -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| VITS | [paper](https://arxiv.org/abs/2106.06103) | [code](https://github.com/jaywalnut310/vits) | -| Glow TTS | [paper](https://arxiv.org/abs/2005.11129) | [code](https://github.com/jaywalnut310/glow-tts) | -| FastSpeech2 | [paper](https://arxiv.org/abs/2006.04558v1) | [code](https://github.com/ming024/FastSpeech2) | -| StyleTTS2 | [paper](https://arxiv.org/abs/2306.07691) | [code](https://github.com/yl4579/StyleTTS2) | -| Grad-TTS | [paper](https://arxiv.org/abs/2105.06337) | [code](https://github.com/huawei-noah/Speech-Backbones/tree/main/Grad-TTS) | -| FastSpeech | [paper](https://arxiv.org/abs/1905.09263) | [code](https://github.com/xcmyz/FastSpeech) | -| | -### voice_conversion -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| StarGAN-VC | [paper](http://www.kecl.ntt.co.jp/people/kameoka.hirokazu/Demos/stargan-vc2/index.html) | [code](https://github.com/kamepong/StarGAN-VC) | -| Emo-StarGAN | [paper](https://www.researchgate.net/publication/373161292_Emo-StarGAN_A_Semi-Supervised_Any-to-Many_Non-Parallel_Emotion-Preserving_Voice_Conversion) | [code](https://github.com/suhitaghosh10/emo-stargan) | -| adaptive-VC | [paper](https://arxiv.org/abs/1904.05742) | [code](https://github.com/jjery2243542/adaptive_voice_conversion) | -| DiffVC | [paper](https://arxiv.org/abs/2109.13821) | [code](https://github.com/huawei-noah/Speech-Backbones/tree/main/DiffVC) | -| Assem-VC | [paper](https://arxiv.org/abs/2104.00931) | [code](https://github.com/maum-ai/assem-vc) | -| | - -## 作业要求 -- 确保可以仅在命令行输入模型和数据集名称就可以训练、验证。（部分仓库没有提供训练代码的，可以不训练） -- 每个组都要提交一个README文件，写明完成的功能、最终实现的训练、验证截图、所使用的依赖、成员分工等。 +* windows上的训练（因为太慢了所以就截了一个训练开始的图）： + ![img.png](./readme_img/train_img_windows.png) + +* linux上的训练： + ![img.png](./readme_img/train_img_linux.png) + + + +## 验证截图 + +通过原来的代码仓库给出的一个软件（MoeGoe）可以进行推理，生成语音： + +![img.png](./readme_img/val_img.png) + + + +## 所使用的依赖 + +因为VITS用的是python3.7，所以就也用了同样的版本，别的依赖和原仓库略有不同，具体可以看[environment_vits_windows.yml](./environment_vits_windows.yml)或是[requirements_vits_linux.txt](./requirements_vits_linux.txt) + +- `python=3.7` +- `torch==1.13.1+cu117` +- `librosa==0.8.0` +环境的安装方法已经在上面有过介绍了，如果需要的话可以看[创建虚拟环境](#1. 创建虚拟环境)那一节 +## 成员分工 +- 柳绍祯：阅读vits源码，对代码重构做出理解，让最终的代码成功运行 +- 尹祯：整合数据集、参数配置、模型方面的代码 +- 白宇：整合训练和测试过程相关代码 \ No newline at end of file diff --git a/README_VITS.md b/README_VITS.md deleted file mode 100644 index 532199f1..00000000 --- a/README_VITS.md +++ /dev/null @@ -1,69 +0,0 @@ -# Variational Inference with adversarial learning for end-to-end Text-to-Speech (VITS) - -原论文链接：https://arxiv.org/abs/2106.06103 - -原仓库链接：https://github.com/jaywalnut310/vits - -## 完成的功能 - -对VITS的训练整合到talkingface的框架中，实现训练功能。 - -## 最终实现的训练 - -目前实现的是单人说话，使用的是LJSpeech英文演讲数据集，因为训练需要的时间过久，而且将代码放到talkingface，缩减了一些训练加速相关的代码，移除了部分多gpu分布式训练相关代码，因而训练速度极慢…… - -使用当前的代码，在我的电脑上运行了半个小时1个epoch都没有结束…… - -### 如何在这里进行训练： - -在最终训练之前，需要先初始化环境下载LJSpeech数据集，可以从[百度网盘下载](https://pan.baidu.com/s/1oTBcZawH7YpysQeYk8-5fw?pwd=706s)，里面有两个版本，`LJSpeech-1.1.zip`是没有处理过的，`LJSpeech_processed.zip`是处理过可以直接用的。 - -假设下载的是处理过可以直接用的，将压缩包放到文件夹`dataset`下面，将压缩包中的内容解压到当前文件夹即可。 - -下载好数据集后，还有一步很重要的操作：Build monotonic alignment search。 - -首先开启当前虚拟环境，在`talkingface/utils/vits_utils/monotonic_align`目录下的终端中运行如下代码： - -```bash -python setup.py build_ext --inplace -``` - -linux会直接成功，windows一般会报错。 - -如果出现“可能丢失数据”字样，并且该文件夹没有再嵌套一个monotonic_align文件夹，但是多出来了build文件夹，将build文件夹中的lib开头的文件夹中的monotonic_align文件夹移动到最外层的monotonic_align文件夹即可。 - -注意：Windows下build后的core不与Linux通用，如果更换平台需要重新build。 - -之后在仓库的根路径下打开终端，复制下面的指令即可进行训练。如果想要测试，可以将模型放入[MoeGoe](https://github.com/CjangCjengh/MoeGoe)中进行语音的生成 - -```bash -python run_talkingface.py --model=VITS --dataset=LJSpeech -``` - -![img.png](readme_img/train_img.png) - -## 验证截图 - -通过原来的代码仓库给出的一个软件可以进行验证生成语音： - -![img.png](readme_img/val_img.png) - -## 所使用的依赖 - -因为VITS用的是python3.7，所以就也用了同样的版本，别的依赖和原仓库略有不同，具体可以看[environment_vits.yml](environment_vits.yml) - -- `python=3.8` -- `torch==1.13.1+cu117` -- `librosa==0.8.0` - -通过下面的方式安装环境（这个environment_vits.yml是windows环境下导出的，linux可能用不了，不过可以参考vits源码中的requirements.txt下载）： - -```bash -conda env create -f environment_vits.yml -``` - -## 成员分工 - -- 柳绍祯：阅读vits源码，对代码重构做出理解，让最终的代码成功运行 -- 尹祯：整合数据集、参数配置、模型方面的代码 -- 白宇：整合训练和测试过程相关代码 \ No newline at end of file diff --git a/environment.yml b/environment.yml deleted file mode 100644 index 09a8595b..00000000 --- a/environment.yml +++ /dev/null @@ -1,138 +0,0 @@ -name: torch38 -channels: - - defaults -dependencies: - - _libgcc_mutex=0.1=main - - _openmp_mutex=5.1=1_gnu - - ca-certificates=2023.08.22=h06a4308_0 - - ld_impl_linux-64=2.38=h1181459_1 - - libffi=3.4.4=h6a678d5_0 - - libgcc-ng=11.2.0=h1234567_1 - - libgomp=11.2.0=h1234567_1 - - libstdcxx-ng=11.2.0=h1234567_1 - - ncurses=6.4=h6a678d5_0 - - openssl=3.0.12=h7f8727e_0 - - pip=23.3=py38h06a4308_0 - - python=3.8.18=h955ad1f_0 - - readline=8.2=h5eee18b_0 - - setuptools=68.0.0=py38h06a4308_0 - - sqlite=3.41.2=h5eee18b_0 - - tk=8.6.12=h1ccaba5_0 - - wheel=0.41.2=py38h06a4308_0 - - xz=5.4.2=h5eee18b_0 - - zlib=1.2.13=h5eee18b_0 - - pip: - - absl-py==2.0.0 - - addict==2.4.0 - - aiosignal==1.3.1 - - appdirs==1.4.4 - - attrs==23.1.0 - - audioread==3.0.1 - - basicsr==1.3.4.7 - - cachetools==5.3.2 - - certifi==2020.12.5 - - cffi==1.16.0 - - charset-normalizer==3.3.2 - - click==8.1.7 - - cloudpickle==3.0.0 - - colorama==0.4.6 - - colorlog==6.7.0 - - contourpy==1.1.1 - - cycler==0.12.1 - - decorator==5.1.1 - - dlib==19.22.1 - - docker-pycreds==0.4.0 - - face-alignment==1.3.5 - - ffmpeg==1.4 - - filelock==3.13.1 - - fonttools==4.44.0 - - frozenlist==1.4.0 - - future==0.18.3 - - gitdb==4.0.11 - - gitpython==3.1.40 - - glob2==0.7 - - google-auth==2.23.4 - - google-auth-oauthlib==0.4.6 - - grpcio==1.59.2 - - hyperopt==0.2.5 - - idna==3.4 - - imageio==2.9.0 - - imageio-ffmpeg==0.4.5 - - importlib-metadata==6.8.0 - - importlib-resources==6.1.0 - - joblib==1.3.2 - - jsonschema==4.19.2 - - jsonschema-specifications==2023.7.1 - - kiwisolver==1.4.5 - - kornia==0.5.5 - - lazy-loader==0.3 - - librosa==0.10.1 - - llvmlite==0.37.0 - - lmdb==1.2.1 - - lws==1.2.7 - - markdown==3.5.1 - - markupsafe==2.1.3 - - matplotlib==3.6.3 - - msgpack==1.0.7 - - networkx==3.1 - - numba==0.54.1 - - numpy==1.20.3 - - oauthlib==3.2.2 - - opencv-python==3.4.9.33 - - packaging==23.2 - - pandas==1.3.4 - - pathtools==0.1.2 - - pillow==6.2.1 - - pkgutil-resolve-name==1.3.10 - - platformdirs==3.11.0 - - plotly==5.18.0 - - pooch==1.8.0 - - protobuf==4.25.0 - - psutil==5.9.6 - - pyasn1==0.5.0 - - pyasn1-modules==0.3.0 - - pycparser==2.21 - - pyparsing==3.1.1 - - python-dateutil==2.8.2 - - python-speech-features==0.6 - - pytorch-fid==0.3.0 - - pytz==2023.3.post1 - - pywavelets==1.4.1 - - pyyaml==5.3.1 - - ray==2.6.3 - - referencing==0.30.2 - - requests==2.31.0 - - requests-oauthlib==1.3.1 - - rpds-py==0.12.0 - - rsa==4.9 - - scikit-image==0.16.2 - - scikit-learn==1.3.2 - - scipy==1.5.0 - - sentry-sdk==1.34.0 - - setproctitle==1.3.3 - - six==1.16.0 - - smmap==5.0.1 - - soundfile==0.12.1 - - soxr==0.3.7 - - tabulate==0.9.0 - - tb-nightly==2.12.0a20230126 - - tenacity==8.2.3 - - tensorboard==2.7.0 - - tensorboard-data-server==0.6.1 - - tensorboard-plugin-wit==1.8.1 - - texttable==1.7.0 - - thop==0.1.1-2209072238 - - threadpoolctl==3.2.0 - - tomli==2.0.1 - - torch==1.13.1+cu116 - - torchaudio==0.13.1+cu116 - - torchvision==0.14.1+cu116 - - tqdm==4.66.1 - - trimesh==3.9.20 - - typing-extensions==4.8.0 - - tzdata==2023.3 - - urllib3==2.0.7 - - wandb==0.15.12 - - werkzeug==3.0.1 - - yapf==0.40.2 - - zipp==3.17.0 diff --git a/environment_vits.yml b/environment_vits_windows.yml similarity index 100% rename from environment_vits.yml rename to environment_vits_windows.yml diff --git a/readme_img/train_img_linux.png b/readme_img/train_img_linux.png new file mode 100644 index 0000000000000000000000000000000000000000..f4ef113ea695cd326724d8c32138272ce243df1c GIT binary patch literal 149197 zcmeEvcT|(v+OMOdjs>wGARs8Bpdg4+rDPbTNfVVOO+cEINDl-O6-7D%Qlv#eL203P zf(}ij#E1|ekSGB{3o!%;AtbqP6z0r1=R52B?z;DnyY7;;)M1m^?01*v`8~hq_v|<7 zsl8O8>If4T#-53j`MTVjgotpbe|K zD2GO`y_v+nObR$B@B1<770(CNU0RZZJ7C&FyKW}>yG6YY5BU8-)p5_yN#XpMhdH~R z=**hOK#~|c(AJ!?avnj?vUi&M-gsX!<-?i<@Q=>Yis#m_AkI3C0*vGP*U$;h8}^=! zZ_1SUfJgc91=ZEsw%Hu?KWe7@k&(ZgN5)N}hIvSPSG4(?zn+U|E{4G%D>KZtAl&sf zoRZfFKXn(k+xZ6%cI>koY>ayMMSalN{-xDYNb_`cC1eeOuT&A+JMJQvbi(~M*>3M+ zWgoxma;*+a75;Is`NX(*&NeILLJ)KY8gz(vxg2qnUcuAsM(TtmDtM&nSL3{B>Nm z+cfO*FKgCqzhfe{^|_ax^&)^4CdScW7n8yMbb^ScGNLqN8m}khka#b=UU2SDK<>;Nu-^A#q{olQ6F48ZpBjw{8$9R9o1XS z>mT20b@y2(wyBiLN-k%ZML)cvEVNu1U?huNG||gljxgJ11>RpGZm)h+w;))gQ~S?+ z%Z%RX*n$BaC?&WPen>6q@qE+875O+=K`?YaGaH6Fm5U*_x4uu0XEK5ta4V~;3+iV_ z*a4wcY}nr9?#f2L8xn_xGq9^+!=E+RMazXL$2aF_4=_hI%VV+fC_AEe$G8}$DEFRw zix@G49HQf6+w`?$;bPYE1#kdqUR;M(AKxXRBj8%jQO-k6tRmfYsZYY*T+``i*VbjJ zttMlfvjRT6jg+I+XJWLoY;C4UGx(?v7Vwxegse79Q71-sj$*CXE5^xb8liOO<5%g^ zy-l>axv@5!Zk!2sa&D#ZDcmjl)Ss-k*g~9BtYFNzXYp}XK?`lelZcSXHJ!Od?~Yu6Ek%T-a(bafjpp?RLOnQr9_7{S4{`FeT8X#K=#jE`)7IWk=?;3~l@(@% zu`?sy96y*)8y5L}V!ni#eti3GZT-zEiQ~S`vemG6_dVj; z>yo7rBo$78cYj?;PVP_H6pCJ)EWhRBS-I1l*=eq-+#e~#ya;05y8{03|Z zIDr*}`Y0`euwVh3HKRqhaWM-5$yr7sjmEu*1OaM|Ra3K1=vMA-p(Fsd=LY}4`_+C+ zH8dQox6We((|OiuqS;<}V`0Li+|;?j+-3ZJc3eq9g7!JaAuMtN&t&gsxjufr6j>-dNcP zdA*?2n{as!T1C>SlUlec8raQiYhX2hO>^XnjdwpVD_JS+d)vppIQ#ku5v|s-*tc~} zw{DhKDZRl&C%a3=qx;6kefjb*&Nen#?bHXCi49n6%t+-S_bmR}a8f?YSizOtmF9v; zpb{3VnWy9%n%*a9m)lHgSUDd|a}8n^uZ^^XnW!#z`JpY?w!T3E?7~S0hc0Oju%mi` z9W^Au-BFeCjB%kRVB5>|b|b^Wy!L~IIjG3mI3n4Ic!)c7kObhM4dug$0e-Lai$%QP z{-&n_E@r!AjiLW+&KUkUV7gB?3>%@3uK_#jxOZLsNGz%o9Kf0A_yn6t)`;PG)C|lO zP;IQHJK0a4v7@z@_j)kb-QAgLX342IZS`2#=qZHt*q!$@$I}Z}bK((qu9EEzk{uod zqMIt&rLr#Xdvy+X;ev%ZkJg3iUL)^ox2vW2*pxuimVV5KL4P`%5eA+}(Z?jjbjRiY z8GKWSOevXFyET#k<~14e5JgyUfDLk}MOSTEh+6h;xw_N{Zr_H>G9r@CZakw2@Qmr7 z^3I$te;oa?&rOp`)!~oZFE6a+hZOZRjGg?QU- zJGj=?^l0-R0ksS50WANN@zOD^?B`)mF5^rn1ub#Np!U7Qz6XvGqcZrUL0f7EdGT{3 zpRmL+Y%|L4b53@;Ev23BNTm`FV4%i?-#J--TA{zbx3AU_<6Vn*= zp_u$^OVzQq9W{7%NqXD#xTmaDfH}TI%^>h>iVG&wU_rSytd`o>l+4EOJC3+aoExuS zaHZCKdf;)(Lv)_mi>rJ)u~?i@F;(;D$u3^6Jdt-!b#Cko(uWZF*Saf$L9+b#nU;i3 zQeJR1WavJ3UWK`%dW!>GmqW(-vqtE;qSv|3<sw4t3T3Lbv5oTxGna!20iU8Ndy+~jA;Li} z?ZSIfx1ZQP{{dC)nlG5dnJ;FqyC^=;J?@?jN)MT;UtE1dfgn~g%ZvG4@`%@C`4_*H zu085LxA3SVlZEn}U4|#P1d8!Cmd{XPAepu9P0h9&Mj{3<5}zqjw7p#gmVRFz2&{=r z#$|Zyy`Sx3b=#_;T209{@3?1%)J=tww!*J9%4R%hTa)k4u)8R~{k6`0%ZX~@@w9C0 zC8C^Ailb~j0o*aXql=|bGVV$dxdrcbKc$mb_gb>k)$UNiaBt;?v3GwqzC$=G3H^b`E|dw-eGj+`S%C$~ z^-kxc??vj+@!tqDx7!2H8WF?N{04^9K~-iw;M2}gdaPs=v2aA>*fhv-cl{Fv8i+p#Aq|Cve9{=i{#-JNBJz#xUQ%Mi7uAkMH zm604B4(?E%iKlPqBBig<{kr*CS6;`p0GNHwQBLN%s26K3#9MvT2;uJw<1~3;4^eBl zv(indvuhd~@rQD!<(}mF90JZ}1hEA784Si`dgnEqSnra!BSgjrhn^9WOjKBWrT2EQ z^>!y=Zq=uLy>#*Xfsa={I25GuJhDsovJeUyhYWNGci})HpM&0mR?2MYBh-)KfzHjD z=M!nK!OPUM3+djnN5)|*_)j0$-hu0B)$ohiI!P0A0@d!1sdteGT0U_)YYZ_5pDah7 zjmd*jY<)(R>E&yUD*2?+7mv#`I*m=s%8LaOaP|T|#h58qTYKSJR~K^|U&108TMj{7 z@UR8fh8^v+eb0*QHl?Blm}mkYYbyNLZB24iDm;tZ4r)LEc<K{Z zIuU;S4T99&Wm@l2u3&6ZDAAc9$@YQyGS03M-3?>fDCV4#aKNwhPA_#bP;+JgMDVd# zZw)k(MduD%HIY}MWuh}Jx}g>Z#5ptO*!(KU8;)NQ$M`7{UhE7MVS9=sCv(PfOl|lm zxY=Jy=vJY~0go%o^sfFctd0C1IzAebm4cpaACRL3O&yGoM}#y|JIAF(7uSNa+s`|x zcN%%O8Fb)>N2?w$shC;e?u{)b7yj7xxCB+?QxLQ@pDeiV<^hi})vnBtILJ_ah{XLF zCEe8_SFw^7kys0c=I}YTGF!tp>}V`~KbQ^w9?A^;asu#)vyDQ+_F_FTE!xAu(n*4y zDex=;9J!xYEiGGD`k4+VZxp|VS?m4^iK8U*5aC3^2`u(2WG8islg1szJ=;|@hbqRQ z!m$Zox3JKwNDd1gvjk6AweRN$aftB2qS}+aBgY2C+>`|c;y96#*3*Zf3h zP%UBA=Rh8>kKY^@V|V8U^~dS3=G}?YA|z5itfPi}k!@?=bBLEa#J69seFVT$&I4|s zyJgFlZ&GgG{{#4Ir4L@n`HroCZ{~Tn^KAU!EgpcMjZgC3S#He0dT?N?YIsUD3+*oNhMp^kpFFnLdFCNHQ z8$!oJha>E&(tiC&Ba#n?-edF2U#f^cD0uuk_!$BoOr)mjsJ-xkes+T3K#^!yi2QU-ZsMqkkA(h-hVX)< zoc|^`yp0j|&%?M~CQiJztJR)sYt@*ma$Ok0dRz%!uUd5CNWtv*z>O=wM!^ZUw^MyY z?2Ci67gDlA5lwBVbx{pnYV$R|(Y-;Vfz%p}%nsb~&L1Hw8h|VxD`@5t^6^F8`pquo zGj(FwE*IisF6-7SeDcVtiKXy|a1-aPAl%KnVnh48S zcH$h~RpPBM>)Kf6t$t(B(tZptHTBPRaf3QeS{vp= z<1SqvjXqA(fbHW-Scl3*SAk&Ahw79jlf0P9Ax@@g%!Gm2Q+YC-mNWmhfqM03i^g!; z8D|ADJf^!o9CXCC!>V9!?CN<$W3W#X`Om)s#QACF#N>Y)Af~y{l2@1NVRdb<*9F!j zjExa%0&6lMtqyx1HGy2Q0;Z0cA5f)2-sOmIWat~4LXK3UFZX$$GUVniM4x7Za!PLJd~#X#x95a=k_ znvPj(ygVq3@959FduA#ZjZBXnTCp|jc+|ou&U@OxB^Bq3D2}q&+d2?Dgyp z|C=(5q9X}|lCJ?}JT(!D! zf@tCtuFlbLrfML}#SQ8ksx7bd_L2R6;iXh$0fF;ELHYCC7a66ugj!&-DyQlB5|$3y z%;cTBs?^Ytj}>v($GkGcq6X=1=(xM4qc7Cw%@0(?$BlalXx@aAie+4+7Iw%bXZ8!C z$6HW4IwrUGN587pk2B9QRPzZ91f8!(^f-&rrI~B-g1o;#>!?Y%=u28<6T3rR6rQP~dgEYR*Hb*GYG5ptw4F;fct~p)YX)vE_yr3r_o(3aq zQM0o>fJseDKp7}q)NKE_Ua2-~A1sVd|PuWn zu3B0!FbL!yKmlS8xZ~$A z-Dj?Pn(ZOm1bR+dGkaBVD#L54AA}XLf?L&kE8bW5djxs*>0BC8Fs*XC8D-Y$1uhiI zY0L?9H0U?tGdGGcjoVuOKA&2)eK=S{ft_o5I!6rbezP5oSAEM)?Kh0o@i8@tM^vE* zCK6LF)SBwxZ}x74k;;!R1>X@1&+rW=6-9xRrTN9w8K;#jaE>Er6S!y3@aM zZpWCne`ENgpm0#Pr^3UgonsDi3zOoX6e{rNM*KQ&nQu7|x6u5xr62co)L!%KWp{tu zQ)SUF)^X0_ZXy*;G%v!1EZ8S>0o4E!TiY{U5{u9}3<9hAGaKh9 z)8ZMd^G<>#6yE%t^n_ZwKuWbZ1KWp0hAz(qYeBt}tF@{9gZo@zFd8LWTy!Du8Jtqp zGDQkK8c?wksF1eZ8%cIwYSEBiYdh5`$ysR1RB|5hT{)H?#0)!6n_neN(B0;+SU=)d z@3oi7G$zTbF(={Y>(^G8Ddox(n&(qip7Nwc%&uy(J`Gynfv({muF>3jl1`&0L=Gv-?mS857 zM12#Qb@|i#H1S{Tc(04Xk;Kl)FG#8aY_;rlDv%no9E|BCBV$ws-Ds7i$T-}E3(~UnV8+UvWfS^Y zb!jaQ6;G6%fVEA&h7e|1Bycp0rnPl-xYKo8KxPmXn3K^}L^I_LY+-6GL`%JA{LB4L zmL+HHrkitA1`LI zPF$Z@v|j4$Pv?&!l&}GgRu-LsnMt69VT*P%lE+I|ACog|aJqOfA8%&0>r&qJ9IP5cRWvA< zajc$mO?zGaVy86~fL3}ip0GKRMwem(T~}4mw#|y>fQT`05n-)o1TViFt;Ai3ju{WL z)_A_G8AGWKF?z$+48F+7kk)xGRZ65{`JA<&o_SQmLav>LK~6sz2>~<_brs- zK*?*zH=1N#04t|t@hN<}_$g0n_K4$}!eG~aCA4GecXa0Vp~^uyM#qBom`_!P>ZGwx59_qMP0c_Mv^`3-Qb4RJx;cZ=e(k3JR<373d^30obs zq5K$vCqU^2N_%x;b=s;pCv=w2*onvBp9{wUoR_5Ta)X%;H4hZ$7CL71?yZgxb4`;8|Q5!%i( zZx|ACt#1y5vdhNHOpUhG*GJjO-}`+e-cGeAO!0GAy?2ztT>G~`T<8&goLu*iD@MBJ zbYS{aLN}eq@tojO%F#aOHOj~ZocGGwD9w(kBo9h<(Z)TVoU7!LFg0aaifUNlS#7b$&W*LU>)+^W7KX{muQQ%>m|_qu-OP$%MoDdp#tNgx;No35 z{L~}`sY#;NhozqHn^scW5__&i#(h_ugA`;~bR)mbcZ_aMtzdD;(HER@d|s z-dw?NzXB_$$KM{iRr>)AozXw@JTwPU(&&-|{h#IjxR|qU7WuSy8PsZX%29*~| zlU9oI&E2ZTZ;wO~D=X{jMB3f_j|d33`ZT@1dMgW@Mo}hs$wujXN^qg7nziOqol|!h z6RQL@j|0)*2QP2jjU}h`+E8-)DG$;2+NZSTwb;rGz61m11w;0YFlocuoM${3#G zP0%q(=kc=V6Unm0JDW)6#jKjU+_Eq#ITv4~sH>WOatY2U>2L1`nTC#pe&V3qQC$?@ z%xB;8enSYY)nt{Mit4|^_QpsA74$a+dDgzlTFa#>q7V}DtYsR$JY#ru9mcNmXBG-h zra0T@z9*Y72@B)(Pdfk9KH4ADehxWvc-${}bJOJjyyTc(LZJk0hf+2aj`?kCrDM4E zb-kxbdUeKPqjylDZ4dO$}pp;h39iQQ^*&>xmPhy^`a#?*2!K>nex0 zNvf-(cuSzL{=74v_`U4;uQpX!L6Zh$_@`36Rb$^tLm#b%b}aAvF+C;#fyy?Bchn@` z>>c3v{}D=>8d0oQFUr6CdXZc&?oNm_58B`Qie?{rIq&tIy&dJnFz0?+qcZg>0Fhqp zlyCO<5t3}VcL{KWW9jR`j&>YUrqM5n#aU`!mk(bT$;v+3N%cV~WMYnB$)4Gr)`sWG zh7|A@DWC?acue~z_kBtlElhsi%9U8P02!H^eX;_^wdDqCapKIX!Ny|ID{*{>ADP9~Ogk`|CbKc+xa6gU#^J@ITEPc@_(gHhBV+=OXXwt;0V zJAOPm1gmK03D8PqC>?sqR-ocSe3rF?^S8UYSjvlEgVC&U~c>> zj38hFQqt|q!h+uIsylm6O6SyTWs}OlP&s<@NG@ITJR!#}5P43*sM3udk%+|SHl#nN zI(O;qLC2x>Z;Tm@Pprd0qPVe*6?)srHAnSEY;Wk9dtJ_EzZBXXzySntV(1X<$l3D%z$%`7q zxn=7Lx3+MLaw_9!d%{VaNx{Gx)MfilOyt6?8ZYU5qGE@%G9UDW z#_H4GgIqtxnLAm1y?n5wJ`8UkQQm~QeK5^JyJ%5~$5sB?;d7%QE}`+IMR?8m&fEvF z*|wVtXbCJ}HjoNh>;VYBLqS1cZ{J}4UU7GI1hNkitJbT6f&??(y6E^|<}bt5OLX|t z-{AaeQf8yk)Hj$&oq7o~txIgeY%nTIB*lZ@fVd<9@2nC7<)|nmcZ1D9K=P|;&8Mky zh7r~jhVlY|RxId!dL=6MtoMypMJrGrTafJ=O)Oog<}Hx&nN3f(5W&KzRyfTn1}TMQ z;v)YkvhfK-E0mu}2C49N&wmT~p6=Z8#c4y%wkGds&rR%|=*T9LC4H<+M&iFdKWr+o zY9BVeTa$0o*jV3wxFfI#<myWGP5g%L1tb^>QLfzt@vtM&~< zY+=(mXFqW?#^FXBkM#tO6>=)zrPVruGYRU1H#S7FIj^zr`s(mMAl{JZb>p{1U4KiX z*gs5U{`lFwg!fN3q10Qv{2!Zuu`DQd6Vq+^7v%J})QM($G*0h75?4v;_H zx+`kM3Vovxga3BQ+k4g-H~`7@M47&w;dL___4K1x@@#9MbvjVqv0`L9!<~d)007cr z_19mHMphFmt9Yp!7?r7|we9iQe*mMxM~mc$aBqdAwcz9Kmp$$tD)Q^xNNm9FIX=)x zt{PweNL!ohAf4Up;sU^xy8Xy}4NShYtJDKz7wv)dK9U)ooj#$XvBrrieTpbe(OtLj z6N_g!4<&ByMA(AVIGW~xi`$;Gj>v!)j6|TF?E9nS5~NjF7po66vzLt9nZPx zq?DYTr+KomNQ;6PSDc2ijLA3&dFN@wgj>KA)X|rD8N9 z+MoKJewVxMl?JZA)!KzcAYv`D$u!kI!m1qb;yNI2N*Z<2R$A`tPRMKW zVlbl*2(D#M`>##v?cI~Wp&(2@XQ~JE?9n#uc+Py@!bsK$y2|e(QwxI%jpeos5MM59 zgf!Qa;yUv}i-i$;N{)bkOz*cGAlmuenfl7G%7lov$q7rDX%Ln@|0ZcJF*Mrj6>sI% zs6TVJMq6CS?x^dJb)l)mC(OMXep4_6QJK}!Xn*(Mz%Tp>-ig{sDN(8DEsN-M0$kpp z?Zatxp%Rs6f#a+5GP1I|@h+QA59z-VJrNp2D>H-5x*(a)h4_ET!j!J+s{myHAT7MlNqn-)&t;p^YS zcb!LF@YSs_{o<@_NB;x8EvXzno)Xe;nw@3tp|S70j-%W zwghMf*;J^=?b)7>;mD_bL8C4w79mzzQV>4U1detyhuOsn2B>Dsrn0u_i}23bHv$XM zvKQ&`3<;0`p>TKnVTyf=M&;HN0=#HzL^``G!Jn<_r!AA`&$(os!G-p_KoF$;OQ+{dYU>VlCE)|dgnX=Ht_sMuEm^E*%^8Q>ILdgb zSl2=^VEO#|JU7-aPjsI5e`)j;LyvdJMRN>n#w0bUS+??*nci-{K zgUXot(|q_$N4{t+f9p8CROf-@ygE1$uF-s{lvFv~iJYLL+tPiL&V$K7D% zu|W2UA#FA<+P77%G`U?#^cr$RY=phQ?k?;?_(ner=*j=h(m##uS#>`p2uHXOSKF5f zI_U*3(KQ#;Ef|g^=H7Fv@h{AM^ytIPQD49%x&Y^2G{eUR^m;x0DB8!>yM;HclBvC4 z?plIqxu;MJj@D@6cfoT%qKFLNT-s6~u>YMEe?B2QH2P%nuF(u2+j25Z*k07o`bmd- zO0_+4fsHoZ_iI@P-*)#@?bO3gB296_k=uzyF@i=5bPw~lx0A$P*%$ej4)++V$`k@)qlrIRjmFnW}BcdJ8adF;3`w2Mk^-t%7%b%xT z6mRtUBcrxNfY7~9F35V_G(!iDx&JI~;^TD3w-t!_Cxw_mupnc$q;MqVavrsg6|`MC z7&;Xn3_zi)*`p}uK6hj0Ity0Xu)Q9D+_mX}Os%~)|T z3{_3jZ8`=#lV^~YHaovVkM-CIU|`+1fGpR8+;D+RF!mC|gYY5oWV9^r!pNtyl6WcO zyEZ5-v$tzh#*p9mrqL4ywgp#wvN!}Fj{bhN@2SBkpA@H3!%hrXw6i@~l^Aj-T2aS0 z-3Ar|V;}DiC1e)_H3=83h1i1ZTbHot$w#7jF^dDV-y9fN`9uWt(;s(I+s(OFJm z#q^ke-huw6Mpy9pig$pVbanmernl=p^5TB0Ibl0tbp-!Sc6E7!1)ylwXXy+|M<4M8 zD;Tvl(qdQFRW|>ZBH$#yH5y;EZppIyN|QY!^hqW@H(lqeIG!@iaj)Xa+%H6WTlMaj zM=4?71$qi1#5SGSEsgxFd%Q>~H^Ix&r$tSiMj8A9C-OG&1K8kiLVZKkjYIdZP~yi) z2gDfwH`BDoJ!3GT2Asy6avG9|_`B=#kr3k;p;eVM?#+P3&Q;GHX%C?8_&3bJz9BAG!^I4yp?!xo zMt=1waAK~Qn22|A;*nTAfdaq^@m+{j^9f`W*wv#-W9Dp%srimDjIO z5hw@lG#VZ4No}%imJwBw_TnwV(y;tpAp^|EylPL)!?FQ65DUUd3B?V&KBY+4h_&51 zXW2v@?USPdMCx zf`7epfNy8L_KB@MI!7QXUVoUXpPNn%YfiqLXEx9A@#XZH;%gj765L~%8)%`c0KGit z$K^a2TJYI)f#}>=ExHz*CK@@1GQwfwZ zbS{6IzuYq4+G@%>dwL&#>~H6UoxiZFc3CY&kKfPz?HDJP!4jyve0fo&9$xfc38w%2 zBUvAizVH|rJ5K(-9jNUP@Qa$rXEm-Us1XaLZVi0q$*gky7p7!Vt2b!b8P$)DL5G(HDNO(*jxq~NfYn%!+=0AvFb$wx*}9bH%ylOlF+O3YoyNTp!nxUd*oS%L8OLcQ8QglfM}yY2iUGk z#@{URbVuc?EIl!if&k0$==x1QB{%fayQ_Pob-xS|SAYF}+U{L?@%$HjwoHg}_;ig> zqD*(8q^=LAgA)?+*oNq#20t6Of-O{W2o11`zkH6y=ofmkrptt*?kq*t{}Hp(g&b^o z_uFjEkn4}5`#Ui1JBtNb;$N4Ih$XZs69DJVB_8g;xGMqN*Q)o-4edR9Qu@^^YECEOpiJ5>Yg(}&$IRXKX9Pgc~hLSrU z9#R8PE2#ep1mwD(bYa=5YP19S$_9u>q(;xXJw(6W&7D98cEU~%rE70P zuJgRaEG*|*$l4d(_VGPPsth1AqZp5Y)B(UWJf_JNm$|jwOViI)tc%Lb)b2j#QooM- z75*uDfxHqfSS2KX6q)Xud#*mVX!umWeRq5f|@AZz;P^3*S)1(X>Ae%ff(}{AR^h7Z~XjKFu z6zBHT;M!q@2~J7QKUAlSL59q7x3>?10SW;lX5w`5s4i(dE(w#|t>O_V4(`Zq(qK*b z*w|pv*mJC9KgRTyzoP*s0b8;E00yKqNhM;N2s?-Mmo(U9lR?Oqz!I8`2hXn!Dcbpa7yF+NJgllOW>?vAhn0%B;HuuNO}n{?ncFZM-#?%;X;_zwO^ultr&iard>kMArB$w zn?61r7}(#-;M((vF#n8R6-~|3G#CGl{>5sY+S=jI#zOjM9#NbdQaB zklc}`Sa4@3!i*do5kRCJ*u*Q_0qat{v?LL&FVTU`d=(>RFy2pE`+6|%d}~%)*Ua@J zQycQaS|gnTZe1fjo@dOkOS>~Y6aew-OKQaR9WOC#%}DQ}#M(SNvk$m|>5f|vcy!!< zW)wJp$0bRDt=TBYUn5|W7qeli2QO8;&Yhs6S5w563gUxbNPQ6W7h6(>f12L+K|FqP z5NwiXy;K{LRfW<;D$|=V(T@w5+SK}g3eLBsw5OfNXvTqP7xX=!%V;7Mvbfna>MukzzL3#NRN=0FL5Aar;J>H^fB+dqC>@WnGgZIJ_saxAzJ=qM z8mT8LNe3(5^Z{yksKZt^Ht~)M4Y4sXl`1Gph3Iz@Krv;+Ny&2G=MR9YFKaXBcU5p~ zj*F|!;qAp44GzgGu{81`YpSvLBt~xyBcoZ6Q48purqoz}uG;)l%;k{Dj&n`n88vtS zk72yqX>Ks?X676A7rQV>m`MeqfpHmGo#gZ$Wry>HyMOiN)jcN2nzrcT3^GQid91S1 zI^Bd=Vt%{W^9EMGT@$Gt|7WbQCq^Ju(3V88)L8!07NbqV%OfU8^he*zjH`ajg&Teh6s&J!x*&fi?`7%_D!Z@WlrQ^NmU{NQlH87MEzkbNQR zGNis;^WQiIBC+w+^}}anZWvRZ7#NQ$sKq50&Ymb0`yASnZzC8qwZgos+GzhPReX8+ zKzDw5dbQ+mLH&`OLx?^9kz-IlXVLQ!0Dv9sdl7jezuk&Ez5A0)jEr=L3PiZ_z@82Z z0RRwECOsP>+kq6bz36AR0M|TA8Ybm^IrYlVR>SNJ#0w zG~bp_Wqe%QG%=JEZq;J;gq{51ciE1+BY^xcckB1bB7C}`AvaF00tzkuKVEWmxnt9T zJE_eqrIS3suaACnq5^m7WiT#;+FV`u{Dt7&uh`M|Tl=Rumgi1(dP+RjQI2SyxBIG- z;euJs<=oE9HqzFA2E&$>iCc3r?tBT{9U*=k ze-sD~d-EpW{2B^mp--iE@{;T=9War<$R%I)_*O?AI3H^z%TaoVsLF*lvX1R2(J}0l z&d-tpqW?QJT}u`+rP~DCwOwssI-da3Q+hNUsI%M?z0b}QWy?E>43pMPm1+nLg6$le zE$&=BlXJaw@fyHFi=(49qYE&XKh^=|zIOujNNPFw<8l4T5X`Ei04hfd; zm{^p_&`xY`*0ea`%jFaxfuW`ULlnVz)^8^Av~fmtt+!J7$nY22VB=8O>rIC~84Fa$ z6;U35L%k@TPb21=4(rDfXU8Pd`rn5DrLqfg`RJaJQ4~ zME6)V!nosY{|$EFi`VH**~^xd_|xCzt-z1CT9r*&;a?>z*#`YpuuYgT2l(cAXKsat z5m4W;K~TKy2UHzS8|ecb-0z!;kz#$VZEDK(P0>CQn2XAPiEy}mNDFd3uhY{_2@O}n zV;lICr+Bsw&UP&3?HFWu(*M1sEXYL5%xVZ+4OjNGzlc#^3M% z>w`enW23Ks#Yad_A^54~OB+A6`~&E5!Y}m7A_xfl8gFjS1y|}5@KV?G^M$r06T!_X zx>o?89J7}NlFnMKt06Z^HafX?7#QyEPbwPvz^wwSFLE|Ixu*z7aOj`QXLqI&BNhSo6Xo3HiLu!Du*^lw({V>--Sk-&Hu7^ ze{Y5y=5j(1uXq+TZL>fJkWKzbv%OXNt`quB4V8mt23wO|$miX|{QUeHfh_m?oF3sH zWjUEA8-W`UT)p~m*2t2c7Nyt~S>G>K$PrFiHhhHklFaOEwv4d$nx9u``XVTyFR|QO zJGGI?yJZdR66?QRx={Y2SRmY6TBwWlG$2VKSFJ8;pnCVlE?UUHb?ZdjsxPtxLF`A} z{>nSDaghSfV(7x|vw!9C5`pPDqXyPKNUUqf`s@LT->iyh3;3%lhF4d!4*bu8onXJ@ zy!sx<%1NQ+wJ@c6^+t__-dvT3um0*c8R)kFWv$kMg@)7yh6wtx5@g5c$It5|GbE@I z_N=po>mdhe0b3K|xB|0aqNz}Rzq^EFLG5+W|6I27rodPahmn3Vdbtu9b|cN>>b+-+NTOC3G+p}*`MQtYoP2sr zziJ0p;-M{8y|Afam;+8;Unu*=OXUJ8J!pAdUzb~EhmlHt{YXM+ter+L_+Ct+=Uv-7 zX(BZC?oiZNo*SH!dj04R+DTs27L10ScSa05)BTs9Az3B|j$ukYPw292&kE5CNT z1{7b>Qm+4@P9RC~QURmT3(cx^^?vwJ`_l@xf>*n-R#Us3f}ncb6aY@9Pm&=Ki*A2c zKEr4pL&0*uB5~#@GB$wsW9s4d!{Op~3jxQ#*OhlzpGjY()uxx`JP z9KbZYF0JriLeIMv3>AVb0gS@g9E^J@);sQ37@|DII1Ba?aZ0 zYARNrhgRtv48F#9XaWw<8F$V-?m`rTAI%J2=uegkwC78B8bmXJx1+Vofk(704_iET zpL4NdI;H(^zxu<4k?U;;;57( zL%@T^67QH&|J+*nkWFa`Xn?FqMw?`stPzxZl^M3)7cQJ$^YJ-iE%uOOcaUS>=+dy?$o9Gb=(sx{&BQ-lIR#F+Pb@!PSGx-nF-KeLJPPGTu z$C3UJ-6IfSNI2Zuly4D4^h36jpr z?J$NwLd9;<*YkDFUY;F6$vlTRSFT8uSjqI99lK)~hh5%HWyJm^7y|U6tTd7K(2?ql zBF@ai)xO?pKp1Fl6m@kH=coM%b)aP7ScCzo1rh<|?``BS`SoH>t#nEi3WfW~6xk0i ztuGjP7WB~Kt`+| z{rvxipl1mGaHn7UUKUXAZPW8j^~3#bgXz8}xHSz+X1e<=Z;#O$?_?y-cN0&GrXK#i zXN7gGazz2<`6|{~xkePx*s^hiRw01RKT#RX6fP$>EliM*v)KW+- zSgl|Vl)u?QZiF7a1*rJ6@80?_t(y+N&Ue8O;D$SfCoim}ikkJ`Fys`=Jp2d0#uPTv zE(5ePwiZ#0?YJO;tb4evk&d??gwPZ`I_bWIqO&2C6EyOSGky1^&79iV!kAq`_NlQ| z-$qxnE)R@J823@=#PYGfG%{R~(=*%zrKVsjkOZq`%ap4}0;Q?GM|vu-#3G1sA4fY$ zr>Y@b@UvHa{gKPH#!pO`pj2aIS^Sa`HS6*TPOKH2lvZ$XVrE9)>fKsgfK&Kj(6gVpsp{?vyiZfv0^i3b6qK-^af%M%42=Y|A1?NVUKjY zN6Tulm)OWU?E_mf&P}0ka^f|Ne3EK4U(5NTE>qdMDTPg#*_0WVg;~jYH^d1B#n&R* zoHc$ha*1EywDH||#h;R%pOT)RlAfQEo=x4yPf5>DNzYG7&reCuPf5>DNzYG7&reCu zPf5>DNzYG7&reCuMp4jDNzaz60D=2c((_Z&^Hb9EQ_|D$Q_}NO((_Z&^Hb6TBuoEA z6>|Tlr04$+NlzsAs+|pq5VsmD6k?UdyThlydzQ4(`fY{V`tQ=L`CZ$2+JG|cj>OAz zqf(oCsrjATc_x5cmist@e_f-b0o+;i>2Qf8a=QnP=WxpUXWu^CoXNidgfcle|+7{x3>yx!`a81!`IvSFB0D(dH})@G0!yC~|-0yD2PN34aigAp38stRVr;8X(GI+k!SfIJ8IS zZ}Pg0Ym|YPmr(w8k#hV$H9vm}T%A0<-x;HCgpKyQ`PVhd=b_j3MAgSwqhuemotabGy~Q)0Q9y&tkp%@@QNP9OZ9)I`VcYJrezQ+{XU=uE z4-inL<8@CmAiqrdDZflgTWu!$nGjkjBQ8_!ap4}}NFqKbtbawmd3#X8E4WDwJ6ck^ zh1uMF(!H^-KV{ifb>0RJTaM1n=a7x|K$mVEs4O!c9fv#WrbaXYb&8GkMOE@+nDsTw z`e`SBxs%}=ewN#N0)a7IYJjW<(i+u~5IS1wXQvP4oh;{Fw;|U@3#yAOpr8SHC;~YF zsw`j-7 z2xkuDZ>i$%_xyNvAgW9}P;~$;son6R5aoy}V#Y77eJUQ%E<-Rj3IWx;>vyvH!?E7X zZ7<$B0EHlghB2Q8fX6GfBN#A`qP)kQT0}1Q1o5#b0o2$u3Smx&=1?Py>*E%V5a2s-S*TFmj6K%0!dMX z9jIZY;>imOyM^1y0;3dQVHzVNz9D!n$G(+^2bA84=1qRAcg<^K!5P_K&JWU8L1(Wl zAAiM#lvb!#!f<6K`Vy=cJY}8-d0A-&kgx6Z8{Y4|uVHXK6bxcK+E#y+PT#PXJbUZw zYWF<0+SxCsR%es5caMFw`m9i}Y+TU9h9c?#L+$%;2`RX2S)TmZ^14v|pCZlGVM{JP zf0aG9%kPz$0+o9d!U6GN-aaWoXKG{@48#Zs-L>vQ@T1VEi)IA`lJpzEdkd-$U7c#k zN@$<0Uf`!VSJj?^4Q><_S$a*;nH0~jcQ`wq+ZXsYYV~)anFKtbV&>;i4Gj{2TMtaQ zX{-gio%vJ7x=8vM4adY5Brh>UFi4AiV)7FppWaj{a-_t5amK||-UUA6$hTlm@ltt; z+on9&cl7~56yF_Pc8}W`-HuCw`nT-sa#aeSyjif^wB1;1W78Je0+n2y2u;&QXK;&f<4`i|M_@v|6>qvpt2Ewy&oWj_a4(u#hHF2b)h< zkMLdgK{%rUy{#=kZ!09&<(d|ZGH$%%>!a=GX~*0TLO>A7r=m)JU|iEbIVAy_6Mnfh znOUUW?H@1e=dmNrJB|ACfIPoW;aNHsQ!r+9|M}}05u2P8IT!<}hO$zo(^bQBK7KjQ z5PJVQ%a?~s5jYkus-$v?!F{f0N}F#YB}Z;_pd~=@XuxYp9xth&&oAW><&Jn zgX06WW0Zi{J9;l7nrg(EO+X6!+RUYg+RQ5p_{0NipK8F`XF^sj?7-TGpWW7(ur{la z53J|f_Ch%aMQEjAJ+P)brMpIUx6~nBFQ5n?KL$WKK~JY=TtANspX&6U)AcmGn|kZC zk??Wcy-Vos=C87(9qg{ZSRn(QY|+yCtDhAN-V|Uw*Np@y;b7D077@?U9|X8^6=wRvysZ}PI|?S@w@X`F`x zHMWR9o^1ZQ^6MTj==}1xsmw^3Zj9?HHRCNp^)9v)B~I{c_vZmBB5xNvGPyr+@8*)G zNQwc)6npPYxR&3KZ;qNPOUco1z8^}XJ)E9EBSlzfE`zoY1f7Kr1f4e;{V{`K$i*6U z?+c2Q%8sU9sRDg2A(Z~Qmo|Yz(Mj1M4cE41K^3lJNZ@Gtc6$#L9-c zWHH&Wuttdl90%F}lDz}iM;RS7!l}3aVGFdoGy$d12hW0K5#}3%g$u`4t2Krgn$=BY z6MW=mr#PGO^o=KY%hlCIfm7q=x&4bUzsFl|G{UsVX5NxC?KyKRx8AO8 z6CTZvU=eNW9YPHpNf+q6`Y$IYOo1R{xI1-D`?r2WvVaj%DKWu*kYR=HCo|4b4i2=d za_r%pb{-b@={n>VC30Z&;CE-tI%Y*0qT4#J^h#E-ZC4M&mNE$7OY-tp#}pdOMV$Bk z4q3YhE$F=~nnQE~vd!w$0_qow5|O*QPWnFOXwhKTh`^5*@*ktnm{)GI27R_WzPb`y%i0cS_L>4&fsRke>31a6 zr7@P-#Q1k1zY{$Wn#8>KuyFc?odQAp&OLFW5+KQ;Z`%4w#Z-T@>-{nPL2)rKRn&y0 z_&eDBvUx;d``niw#6tH5&plGnXC5piZwl^Y4o1EWvVWg6v$}&E12hMcvSyt6r+@+6 zu1=o!XULt51dx#9R=WD70utQmG0WriQYCScJti#6p{!=c8!Ye^oxNgiVJT6U1JCo%=ekwlbs3kpFPd%(;uoAjI(s@&)XBz&C=Pv6)cedlLg?n9>2v zJ4vLXq1RWM|6yvz#da2?D#=w@N^CMOI0Q}6i6TQNT>;<<7_|Npd;7Zw=F`5gE0YrB z`ZIvTl8MzXb?nK>!@?Z=>ymxd@EdEa!X#x%o|g_SuFgKbQjhKnXe|#ut~CZIm|h7! z+Ex)1@UV91HIfA1M?XXEUAyD5L6ZTK`3Cra;eGERsLLK!jq0B^sl z2HIBH*OC;<0Z3=P0;CG&;+=js9&9eWXuFv8&dR91EPbbbmwIpC)3629lV!wu_r__Q zXBNXl1KJx3HXBk-bRDw3StN*yH$Hv;;8Q{fjsw%7{e%BB9ir@?DiwA6`}1;k>zN7J zLFxtb8A9}KFJK*GJe*AmDw_@qax<-WS*>l^eF=0L@*bK$O^DRg*SZVPQ@Cb1?7<<5 z-U2m{58}F=!xNgCK;$FT0Ml^r!Dq!kl$AG=mk|eBfj@qV|54<{`t%P{pwy4Q%CDa8Xx?f}{Xl#Rwz}JxwQHJxxZO+bR^u0yKML0B-2S-8|18O) z?fws9MDwbx)Wu}9P9!Ck96B|)?^V42@~)&8V-4Qo3-$#R$4(sieY%st?q`0jN@v&O z|G6{OcQ&1#Cujb9#TwnsTaB0RX{G1c?Be>}4_fhualzys^ap5=&fwfK)$M>6DXzY7M4R&g(!?n%R^<@L${Cj2AG^pfcoN_l$7+ zR-;1vg=@gd=&4l-UPm1Iwdy=$dhMM(OLry%^o%x81qRQJx!CMcoT&Y`x%I>*?lqe3 z=a+v(JP(wQ0kjfdokU}J`_Mod$9bdfb9QI;zICpyl6=S{Ksh~H{~Wn)SLS!Ob|Hpa z$A!M%YkYkC4%QVYPx}B8N}3u!onD#N?~q)0YzTCCRvZ9B28ciFykk#pnVK5h%-{i` z4YYfE7L|l+)m~>A$v+1CRzOMZ#i+Yy+uH2%R6k`M3KxCRc=uyr9T3re+?Gra&DIy* z$pFd%Eu3q)nDcLq3tW9^Nbnadna3VPLn^9WK6JRB_rj!SgGHN4VMbaZWCFx))s82*5Y-u6Du(vye?2or8Y-=L11 z)p3*vxphuCw}Qj$PU*-SO&}$LBiqI~B3yXa(Tf!qEhBeGCWt&4Lk01sngxeXykVf9 zH{&yPYRV&UhO(Oun;iE6>t)GI(kx}wNMY7a;pl&C|N4uBl2nyw?Aym;qZ&6F_xlFf zl>wqHTWotYc;uf8ZCTW4K1cV4Ume3c_<5k$B_~+u(r)1>O1b^Y$-wOra66f#KJ zjFt){_=e=v>^T3g6$oz`?y*|U;dDjJb=4x9X||N#8_`$-pTlaz6I^V1;hg9 zaGP|QBy_H!yA(*n%wyD1aL#ET zKB0|TiP8%lhj+-k=^q+GK?4SXEw7(8qhLC^Lq1(?ap8_7yCS8)zx%8Oa8;9BLI|9N zT@mVQwg;da(qb~um*2|tW9MG;qdzdvKtI25bSDy>$dubldziZ5gj~}Bkxe<(U zA-DdX@i^GkQdeJ$%f&S(?eN#k0h+3UNM`9LYPq^Hs~*l{e7B+(bL^P4Ap&*k3e5}l zhr|94b>R1e{+QqR9P;PY{s-SbTw_O!9iTfLJZ-dlip2l>F#bIj_$4)8`n&Rq>Xes% z{l^KY0I~}VVsC-IdN}BR9|88h%bdll(gXzA0nuNN_~#HH%?aERYxfNVgES-$FU}+- z<~fR+7?P zyB~r9heTS7VPK9b$R@c#%fC_{Fcs_1bUK@S@clxqTa65s_3;-^ccZWOpE}6hN*UYU z{Z=da1fRa{YZQlYz1b(=TW`KKIx@f7?dyRUQ=6)FsmuSv4RX^0aWAgC`{>fAE($h{6im6!V*x4Aa+_~H{|9eU!YJW;2{nwO+)xT33pG^R^_raf2 z8Zp0|NYGAhF9CJOeTlTY1@oHwUU^OUFSB$di!?R8wqj{6uDXR|X`yJR#O+Qtg0IF^ zyF2`#?QmB~fOMJA7h6lrp3xOgll8`M5tK2)5C}cvzMitnQv{VPUcu)L6ff@^HshDU zSH-kewL0VEClOky_*2*QX(K=iy!zJ@a{h-ppl!p>)$7}s^DIyDwf;Ndq_FgUxiIvV zM>+ys`(vbidc6TxSqQasahxb{H$u5U$r%k_skT>3OIvjgDryy$Y85d8Bd&OY^dhms zti(P)Ls?BIAHY{!5v$)`e~p#ViifVRNi2M_rSw--5Y2-I%POUnYi^tkwaZYDe!#e< zY}@MhTJo3hJr$K^I4w=<^>i9;|9q*@ABN6q7)jwdab1cuD!Z|amHWL5gs;QVq}86g z&G^}IQcd)o!#6yU0<}+^;wIGRcq<@lTUKG zb=K~Ds!ZmxgLuwv&$_rf;pKxWmN^pcs^QwO-Tok%c&`9xeY|(=&@b6Ms;8T&ij8N- zwRUE*DS?Fq4x|mL){C@KLppUrHTgB++#)oRPUVc2l{~!K9AQ)st_t+81AEr{K#BGk zO<^?eR@gX9rp#+YmLVjiI0$biJt{PI7H(xKWUaGwk~ne4ssk*U!)5hJvL04~40OKN z3*u+-fOL0kGtaK^R-;0Nrwx7k*XO%PIjy(T?CYBCKl1J+ITaz@@{Cv5s__rWKG#q& zQ|AIA%qhqECrt+Fc)IxqK%OXrma{lLfN9N=k7tk8(nI23g?8p7-M6ZLjk#SKZ7q?n z(_RtDebQJcxdIbqp^M-s&oY*?L^}0R752-2fGDI_PV{64K)D@f1RwdqE>GsPnlS#p zMFl6=n8SWdD}j>2XIm?0akn^d#>5d10vq=D=11-Hf&8}$7&|!U2^$NhaGP_1@1({A zvum)o3&j&n7Qh^^E1Rn=J6EOxn)+8|capc)Fk$R7Q`1uB7CJ(_b5)3EKJl`~Tvo9i z1?}sW=94{cvJb4p?k`Cedf?S7Sk4=4%;gHb$=BYyO0keT=D7tpZi!lmN1G#r>w|Sv z^7S;a-(->mtN*Cqw}(^nmurruQE=4eW2@2{;OGV~-e@whxu7QyUrN#^>k?xj8^ zrR&u+ytTmO26Cg)HT}phmwlZ@U;-=STO?&J?T?bU+fX4&8)ssQ|7d|$*aK|9K#UCb zz7`JC!84h+F5DDvR+lLKlTra@0Y`gMQzgKWu^7%zqqOTjNq0(%xB7A4TOSec`>zi) zPu^ThFCNGFiX;eGRVTDR8IGzQe-QwFUWL69`6R(;0Rf8fj)mD=q9(BCHQXByTOa?{ zkU2iMBh_4-?Wz?9HLVUEyDuOUSjCA?IQ>d*uDT6koTRDZZ#uRrRo#NeY1Bc)g-p{;-BUIpjo z%ybK35dz&-Q3ZksCO=tGRvnOT4(yy>VWHA;u2S`e3LUjU39fWDnXTt}|*KGeRFi(*io6b6p@sv^&LOx7s>z-^hcmd|EE2zBPOb zQS^}(Q@xQW{&1VC(JJ%o!}9mjYJJ`&15)75clD*KxndZlL~K>zhU?ekL2uocmp{r$ z+DREEO?PDa>yD^vjI6v3)L`MS3y%~Q@8>%YjZPztJq}L8oK2lLV zkzee&5BG}~V>aZA>%EkSO>qwVrFI77!pp;;c!Qv4!5*RL8EQnNf z@M=|!Nxa7rPyvrGdY@F7wv|;%y^?(vGPtDO0%Zz%$CZ)Ao$e7-I6tT0JFqq`*5fRm z=Fv}RE8Hns>O2#6N=B4Vd615QCIYy%Iw*sn3{Bwr}&jQ858?0tPH zvZmp+d@gsRS7$Seb9u+vq`21}>bj(Pkxo$T$JiwJP~(s4CaO1e`ejeWSKB)`huC8-BPSr#U7Q!VYKDUQK0iNm$yFJHCvPrZ&72&z}N&=Y3QkC*U_c7>i0 z2_=v+m02q16KB2TU)6C=Dq@XyYzjFl!X}#c?8R5P)rRu?s-$vk>%EVM-(B*(DZcxx zv#XPR+S^d7k5Yo!+?lq-_WV6YICUt%MYSj+BQ{XJm&7z-7TVu8-ZT}!b@fE69oq4W z{`GTJADWp_G%Eeza(~C2LM!oT?}}Ai$$1(<$hj{#9(v z>r+Tzy;>)Ps}yTEhL+5Lrtc(X0MHC;xz?3H6eerW_ho z#rC=SUGVu+^g=I+Aij$^eO3%%CJTEnnvRI)3b;%YW(dv}oD%&bXB=6AN3S7uMdT}u zJkwI=c*>w1kGV>3(iewUrsKn{?TKkdSAoVYZP*fE-Z7JWliXeXnb^{yE&vx13qi}i zK;i@MWW?^JN}H)^rA8-xL31zh^_>CTn^8U%A-8IjIV(2jRky6YChb~Xew=BF(Gc(pp8ZuOn46qB)d~SfFNBmXCV6zy9Tt#xGsO>-*!3)#I_=5(_E=? zw~K)@r+Gvq`$dqv<{S6@v;G>?7rAYc)q<614TrV*UpXR77WAu5UPG6?EacuyVdP`} z%NXT44F4!U6xHS*MXtn~@?0ZHwmH8U)J>X699(;W=PAsf>GKfePWt$TDO*IBLIXa9 zs?(|xIr;aAnbphEh28aXnd?@7whUSU{t+}PFxt>4H0juvKF)<{g!GAAr;$i~TRGq2 zg`)8b^NvMYR+b!J5?CPXD9|WZR}j~XHIh5U#Ugx!ZndK5x_~ybL+8qHj`*gj;@2~l z+1Tjf%d&lWV+$11MmCc$<|b`oM#(&D5z$Q#D;nP-%fS}EQ zFw>rU_p-EMJX$c*S+Q_uf}^7|Z!ZhNzn99locy_yR0>kFr0r4#{wPi*~ zB;<~KPJr#L)hz+5Y!J%!S)9ePZ&%%UQJhK!ll0bUrafQJzKdIy{Ie?wGydg<$sd=S z5fh|rJO=aHyT|28Fotxq&S(n!x>6MzQ#A35|Dbx3mrUB~*Fs2Al-L3;LC$M^#hNWC z!a&|3S-z8%NTX^_qfY88HDA(WKhgBWoWu@63*IugG2KBc$tJs_%I6pv(OkGURz#Dj z@Tvx(79j0z5dMWFKeydbY%K1~R$PDNFaa35f|i%I6@8|s{dekLc|reWVcwhi7u65i9^mh< z*Z2BV#Y5(Lf74PRsnJvw^oyyHgbv6-`m%l$txft9VJDQ~sO2h>mWI z$4tUsW~s|#&9@mYV8(=&A3$$Uc>aSO;uVmNhx?gsrwbi54n)7UAp6*j ze$rZA?jvP4F1MJxBB+fC$xgmLSepi1lkML?=$Q+f1@yYCktJdfv!smE>ua;lhTPO@ zK1p}4Ouk5{4DE^TeJm99ENjeOV&D`+1l}5A2l~PNL91y~4!Z{F@}nsULta~IdtdLv zJMS%W-wM(1iKZ4wKHb!j$Op}li|s^Cd<$^GH{(YJD%tu~p{{QW#>1C;aKUR&N^PZA zn@rq*!7lQ5s#o)ZmPUDlgL>v3pKyP)&jQIr1FRdy#*|Quddkshl`Ow3{_vRTwkSWiUl?+Y$@+Bze+q<3mg>kP6XQ#X4aO^DU)URCcJ-ms{W;b(F;7KP8lXzNV0y)k^sw z#&oxoH`e+jtUN&#!b%AF{1&xS^l&uq$!p|mo z@exO{0|Rcc7~F?J!d-{2t*v1@qGPw&5RSb8l16CQy9t5$uizG~MYd{+`{Idu&02+k zp5aDf*|-xNpKYu#vKjqeXOHPWK_~iu0G*m?_WmvZH_%yR*xIit)r`~J+Z3B`AIc~+ z2alM6ne>(aPqD=6$)~p07(?TSu3DM2ojWE7*BZmM-N=~=AJq|L zFIkYVdx~0O@03jL9dowTMKqj~0D|6rmNAIVKlOVAfWHNL%kGnOj!NYXw8_R^O1Q5R zX+?$@=KaE_@1FLuzEUzytQ{B=ir==1o@l(6kk6p)Rdz3|Ub;%APKIo0-WP#21LTzM zU^C5gprsu0i(}#5HP8ie|K#!0UR#%v6e`f-5_7H()(9*gDo5bquCkHM{waMBbIhjr zh_kwB8@#ZFt3qihix`fjAMQm7+auo&>iUuzwytS%7i%JX*s|_6ch95}^NgCatbEI$ zp}S*%V$zEbIzGNYC;Yocw2_N;?VdF$Y1Y~U6&mj=xJNve{@5A7!`;%-gUh*w8JLdj z#3WCy|B6Ff&*D}u^YZOu^>p1jj`9pmxd9#0UdbCt43P0!GeT?*-GQj8+}&-nyWo~Q zd-rlGa{ZEcdmRNx?$8~Vi=f#_*$c&z5d>QSull6ZS!zZ?S%BQ&tPtV*BwO2pWp)-Y zj)hWYcQt#l25PaiLCc1|eky&BEO2*cJpC7xw#DZP8X#e;dTaRNaQ;dceL*r%-r7<%0>kZ{-NRM3tP7LV)$RrV&Km&wF#;ewI*%Jn$Xy?Y-5eY<=bp^ z^v=CNinMn=Nmb?(=D`Z*bFHnMqjb!eN-T|T#1~hJzF?WUXA~NLVceX_2qYh7y3hun&NT$`9@e}X$vp# z{O!L?6@X`ufA4bi7!P_W0*-mNmpgYqX@(&bs&h7I!}a07BN=fwS7MhU$-Wg7!|7); zW?6K?W@}^{tN1(dxJ^iaCEgQOFZBB*U{`9v55n4_aRV_6o3@x~;1G<$x zQEitpVSfjcxf2Cmf7Bm)nU&Gq`hK6c+m@?T=4OkptQhC3yHLG@OUS=h=v9A5DK7Js z0K+ZkBz{fS0}8-vM`6rAedK88Hf}hSwQ~x{kX;-(Z_k>2w z8Z&I8rS)vE3@%_)x;8zNorarXl4HogP!E2m7LgS7dx?HDeUBm(gDjUek}LbX4e%L< ziHBw=EsaNhgN>4d0lG{K^`nwQMRin$9KhgUD%m7~;JunWs5>)Kf$Go{D;t0LfS)8j zv*{gMK6^@uz!OS{vK%_uUp18>#JnwZ1M#l2#o|q?nd}j~Y0q$6i;0w`EQH?inCP*x zjQ@WT=zf?55a@1ogBzzFqZ^;`(8DQrWW}gLz$En>YJ2?;e~;mySZHPO+4v>Le=2D1 zI>EL62l$EnU&BxC(8`vfFQ5mgJ{{W(n;+gPGQna^bdkH-e{pH~#axxvz$X+ad}5?9 z?4;`q@Cr65nmF#WZu;_*=PC$?XgH39jE9^cOe2xG1c(#yb+YA(ebO~8>={Wb1 zhS-Lcq?^ZKqn6sk!P^g&Yg#td1BJbKP&83*@V%#N;>TO5ey;NQC59$KQ z@b$I%@~CL!hPdnJLxTjg*DhBBZVdM4cKIy$EC@GHrjhw?rl=~8$LuR1_g5F zv2=hk(aMf^N?20R^xHKS zq4Rx~b~eRBFbJwLY9SxnDXL?DToA#sR;zfbCFJ?XoYU(2e%dmHj;(>Az$f{M75&k3 zO=F7ZsDB~OhCdOfg46#4;%qxjiw&;>8clLySMojzWykg|sSK-^_|8#YJA=6M02dY( zq+zUEAEl1E+`Hm~^eD`?jLXwH@AXaf@%6DsEns2s)PQ%VOK>K2P8vv9+UB4=^ucEy zvcp7pTwQ~Gi=s$wIN6(A$HtZ{9W>Lm{}hk3m?R!f15i2kq)uP#Sg5*HwDIBxDs@Xk z@g_jn4#8_nntKKFGV5oDN4BYPx5LjsW_EpkV^1mfaa(4kYgcP&5UoaSWhgi{PYOA< zB%_D_{{WkwzQQA?or;6CYPSTETd_V9_ZOsC)ew?$Js%vDTan$;&Q0ZWm9J|8ldM&s zvl<(r*&V4{dt*LBaCJUWk1jFu4Auv-@@h=WNO9wo`42VbqU%lS&O)ZcLcX3uN2hZuC}6Guh3|g{McDzo6Qe#>U}H{xazn7CV7CEM@$P6c?#Rx)hJa5$K2PB0^ta0Tx-`qf zD@-5zXX++|F<}3hu-)cbN60UZZiIC7TSFgklJnP;O~LSmNVLZE?=uy9&dsZt;-;qg z;c7&bN2YlF&`y*pi=f=%IRi7<@GD5g>ad==3Sv^ck$r2OjKF&=8%@-zoh-S!A>yvw zudDr>k)qfb?K!g0-vH06rma50Y{de)%{{D%Z)bog6Up)Aicq{0zP;LKx zkF>k3?Q2ZUJa|}Xqz;x~@$bGG>57U+h~G8lH0spJlmCk1^jR%PB%m6gN_ zLjkTIX1IQ*3PRRCL>(30lqSW#gHU4Y5m|n(VgDY<2{_^6@pp3GS9({BV&(-c1?PMi z-gwiAEZ^s^M@!9U%!|NGbX8Ggk_YeWYW3quqsY39B_zOd39ob(FNiMh$eF9IQ_UQ* z8B|m^)d1YZMRBYNgS%pJ^Sr@UjEj*&OI+zFSsL#Z20vaqOeb#?xZzi zb^}6oPvAwB&hx#_Dg?RH3?Ym*;_D6fu4Dy$;7xvWo5?0Xix@l0Xm<3^pD{UrcQR&Q z4V1Fh%ip8!ld=>`#q#vkn6}p}^ZL1yo~stCeZ^Ppf>akSGly7sx3UmozHV zI73;0RD?x!n-gmjD9>bm`{r57zpY|?2MDTF$!m8dt%3?K#Jib+mA>3&fIv2^E1IvI zL3|XPz#YMDb~QjkUL8FqOSrYM>1}nyi|fmts4vAbnWlc=8QG{e?`WLxEn=;bJyH&Z zYBm30!D|vpCMEt=W;LGv&!sQ7Lbm!1$= zN(RM<1={!%QdM)ZId3M(`o4w%B%4Z1wqb+n_}wqn@93~B)GI59$n~WM^w;VM8!@Ug zO3~PzI~oJ{y-NQcDh%6AN$v;RRq8U9*tj0 znhu-Y{4C~++>3{{KI*%gV!3o2@Pe1;59QN_7 zd935{XGb{^mh&_Q&QUkBC(ow1VN*t$K>yzLVIbiwPUCPbG8=vCib`bKtN$b*O7l5) z@IhdsU4X<<(P+d=izN+7kda`}27RR}Twvl%!?)}5RWfT^%>v<1N(WzES~dL+9gj2m zBKANTY?VclVNls3nF!^}kaVKS%OSL^i&7~Y*|I8cTS=yqvQEGhXN5&D`i`CN`88PR8-}F*nva-(qz+K9_*i94VQ#7cZ zlC;+J;_;uI{ysGuv*!24(50UHF3tgCBsy1TtJ<+!y&^~EI!>u&5Dpx4+i8sZ2D0u0Bu<4*P4^lSeUD$7zLyQ{YmIu}1%_?LnF1#TgR5q&J^F zswYdE@Xc2`B3O;ra5cHxKLP|_zrrr?M>L>XPEk~Jn&NV{@pPW;xk zP^ZOG*Bn0^Nz9eq9U0-a=& z1^z^uThWtuq8%jI2X4)vKQ-oi2(ycY{CTR(K!kjW>pVpb|J$&=2&BfGk@!q~9!jm@nv=O zT~_BLGeho_E^Hu~*0Kmyii*3ww#d*lrW4CXtMK>JwZ?`B?4hpmoNJc9ysj8{uW%gmhtr(P4 zT90!E-(~`7cv%Y?YWVeW1T8Pj(`eNH(+aI-(O;*3a<8QGW?Eh8v$crg_-!%y`WN|2 z`#IVGS=2`%Vry{gDqgERT)#_g+jCQ`4!eMYX+9Zx@R!QF4Z zC%qYC9f0(d_TXnf9sfuBQK^9lOF(u6A&1HkZ%*Q0{=S- zGf9a&?KSVjWeO&f5F|x>Ej+c8{G~3)>*XJ()I%GS@Nc^TDMVxB;S~G+<`lO-(hcCf zOc3qi8o2-4$BbV+%r*;m*5fvO^QBrBX4Q%ezg_v!<&Yw8irN3p{_Fe2-whGA@j^1z zJN4~)V2Rke-aPe&1olo^?3SO7QEX*x2mHI!6?3VW+Efo`mhbJhH{j1K%$c?6Rkk*` zkR5}^-ao2jyMWYi)ysqG7sn)F_}-87-_KM|et5odelV=G*>kxL^S$!VnHJh#RbtCUp z3}%cnEN&p(t$SFtj&Dl(P|h<7Sb2LX9}(3|iN{I*Yzr!?Dpq&fMX8_p%|@8AFyt4( zEtgbkB^_x*(Oh$HEF9e<6~BBJ0M2k=|0fEE>JRnywAwPtQasVx7mjoRx71AQVcC`J z!+92s_#|$WO%~K~ez6}lf#02ak1zKo5e)F_;8PWGrJ}Y7QY*rYV?j6_Ccf^eEV=A< zcpgtaE%x+SS&P-aEaYYGTJyB5-#nnV*_a1wjRmcSYom%a;ockfuRb!niVTzTk%K=0 zwL$yhZ?!aL7~Qty?pTUyTE%qVwDmg{*H^#CdU#w@S{X6-4**DHzsugB??Cn--DH6H zo_K1>^zb6<_HvSEL4=P>!>fkHk;338rXvYsXqZ-I_9nw3hO6{KA{RF!-P*UNlB<;G z;bqW<#|6Ml6o1kn)&nR2d{IM-mMh#bK&9sJo)mg^$A3b|wUtiEFKj9kM7F@^f=R~Y zd0~Zi%DP1j=@qf75Ox)2?I}H!OxiHmK*6w#v1phsVjZ<%u~S~1RB-aDCx1HfJa%CH-&IqR9G%GX z7_<#tmbv$NoUAId(wxQp51CcHln4k&H+X>8Q-*f7I-MG;E5q6<+x33F!{AM=n3QCs zaH_6kJ1~`GVtpQ2Y%yaK&c$|(``8I1s3aS6MYn-`l6nPmzj8+Y(kg+>8Ohfd@0(f} zJG<&yxewiz_e6k|R$2^mY(d5{;A?S%;^OeOhx@I?2D#!kq4K4!bbh%^%QEF$GU;^z zFHiER82Vne8w2DTp^=^?R4c^(L}U)xkc>_yRTFI%7&mxfmXpDxcf>YfvM!l!V(D|8 z4l0?nEIdou)lpU;Yp*e8Pwkw-BVhrxenc=CXl*3L-GKs%3=h*p7SejzXB!^6Q&CYl z0%*ntzoDn^KgHQyw>5H{;3qHCUJ1S?e_NzwC8{aw|;@(n5$Q){jj*q_@Yq6^1n{wq8!#xv%L7cBYz-)in$Y7&BXLqDbf8gds9b|)(934haJF|Y< zXGktUoIiFu5o zzyiz3_62V+-=gC+1{O}!HyY>V%l59X0Ol3%T zu8^_?+>*$TSL2gVQu1MM17cTqtpmiYh{Q(EQDGl=(QXpT| zeY2p;iFJEwZhceoCS&LZ=xg}(sfYm7dai?ZmRUx?5B%P(-cj)DWPNfYh!R5F26vi_B8a6#BxS31HyO5}-0E(7kCaR7r{o6&`DBpvDPahL zGJdKPGb~Jz#b=W@wR$0FvHVX^$_o`_D`o9|c;LXZe}mn_Q*6vN?e!YW8T?NmQSu?y zeD{WgrW(_pjd%u=x3jji7M0qqDlTs%$mk|zU8AT9%t-59CFOqF>eD>pSDBPhfarLT z+32rWzDbWmr3@$;XmLVug;Mn=ep{d@V|`&Dy(mRXfk7T9l}kcgz;ggxcf+K z^>Rwv!*^RjB9rEn08y5&)&vuLaw!|*W0(L8mkaKgA~p{>(!%ymZEji+Lj=%97s>a4 zE|Xkn^JX_5v0F}T1+RI&-z}wVBi>L5yqYzT{-xiLfe*;1ynsaB?z4m4Nm5NK2=|_x zg}oIylilF{wW6YK8dfGm=Ns#+VJJ;IWWCO0kNLb_?NEQ(RQqd0_#!V3`H*DsUJ&4;J6n*l> zI*gZ6W^OhUKCr&`iin_WA?F|!F{QgOlD5$mkudecDSfJ&Ou#rZxa^nVu~rTNb@DC7 z%x@I<5v}`l5a^ryL;WKr0*QcC?S`W)yM6KN1>KA-fQ9-wlDW)hZjo_b8z9oWBz}aI ztY9>gdICXOKt#cID(9<~cZgcpJQ`n~KoflKF8B>)6CAY@VgtWEHbu5@UJ7<)%S9fx z@XZAP$CNgxjCaqEe@iVMCuDl;fYvnI%;8Q)ez?%ISo6F*$wqBD#W>}qCGuQG5Si0I zvfl6Mqd$Sj`%7w~l4%ev?O{rMZvw@~xflFU2C`LyhUVYWfN+~X+hH)#GvD^bvtll{3H`qQjetnw zbAVod&OM*+#QfAN9K_L-ue*U$yLIGA9RlI3J3xRETZ_+50Y0G_?|FR!u)yycas zHd6%@+c~pm&X%+ckW4v6pR2}~5NQ=1{oA{kis>ji+{-q(AH`MemNioGi?4|I)rZu$Bf5P_A7w4kVk5*+Uk=T?XEcfyz3er~`WQ1{LG zkQJMOtSt}Lw?lSstuROrIj$`-Csd*TdCqxAOdr!(1#(;AY~fHYh*(Sb{PiEE>vv(BfN|u1NN4(rs84g4hIn84zOsCwk)ifCiPgTpEmuQbjGA`>prb4 zjqoLpCEl6UI&j{~Zt)WVuSShiMI2l-lt&kX7cOjN504`5?Gd)beh@snGIGDV(79Qa zec+`Tdvzri7sAY6tCu9v3eK9SQ_Y7>HOR$YoY424yw>7&9_tpd_Tf4QS7@HecC%@m zM7{vW2sC)51GZMD_cp`0Z8oq(zptxsQ+$QfZtViwr%+_y!L|+m&P#co4y^ybBc0n6@<^T52;g-`h zW)=Q1M!HVRTZ3i1Bp1GSb_w)vxCUslgfWs~C4T;Q0T@WyXlX}1+F;rg(deIUu@%L^ z%4|N?6~`&G3B1*PaGR-e_(7&@;9}i&_(h+@K~JAiHrUlhvg1S%8;8NFq(B@jVC+GL zT?Njs-LT0m&y%Q|qCC3O8Y{=bQkk zt%Leew~t&l7(o!ziM3P2`Z}KT;#~Uy2^_F_jWSIUDO4ks5~*<`l*iUSeAe6e2}C<6 z*6Z=IXdw*T6MKuWfC%aT2m%V_WXzUD39@#&g}(z5RmBZOMO3VIFI=po-2J7Op0#`V zA}y1~7JJnbWw;Go_w~Zs0!oi!vMLcQ+0uFLocQ(g%_r(|ckgUw|31j)vma7ZF`e0- z^#T4F+NgWa*4zbDidxuE$Ph8t`qVr#t9oY4M3wwp@ zBooGVy5SFtBkq2WM=dCK9tL=-@8^KIp}%*(#CI-)_a)BX7i)#L;!P*JhlW?%ZLvHM zi0`S2#{z`XS8qpckLtVtHv}r(Kb=E#9yVP zd}{e$kZ*bh7&Q|pQfHKJ`@|M>%6dce`x!j~*_h;#+&cZaw7F)+t&Lkq;WM#2wT|Me zZHa5wQz{zPSf4)_I9vq*Kv*sS!itE-83Ww84#Gjrhh`AgEvKePe|KgaW-Ltl4%7X@ z7!X}JFD}H2J1iKdq7pg{0G>{gJ4azHM}xj&fIF1w*eRpBCA-Bar{aH_gzdPzNHso?b`(-Ayi)p3^F?7mp${(-eu-?B?$PMej>8o*&JVZ6 zd_=_R2Vl^-8=dQg8?qZ-eTjm}RqAd812uxkTJQI70Jl%zwd-4QuK7RIy=PccTf6@2 zS{9ZS1wlcYf`C+|_vk`II!LcUrAm|DiHcH0K&es#(rcu5Q0ZL=5UD{zO@J661QG)O z8EmZgefQqyf3AH#9KU#ZWi6N)bB-~`xS#v}J?qVp2pEkdA&TQ;tTCP6KqMB||57I$ zsxw^L*=ig|^jq`wc$gFSa-oXFoq5sjhMd0Dc!PmUeyg>Q|B{11pqJ8F#bfKe)*E^o z1%;U313TRV+?)HXj&AD@IY5n9VFZ_->UxIdcXfSH<~pEF%;Z6n#6|F*l6tx?nK|LH z7ek12K~oT4@@}l(c76_-F#B-e{*2`*o#Ms-Eni2DrGfT7&W=pTuEC(>J1Gnb)8?t0 zx=q#%prTEP7tMv7iV_kPj3zIvd8A#I-dqWmf}?2@7-(KrX9P>ANlk_eYT;JG{K8dp zP7tCeq~G|F?=ksR;>xCw_3GVLxYr<7F71UKBjT>SAmV=9^5+FU?>fzK9L#X|_wBw( z1>{%C{04+~F~>TvRPl9$t8XzCxLDwTvYRq7dDR#QsA!7kTGdeUCo6h&1aVSCbEZ~< z#nRzlVtiO+opiwmbT?v4!t7RLkQc*YJRAmgnPixS`zNNBY^eDRZuEa*#r31hWE*+< zt8ubX*Lz`8gQafA?hVC%Sg)VJ!Pg4QV_K9wIW_m(9cSg&)YFFvTOlR6xVWX*#b#-7 z)~JD<0sYRD>==igIqtFE1$BpDhkt0u7oy1y0dh1Ao+vH9*%9g zNNC@c8@^++`fy9zHIpGj_G|rf#4W1sve)cYBoAHSurvW2mONJzX$1Yh%62UHT3geH z$GGqKRbQKgB%fcf9hPk>vXkD8fnZ)nJKxE!Xy#@_Tu@rnO(1T-!uBR(vI&}$!Ejk$Yye63JL z+(oeLG)~Q^Q8~9uNhA3z^TjT(XcK0O?+a-4rt<^$ekY2@w)Nf5j1#bI);>FP8hf); zZ1?N2#h8^{D#@zS$z`MRWdJQe8@lh6d0igNTdOr0{n0`oED$5gWaYY3?zhR);rejS zTTexac=7qY5y;#!&LgvSp-Ro6{daBUaVRjmbPKS~!B2P^$#*y1Hj8!N->-x47v!~+ z5n%Bt5`bBT*x|z6Fa>pEP#Q!C}Hi@?8M4$ zcX}V{y<0+{dRx*9;I}yxwKXaD|M~Mpamei`uvTG`T2_kt!kLT;&1HM{$Xo?la|+#T z%f>7p^h%ST0O1O^not^`Bp56>IQHy_FEEbQ9v-1Q5xo7>G#X52$(q&yAOxY6Fd5y) zrkVLDfWTk(rf2Mp{>UF!WH(FDsmSO@GP?zc12avZGSdd#@oK?O{NrFs%{juaw;ynf zS`thV@oX387@Od8Y%NK%*=4{=2~-Dk8y*|}Wyfhc)qMAkbF(|(n0<%J7ZLcAVUBUh z6sJh-%oTz%WC8JOn94nc@=BYgW|&__ub4V}J8mN8wrd`F*H+PpBY@O}$JS%TlL;D} zLJ2){>j`mJ-bX;~y&YFT*ChVHoH^@b^=DZfCQ{XKRexiY8MyZj*}@-vDx)0SQIM-j z9>A`=XW?P|KZdX6KWto2NdIY3O_7t7GPWvhILSrVHc&yh(ql7}{c7*C!vWvu#bq$p zh{8@VxW3zt4srC$h_krg@hQ%%@T%CgCjD?!K|R0Dr|!hhWtJrZ(Cg>>dAInpwx{m) zx2rQab*5CEXqWAw*p&e{fMF9?U8~8CYtq(0*Jk9qyG)7=(6IEG^$G!`EKZL&`s_=Q zPk^|kxfwkVFX*9v(enp-QLkBH{X(W_YNm60OU_m2+un>4wlKfnUlOOSY!*xB%6hKk zRmQYD;%V45u(}U)p%;J09fN~AqOgy~qIV^9K;lj|Xa$K?@y~Y~-|$Jl`3u|~Q5SRn z));()3Ats2+UovVD^up?-8W=?B5cw9ZA_kb-e%lmy(}5iZ8xY08pQg=UDRKBExq3^ zaG^5}Sj<+TF>2VW;Kt+rjaHbTJuk57JP_nEn>SgY(M#*wmJK5MJMS_JuEwNSk&M^N z9?pPSJuBT=y1pEEXWyi{zQ4sA4!*OB@>8~cpWD?_eEC(f;`qT0#;xyLxJTIgExBmV zF36C|i|1>9TOTVAC;n_~e(2BzAdi$%6}6--MBb$`Vnebb;*AHonNGdTE|twk7i=A@+`B0%wJM*P7F#IkwNvFW?rUx7(Gknn5wbm&lG%c+Aqv^3YZ zzn%NQ9CbUx{4+C8nXxw)0Av3RgnMsOB4WN|;7lLGXS&8CVK4apMAkRTnC5Hbj-Rt=*G`QM-m{FlA^X^+Uz?ul_OM2se@T zxjq62KiSKCll}0Ai9Oq-#KYhIoI?6x>Gq7&9Zg%&JzE*qDo) z?wEenaBRn1;Bd-Q?igoq4$|H~Hu8F>B4LRtk`~ufAf^)*tkb%&6{$3;!cpc7G2JBN zR2wp8tZ6ztEN*{QP08tPbgoZW*D2q#H8Bo=H9r~~PiEK7NoUZ-L~|F%ljf(Q%mnZ6 z2wQ)v8EA_Xn27uwp|=WFyfXFrik!35hrqr*F=5~VP2(yn|9n6cDN{V~ zRj`T@OKY)(q<>U3xu1dQ?N{?_uv!PSNruayA9{ljRN5n_VwUH3%6E|bF@X5hV(=P! zVy}+6k)|ligJC!dqRNtY=T}fb(6M}D_Muonocz-19JI`wdW_F_OOk|(@0vs{U>^$X zCU#+!hKaY^Atr*bo`$O>_pn_4j7&A#XPbs!3nL@@=2O66{>i2Y&mvq9(@dGAALPs8 z8bKE=zyH)|vH}ASlxNJC@W^lOd#GWzrb((2-t9F}hFBDnjk9T+#(SpyfIu88td|i6 zo%-BdEJ7a6*;cC#NE<9MWZzWF;^j8r(1V2*LRd5^(C7+Fc>f|f+FxuV@D91GR7;g- z4~HE~#D8+*3H?;Ek&Wz4BDF4Qz>DE7X*UbnaKV<2^_>8otgAb0 zrs6f`W4;Y~u8yXb%&wLgu_Ot^g}XbF4SOc@KK_>Y0FQ(}>M*>`JhCgiV9#1^h5wjc zXDuMkwj4+iqzx{OsK{D^sxC1O!(h+V>aPMW$ds2=jQH&veGE>c#IiL>?Hd}Nu>q(NreV-v;9A*XkQ1mR6G#cCFK(>m2hFjCgQ#JKl$7W`Y;IqE? zv%Vj~VGB%uBwrsV07dgwxrxR0f;T%`arFYx%Q>5TU!3uiZZ;AdM=(IVfOwA*FQ95( zUA%0TBx(j~NWZ3pSVFFUa0D{$lmmj>Tgm|eZdV&GOV`BQ`JfmPCkj)*Hch^L>+$C( zBR*yg)TZ5X2i!D!hZnFuGz5Ts=yIYAa**{Aa3M`w2#|A!J(6jm1l@hPeXa*Q_>Vz% zyUKvqFvO!i@O7SfP9fy@MK_?>Ns`W!V9%ZuxJ&ZETONyt2JS?cNAAKm^kh!b&%eu=aKzI}4pd$3rTJ4*om#pK~wx zHuaC^`vLY?+mc-@kuWSU6ukd5PhSBffJfU=JtB-s!yW-iXa11Z19LdGdpcSmGfK(> zpX&`h{gldEg_9Qx3ljC@fJUdkr|B)V>k8_Wua3&Q*YL67_7Y<`8RtVBUeUT+AP7dG zypGB;MlFHaw~1M4g|6E5t0i3IzLCR2r%7J9iK!MMaXiNx=mV^7C$pqizHMnLkE$+H z*@4xDXDR~o(`tF8C+z`O2--m&?RdrF_etg+H3L?2N{F* zNGoktPW#mhk(iCy?shH9IC;Oy5ASxWbn}p#Eygr`y?p+fK-?sE&#paba1L9*oJ+m` z0{>w7PQJM!EFeVJI4^Zd7j%>NVwQgIQ@n0`^H%zl*F?NoBi*XSVBXWKsm1Qm#~QLp z+H1F)yz+;>DFgwx0uXV)J%OKA2Go|CWw0nchQ#2he@#b(2lG(U5zm2i1dRcZjxgF! zNBD9#Ox_&7f#qu=Nego?6<*;||%sIxHE)_eo0VQ(-c*wvkLt7V}$qigRmS&u}jFB;s4 zXWr96Qk{{&5Qbf+Am0b-DrKNtoT7vMm@`??{AH(Etsm62+`(7OsQk+E&vI(tJD&|= z4zI`<_WFDvQ}N_`rh>bIlBw|Fo>aqfHBB{V3(HFgEcT>j;^r5ZVtbpv;XQ1gLlq8d z3}Z048|7CTrlPMEN0%?UPX|tfbnIs;%J~nZ`t_~vypD4+F44-7>m(O9Zdj+^#+{#N zg|~o!`9wfR!h`-V+1v1+I`EfVT_J0d-8CJqLPx zlIhNPL4aQvvB|OCu%;5b@O{EY0ZGi*R=Yy9RxI%kBiIYu55^@?vkC9mb)klwcFf(* zD)ttXlcTC``Ett?5GxT$-Mv!?Wb7pqoZ2K&8Awf0Glu% zLGmZPSvC}TX^ULUe?V{dm$*gB?n~FCvF`@8QymyfE=D8Azw=@P!n|zMt@yvb+X`ik zQ;#y_?P(sQ4OVad73t`e0wNvX-phtpJx-Q8CHUop)d?FF#9;KGwkE-6o5)sV7FB=U$>N3TP@dk7b!Db9QKN&I7FOTe0Z9THHv8wjWp)?ElyPtrMUH zb`B!|E?`|!+$A@UJ4MYLzLnY~^G#|?2MtgNvUpU_VTg@ejY*djJYR{Bffz`y+cbB) zD$G7E#m1)QxC5BoT4K{x>L%&tNaaEXb)ZEAxa zZ}?*a1%KAE>K}`E@dFVUDRS6Nm;MK)v61GNGgKMur5>xgz?*6@OB0b``YV-w;jHH9 zyd6bc;JBt)q5))tsfwF?RK@%fJx(*wEK<5o?mZ^b;teOK->A_ZB7Ry8#HTibt1yff zkAQm9fEJQ#$&+)Qk}-`5yO3|*c1xl5^+lNA=Z-rU^Drt6{!)sW)|1umq(P#3$>^O# ze2IAQ5I%?Dxc_V0Q{zjTaV3qF>J_2E=aI%>7Q6GZTr^5PexFW_Y>X7?=?c&)%9#-*-Eu5wKhUVed1z(n zQfGXmKw0)#sHKqrWE{JG6#2&np=#y}GS|nyHG(LosZiAf8~JhKJOtbpg#9*?xTc=Z z^*qHB`1S{J-fFkg0ard9V^YuHc{(eXkV|UAf}tl^GMRy0iy64BOp|%MJ}d8nPt1Tv ztsXpe!<}9AW25KkY+i@7!A;NviA_9}%dB3qv-uAB<_&-BceFx4tcR@VvWggx>zer} zB-_2<>}MuEBsqdv-3&S{Q$P6`SLPaV$=P9>KMMOL1`EIb3KQ&?iocqH{tHOD_*~Q1 z`cFxh=NYM&<-z^xjDe~4FOpNVlVLCMp{w@U4<#me)q{VQh~|2a+CzL6~NDpB{{eEM`aSMpW_^->}Cvwk_$M*?9;Q zfnVpN-RlgnENKGrnU7{jA8r9h%EVljA6domfK9jth&;7(3DH44s}}j3QGe;JW;7*g z%=V7eKz!}}nIcIAnesl0wiReIVY3ju3hXs!9wcY}f-bbOO?hllayNUHNO*rsOEgct zRk8mJTpd1#{Igh4Wk>e=DjxCS)M-TDD@HixDl3bqUL;VY6FfclB3OUY^O=`T%FiUt z9_8o%1M0vwr5Oy0QkV`)I?kxylw+J9+m_wNB^Q>GzvJxj>!;re4l0OOWrqP>B0jg# z>QR&-xN_AE_iKp=7n$-dI!Jkl;)X(5&ZK)7GR3Z2P(ULIuN1yjRmFl7?Gz0ZqguCT|TtdTHHlRNDL}e+AL?@GXZzh_IN#1-r+HECM$05Oo!4|z2nv5_=>pTohmRV zB(SGaOf6WoQ}ctes=n`dWxD-4NJEK{{tOgSe)s8{#h65hD6IEk26M7-8n54R z`jdu78om9!YjvQSRm^|ai-vmHG2%uuyCeHmBB^F-l!mG#uFmXBUKG~dS&&!s_Kp@0 zNZr-{__LeO-UtTo#SrG4<>ITQUhoJ&^m02T3ez#{%g2|5|jX7=x_i2Nb0;@a#xAFp^eEN%(b znV~TUz!76)xrdl8RIeCI{;G!mm)8;P)`xK)$PK0~!s_|j5XiaxhxzdtU_0dTyF@t> z(0F7$)a$#<NFk_TA3 zy4@_NMioKaZ$qrjbSwTTLXqpQoUoi|ik2oH(sCjwk7>g5jG(uj8z$m+rFQXnnl_N@G3X_KgNYZUb7Rgg zvBH%h;+eVB8j&Pl-w^9$b@9F3@8ae32CzNp?O9|z4(?V&6fOlHSIT)}Bc=`cFmBLQ zu=}Cr&W+4%ojjI(^~u-x2c<%hS$mhR;ym?k`|LR#5#K1=>~H$rc^fmqiK%`)awm<> zWQix|ug6Ghp;x$+QWd3tt4==Uzf~ulA*aG2l2TGIyEyAi6{E{MX<)Q|9fPqzTHBl2 z)n5)Kp2Z%=O$aqoJGpIR1=0HzYza|7uDn5jHxRW=L6K5BTi_Kw0`dOe5^+--b>3yQ zmOB@k*a^@xg!Fuf`qf%9zefXm^5OpjFfHp?zH9%8>zN`|v-YaX6x)4kJ%5UJ=yNcqk2L|J-X)}>OzwZ@FXqY{8j*D$4R~6UJHaFtT!tEMQmbk>i;5T zT@P4@x)xMh&FhbO7n>@gt0)~u@_z}X<=JoRZWq@H~p)@#yCxtxh+{L~jhAfbm(X`_v_g=3K9wn6`(u)TK^2ojRyVeQLuT1G zWLD=<$sXIhPU;j8M}4x|b3HUrno^FbF$}^7YBW?j>^{@FA^v82sx8eJ5PjhtcWCbyVncqIWLcEKw*=8Z!2+{3#3qY ze;el}ZWWDh1NHWY@b_z?TjVV_abU$FqF7zDkMj2+E?-knf7564eEFpmDB27 zIWGAkjzmku^r`4z`m5S1`1gHVYq9Hd8X$TFzMmzt$6 zzReCeM_P^KWzLXunZS(2$d$C?V-D->*i7<^$+TNMGtIZb}vh6&IYzTJ0lPN@O)sSu&st*TQsP0}k>P_PsI{r0El%h*ES;0p^5VXA zXZ7-w$6<%|`m&u>ETG1ez07qhMuD{vA3mELR!H%rNw1HoY;(->@n?=r6;q(`-{Tye zF<$ap#QXMQtQOB@2WFlLv05wl|D~ckplSB-!fDMC`vPR57hbGw=dq$5H7ojs=X9RIE`eU0?j6 z1KOXcwnfLn`r_}21LRcbkhyQu7kxRqq2O?7U70U=EPFW*Jjr^mATu@2fQ~H|Myha- z`H~N4R#;(oRBu-WxnaNfivTu-UJH6rGJ(#SXyH@~2ZJ}cYbN=(-`eK{W(1va` z0~;A~xIw4Omu{IJ8jmCdtNfO!=F0vnnQF8y;1ikx5jkfO#tEG#0T|1U z(#Iw;v91@otr5zxhRy6}q-VdwEW0gR#!32Q(vw=MR_#x|Noa`iyx(wmaG5{oS`F9@ zLmI3k7_)l7c2;JZ9Kz!@xX?y3HO1Pdf@1C1DMErB$#>tgR16r`ivjnv)yAi5hJ`g_ zKzbx9S&DAqS@~pB96%spF#k;;u?`LH87nxN@iZz}g#sX1f4tO^4uAiPd>KU{U&Y_MV@b0emq0kA5OEsiA2pJGvCe#{3DFpuP!8P_Zu7V2&<4m=t? zm!CC0!ri?uRx$loVwJSaFR|*-Z?Ov9+~&^DVvlNaD2k)TO;lH+wsjC;D>z<%Xx=5K zaEVqVc%iO|vUT5oD-IJmajxeU?u_}w#1L-HJiSVnJ>=#O_Cq?@pVtDSnhx?>1M-#r z@X#^kY`Exm`bs7C@_mY6rQIGl14_)pg;`~F$e1MJv#fECJKdwVmXc5QIMw&GxLlK8 zXG1dhO?iKQ+h+U_GtHW3w{)$1kiEk!D&op%Tp&k)&Y@0ts;!HLwp{NJ7nS1BHT(>6 zCcy0_G4q9&P1p)~E^4OerAl~JKGJ&d+=s8-nsGb=WiN}{YjNfTa;9vK5;gvQLUC)L z!wyt=7();VSrE#3xsZ?39Qk8LbCi|N$#h2!K8OT|qQ6Th5(NtzXO=@cy+{_Nl=$XJ^!0;FbqCwy^Lp^wBlI2m5no(O;UM^uVC(6 zUiz?1D>kR?+lxZuLyIAYb^j>HmynN*?Se13ZNG}bf3RzB>LusmFa?e>_Hi1ukRE82 z6?2FUpB+(l}G$#8#_i~g>r5@rE{n93{)q`nL+-xts_j-3$ zcpPVi^UvPbuaICnI@JCV?lXW6G%3LcMks5m)czoCZlfk^;@dYGdIBS_0P)u?VN2@b zm*>OJ=20T9gDjX%i`0ZM7rFS*g$^L&`ao3Ft_~f1a~ z#!L&AqHBVV3H4v)PWX6v_l@`)Z_Y{LecVk`aE|+JpTXb(^eYQYD9>C|yrG6yG=0Mz z&!`BS&H9B}gr1PvNKUA<#nl^c{mn73_(aX7yT?X}{8N=VSlQm~d^2cnHLyva9W3fn zp1Y>5Bq3lb$KL(lpi~Acyxy}aJ zeT3+6d7Le85^#qWh3rlMGXW?@ydc&2?>G$=K&dnLEFh6zE~j>vn?Qm4bBl6+&a}D! z5WMAFY?ZDX2@8|@J}W4|&>sSp@9XtjjxrkcUanEWhlzjOBuFC2zo z+rzW(b7*}G3`P}NjA6RH=<^>YRfzyJm##1B2*Bvm==l8F7eetzw=C+L6=Z7p588hN4+5kNwuH-W8|k7_PlXCe5<0E#X~BzZot6m2!3a?JwnO zxyXfDvUNM(0J_*`B^A_MB%}c^g*6sk*z+J{%)?;pGnZ4Z%^g9Io_duvHo0+6(cl~V zO|0q}VDrg|@k^59HH{nGM()KfIm*zS-IP<{UJO658^(~7^qTQsrDW&b6I0y-k}i6y z_#2?zaGGCt&DeJl=#l;re9=2I5i%i!Zl*?O93N^bv-lQjIU_lWHRscB0E^(rn`w@_ z@2=ERsTvcCdi~pr9>xc7U4ul6Upfk>o2ZMhldr?=2BIWb;(? zf2C>-Z~sHpq6LnZ_Bl($%%c;6d^o>-eMUWkfw4G+!7>98CM%O)!U7Ot2p79fLY6&| z$7j;rcQZ~U-?c&rnaoo#F3vBBEke6RSPI4^&`X}#CmjEwzi1t5>e*0|*Al8x&(-2u zqCLzdA)UG}YkXJ&>dfe?@D9u<1E?H#y9)rtkV`<9s%{LkA5gY#0?JldA+MhiA`Wbl zDu#(>#5uWxW{9;iEtk;M=i0kr>rG~!vW1mx5YZN{DcYHuFL`L%WV-%+N6$2$fyE;)XJ#ObH6l>f{Ps89Lu z(`N;G2y{NDX-XP z1dU@elG}=o5vWd!fZPGsA2IQDIe9lAW7BOhy<{DH3H?Gmp&QjI6ZsEvYCiBibO)oa z`L3(0w)WqQC9Cf+(K$H)EeU3J;)Lq!qU-Kg@Rn-lPl1O-MZc|uOHm}EL3@<8{;Hz; zqK^W|9$cQh>B-_G$&b_!l$xqVH?-%>5rQ-7gSVEIWrm8Np$qex$VMkq5-H4!GE1Jg zQUF8itW@a8T}`uW-gWg7?&QvDWV|$antzHYbY_@!?WOo}3nX%7)+&xj_Roh0pcZKawBzx~roax%W1v;kM8vrw6&9)I86ZsD-y) zcKsD|1Sx=m)hjtj%{B10ix6LJwyFZ5NOZ?hP|3jla5=tJ3Ut+GZr7b-=5(Gi&Jaav zzA@$N=K^t}#=U|s%_G6z?PAH4-An?5Df?GU>VRk$VDtT|6IZY-Ul8jF;Fu(Z;0_Xj(sWge>uiT0)pBL{gJqX?r@6`3xt3zi^;+?8@#iv9m!Ow$AkN6N zccam&!Y`VP)Uz~Lo=An`3Odf7DtSI%TIlHspmzbfe5P=8OW>Ay8uCBMYklF46f zTDTsur5d*pzJ?3zkrl}MXNR0S!9l$90k!&&e9VGYFzX)Hv-+bg!(JeN1arXY%EEF~`BhGL4%!i34Mra+_C@}Rerejxbt zHP*f2BGJG}4Hp>eJcTRMlq60FgF~}TbLMV7HENX)-?)t|qkgrTUoKH006I9jfLZCp9~gJX?fVqKF6j7ZLv9iF-D>ljT%l$s3O2H=_Fr^C?*{ZE_# zB#aQR-fA39+_|{$s>+^hxSgDL@fCutf0$QEHD>MukrXt%JB%t@CBM5ai*DG$ZxTuv z?J>>sjUc9xaN_$EuiPw`9Yhh-Zlr2-Be$Pvk8sz&Wj(+HAG$)WwUV)*_^-%+myiPN z@=y?n`{n(r?KI_>|I)vDATs01Hjdxh0UOv7oI68-x+(&$tC7HD8PAQgFiQrCukCz< zk{kgv{binlP4VJkrr<%oZ6vN*Y8-U}!W)S7Q_{=WQLJ^~l(gt)h!;ToIgP@TF#n6nXdET_^MlqRDQwqSUQzCQrz~ zX=SOYjV5{9dX3wyBrRifi@fYGOfYHxrO!Y0XlOxE^8Z!>d*a~lwL_pfnUYIw91+~L zjB1K7!aI0y;b*p*6w&Od-NP`A{7INyYhY0qAxuP;KLEN!M1oDLzaO*c0P%5n?P@~8 z4Vo~I-Q?=^TRX55)D{0GhaqSxTVuz!(w{3dCrU^4cWUy6T8)ZIG|#3hbPh#LO`E-Q z>+Re1k~N*%%ncuohvA&-pRt_obW5P5S03MU(SGp5l9dzAh||0w`&|;_-}x?y-B7xc zd!k@}7K=Z0vOY#9eQRf0IO=+tRZ-)y8B3d#r!kvqYsXwz!{>?-(O=!JboI!OKwA?*?RTRFL|dPs5ybXikQPw4ai@!vj%9k)h1h6+fEe!(kuWQ2C}4xjfe*;x)BhVi>?~BxAM)O%Z%al?#vqSr&mFU1g&yaSRNRsMTc+y6JGoK4xd2mP z7JGmbX5a_SV|G%G2c+T;WM;}+p3<@M0hgMcmi80Vf1u(^_ zy}6BSQmWk2lVbHDo2}O}_&i@?%RBroLB;|4UOTS;4L%e#@fK1s_nFw?Af+H>K6a__-R{pRilQ79hu6@bZ2Uui` zYN|Tr-$-q6ht=3#ANR=}JVHKeL80PCzhk&E$iVTE<%AxXw-Jcllz+AMtvRmZD0Eff zJ`p~^D;*IU9Js+<2^5a*Mh(KF&OL6{Uw47Vp^Ci!-NR+m+uRIzxNgTN9JV;%;d)B( zaFqp4{8dWva9QzVHQO4N)J-4g%K79YdqV2g9C*dhLtHh;;rLy?81B^4YV-0b1?l@T z<)1$|`9hZL>rENzu);o_@oY_ZdlF^1_beg!q-(y{du`cW zjn-9S(Z#(MS5zS&veFam#({w$Z_y*I(QQewzZ4~)M~`_s{%Xfg3DU`D!y5H3g4x6{ zMKJqMzAme)?9+q6kSqa#se4$CCd@S`GmhmYqE-Xt0DESacEh+`&e!Jzu$8drn!?lS zDbf{Ph-5Ps88yNJuwC}FStG9kiX}Uu&yi4(zi*@oDIMU z0EVu#)z~J}ovI?-nxu-Uij4RiARzVP>InYxW4lw|WzfHY{T`)ZOoOJ@PCL-|Md8Cv ziPPTQ)(7F3AV1QZ*`Yj%3z;js6@}R}{fFwz_WP~G7%jnQsTI2m8;q_q<|cSyqW;&U zGQJb1hq=@uB=|gtB&~e1mrd|@>BxT}tSW!OuEE3We3wD1<*E!_;UAjfEJox2%a1&= z*5Un!k*tgZWbA@NS@>RMg^?U^Gshwp09mlI9k$`0?N~25a~=Xo!S3z@kSHBz^nvtK zze4h*yb+z4?T3(&_*6VAiIs!J;NE>@HA6lN|}C zs>5=vNUHfThV(ZeS;YkSN ze)}cL!Z_^(l(3DKYU8tS`3vIPcawG>f((O8M-ro!5(@?h4b&$l2L7Ip4prq`|1>aN zky&;*mr0fW>1?WL4PZ$4`%Z$;UFn-4;+<;oOT{^^$h||wrE_*W9~3p_KrdO{UaSqa z_@vBND=Z0u|NO$qvb=;3DZ}K|?%t)heefy12!9XLZp;K)=LqPNbSKqyV_mrYg~@yS zZD~fmPVP+fZ#2*RMg&u5xG&_iz0^(tm!*E2f9(_QC`_}#2KRcO+MD%(I2K{C>1Mup zJZUYjVcr=}yp3pjn*T&sH#r@UX_j2qj?}uzejCF%xq=?;5c4llC(T8#vaT-_8B$Sj zw}T~K(ruP)N#~$2AlY9G+aV;B|Dg&I936Vfqc<$e-@xJuEM+_-Y_2BjSVtBYSWbFL zQp<15AM&NT<9`;>){v~-%76oG^@1MK`cZpQiZ+>Cp?BlE`>q!_r_dRL7A3A%%=(N+Gs}=xQWWu>a-Fo}P59;cl6#LwsHo+FIRfp; z^iJb&Lh8JqE=)sbf?7w)Wl7I6Ywdgv2UENN^o=F$Ud5`Sni*IWbva>J5h4Sbiiqe> zmd9BEE4fj*i+k^46)KISg-!+3w0q3wWDXKpzMOL(*( ztErV5KoSnaQd)z9(2s|wj z!~kQ3s=ZwRenFWhPlyx;LR`P|VM{o5pJze^Z$^R)>y|IbQRFmxC?AWPZdsHq3}CV5 zMmS6j4xNo_J(q2ctUCsel{+-N2|Bg?%K^qfKE!#@0Tw$?aex)hd=xm~ z0Q=un)BYEHU_R%Ir1WdFv--97)PrF2czPhOg(q_qd?h|kVOf__>z8U$dsSZ%(qD^Y z6%duvxIh_f(HTgQBiY^*$%9saLm~|>r>az#Lcg>IMr<2$rbd&`v;q2M>kXte4+b~| z|5WvD+J43=QHzCfJqv|#pnJ3@y%^yBTep31-_>xWUH9+n9(c))ac3C!$;<9Q} zLeq9{RW(vvR;Okhf?4ZZfhA*8maM8OllRGPevC^FmwL9}Be7V+=mYr^%@09p_AO8} zP0$kaY53Bd!HB`J;@u+C>%X-J5K`Cx;SSXGA=JWyzu6K9@KiJ9%`+wV$)_t?2)cHMOLUiNYJODts;GYxT!BUH`w7)l3di!i$ti_2W-9V53@;*;mAX zK0^nxj!y`Hgq>0qvtYfqNts4Y%O{)^Q3FTIy2Nyg;6jj$fjelp_wAb8~f>&p$fj_{0K zTJmeB&i$A3kMXHD2Hw%&)(sqA@hklX=u z38JQPLYcb^r)l8uJ3fBsG5;@5=Z{OK{FO%gKj&Bv{OA86=KA&T>SDXy7la^J($qE$ zAARXxe(S`YkY9AkLneO$V|nPif3OzLQN_TL@^LfJuAA{ zy=#9tL+nI1breeQPDTFY;sJ{v zOsTRR{5^L%wshURH9E3JZ$%RvGhkGG*d)QsXl_xAL^#+mVNz zIb!0My6OXoZim0!mRZmD#z!;();r{c;QDxW|9_=WKfcVqMe{2bEWjYn`;#-dAo+QqQQhU@L>l^o>L zqu-l-AQKS5D;%sQ_K_{LI~VOuMTU11Wa6Io((&54)*=nrFZk zj;MQO!7PfS+NEH9JwrxN7sW+~g{~Gn%;7j(K@GdwE zS0gmO+8U+Jzbjm_9p{!d;4Hk~%J&`E()9O`9kK>=$}@m*EQyt!qMJ3uQ_RO#4)=#% z;@1Y0?OE4b3r~SvFRcc7qCPzjFl?Glee)@RwBH+PPtyt!#$lOlZ3g{!`b=2=F3K z6q5DY1p%Mh4yja_(p&vyjqlVHN=h-dPe`_9*KHptDkY-^~@$ zYY>tvLs~xX&>hb~sjFUB>a9I@(?; zxmy{#s+zWondk_fP5HY3n-t9;IwjOVHc}t__+_;<5r_5$tu36LW0Y0rkD4|#MVke(#FUFw?9Ikc{X>k}} z6$%h9QzaGk7E;mlW+Icigy7~i0PIyFdEQ$7x^};lcn>U2-utETU6nXFfWP>b#e~_D z7$pLb*uEu~J5Q0SMN20{^5aBfR5%6*PBrD|4GmplzmQTRPh_S>VCol@&FIlZJeMGHjEK2;)^u*%{NKvNQo+seN<|z?CF8gg6bZwffPq96GeO zp>+F}j_%*?EE_Gy2cD+y=%TEdp+`yW%-rgHYLUWsAM%$aTvbrV9KksqSX>U70?sH; zHp5GMj}ND=**+}0Cso$s zTN;xYd5hbUtl!7tq^Jxp)4!!!l~;$O{`FOp0STq{5nguntY&K!YiDZTRK*FgAH8Td zcY$8C!Es5NtcGW@5I|{2x&jY0SW=UsiZoWyPkznXA!BIwH`i^ss;O$G&YE#@yuAOJ zF6(!T7WIaA;j|HIg>()LJ3{<9pC9cQALK&pBS!!h;VOEfV|9kw8)LhR1sR6(2pZ`< zK&~CCjG8;rQ%alFtrkORb?5g6E_nC#oQioITga#Dj%P=@&mSq;DBfbjwfr$a?LJR% zrFd#&mrnhukl)tdXsH@yD81Gtbu+VFPA@TadHHe*+-pZ4rt#}LKPd*@q1IU{%x};9 zLE-~P2WeQdt+(DS?Ov@b7QA)6OEe&-`xfOiZH+CqX6H7e|CFc{Pq-eXHSw6atGj%$ znkO89)z{qd0l72 z%pq_vhxOzifA_1Jdw7!H_^DfWeaToXlP+C4zB5sg4vW`%Z&M9_xup6&waCJFato{! zWvU1ql()ZF9(*#Gab-X+lqJGEa*+}Ax+;`wpir>kQ^X;L)w}fTw+6Wz`4g2Ob|=Wy z_v;IvN-%X#J}#Sn0_?<3_xrru?HR{x&@qEz1H>xbCr$%q8n}1b&8!{P*)DFcn4~Ra zghc8XN7QFkj3CHt&b!uR;l8$9`YYjX!NT>jXzMzZlL`d+9fC5rR-P{H*kd_;8)#^5 zQS~+q;z$cJ8r=nOfv8-9>zpAIHH8Ye5?M9aPv5focS=VTll=-b?y0w7ZsE==d<9Jx zCr7Gf?GUTPm0dW>@!Bi)qyzMi#Y5jID2qye@bF(PNmPb`;tVfd%~%NMK4H02KE73# zxS0t$GrZqK;#>sjv`CZ_N4Gl1CqyYqz|!C~z*_GWX$*LMsXy#eOG9!~)g)?ahwkN~xc`tN@M75e)@ z2ezX?$Cv*RWcTDPr6EkO-TD_Bs)bXFC&15uzNJr{%)qGv!(2lS!DpS+O4WY%SFHP0 zvY#_we^GErYHD_+*B+Q~R8XLMhXl|yhKo_rgwn*+#oOTSbRC-O!fj~qKa2HD)OpHF zH!PuXzRAbvK>5pI)w|q|I>y+7$`@lz76f?hvmNxs&$iXmV!d4xT8$H^QjkeWO5Fe4 zzLc9H&K}r^(%mER&(q>ci&6OI z;}N2aSE?64U~D+18y;Noql;-aN|92D2bzg<9j3F}<`h+20ZCr`_p-cEo<_t#EJ=&G z)@*>;k)A&%#mg?jq2AQxX9v-nzQ6%y?mNeyk|((~)3sPOr2#P95#h|9{tOr@>`TIX zh{*gS;=6!A_CVoH#&3Z&r`(Rc(`@rk2`Izs%6;Nso&4F|G?$(_@88>-w)S(pUg-$= zlpv*%7Q(4@%vI9F@4;%0uk#S389|QRgOfcjozPpGvjcvmr&bWB`mLjxou_J7rh)bk8_NyQbC1YW}&4|LjWH>8Al5O~a-j zbvJIT94Qr52F*cU<$Q>s5D2X(4K;vzpfgXXJFyod!GAb*GuS?84bVw@gk;AW@9YHP zXi5Ju?lI|($~Fs=`%&tyb5-x#uXQ8;bFCX)zMzp?yui8M{;5w53As(9;G-=#w6F%1 z89d&VvqGHZ23mDG&fo`z&GrdGgJGR#Ggx{TmgMgw%cf5tw4$$RvecbJ@FC_pL zSQ=$+md)9z>9bB;0Qn7CAz0Wu1Gb&`|5 zMHB4~9Ovo91c_cCJ85V%FgobnUHSF(ME}b(S zBfQ5fG7Mtxg9xn{bnk@#U81c|Y=3S(>+vj$_>|AL02_4W854bliP6h@No}?EA1dd* z@z0WU5{?s*tjdUK!y~4CZ&vhT+yCN4@1pbmz3%t1mk;OSn8=Fml$UM}Y~~dfZ=Br= z4NQb2ZPNa!8AHqfR;S%Q*Xw38+`Kar-Fkf-;8-h{g z7>~*JPTBYIZI+BqR#C)VZ;=VW3hEa_bSo3S*nr)Go@COEH(0=98q1NqAk7#>ZpF(QH$!;&4O8*JMA)X}U?j4?#K!y?))`8w0#@GC3f~dX#C*;b z#3NW0=78?l@VSjTl=n4-T#1o1rk4!QLMR^0()Cx-TZ_+U%y|Y{9lxBRbtlJ_aX+>0 zcwCA4g`^#?XM$nv&@pVo{n_Z)pY%JOZeFl-;ZvVzr&9K zBUlBe(%<|TT>1+^i>9EpNu?^&Jz7gEkvbDCrSyTCE#BFwP9sS-0hF04&8QCZ91o8o zn>OiPdy0C0>j;c6+nxxcF+`A^&g<^KeGHwaIQil|y^utH4fj=roeLuOD!2k;9&kH~ zI)+7YEqGWluDr5f$M6W7zC>*bn_ccQh#7Xri7eJ~?c{bmk9&WKXV`Ys10g0QiPbUMcMDJ2hXtqJI*)mS z?_W*6@`Bq)Nlj6$V|qDddRoo$>-+RK<~?)1Rj;@BE=_^;OgeYo67DAV17A)5&sEP2 ztuY> z?3SG=owJ*Glml63ZaaPRWy6Y1XhAnY;6JXE=%m|v`}7_MOse6)hoYl6q=+6n?S`;t z{agbWcJPNGtTJ2sL?MoWp4&!bInogZq!xd$qM-k2MWG8lu%gKKk%PC)Kd;;KySvbE zazM9!;3b#2zk?jVuh=!*Qs}{)>78a*moB!HN#E*fp32)im+6`-TcP@g6L#W-?2lquo*yj4i3;2?*MiYt)qC z;FU;UYdQz~#;zQ#NKAK;h1W9hBS{F#pFaW@|Mf?Tq<4X7HhWp!Fz18-cGxx&b{4C{ zvVVOiYPV&rdtAlYe;d1xA)i|_4(7*^Y%qxx%z0TST-{p)=9jo{+J#x}2knCPaWa>i zg8%HAkf{_c{A^9>;A-!N{?QtNuLeD~?(5ie)QMn}*m8?@`n9XM@k<-PU3Y}KER^Kn z&qSyR49&wczxZkrCRHE&E8%}HT=$xHsek=IfFLRV`5(bHJ+u~JCx#k?Kv5nKdmj~j zy{yai;Oy2sdT!~S|E)=n-%-P?;}vI!Xlx0v(GjfG7Y zT-2qaE$|Jh2w`tu0l*Xd@tXEKxe(oieJbf|+e`@oRT*B_zLk~1H)Q{nvXa^T;(Pw@ zzMBK9_%`idtTsJHQL;bEwzI%K@r$pfowUi5?K={E=hpUy8>;*6Wm?6AVlON>Tq5eb zt5Q!B{JiH-W@F^`UDNljqMj2Z-QB1MFFFGt$aeAvQnaB-;_5q^-ux+9^)Yy$17X9U z^XsbWYVc6eJ5?L}o*DGOvOs)-OJ7wSHOw&XRX_V9;l}{-3c_KFWu1N-=eAkg+A|9Nwod4QWEAdss5cH|_O7TvO+ zt#Lyz4PaIZEw2>s99f`qPoCGv@tL6StP?oHt>t~Q`=~?;|x;& zN5bC;^kjtBX05iV@1HigS}{*xRHSzS}0TR5wK+|e2+ekg=ci6w+d_d|%npHPhvfQDSfe3q5o0|vlW&!UZiDMLH{OG6o* zp9u12e}d`caZ=CC3z>*egjbYGZThTh;E@d>LQ`O?#?m#wv>0eoND|(hh^fF zoHdtcV7Kkqg&GFGI84iJ>k@W8Eh^Ec;!iVf}sz%%> zx4|^Q0?o0^8LFJv*DrwXc%Gg;f>Wb%3kGBTv7+=Xj$_+HYk=dNf5NLh(ggpSD=PaU z3ioP-W=yvm9Q~M-W3Tj~bLBYXKEFIlTPs_EJU$lfZM8i)opMvb>b&}rAsm)l^!R1% z@o=#<)?41M#T4tl-G(t>_#@uHaXulT7yi(;lCsydC{l_%R_sD*#{lMpxW#t*?w;9l zGd@oX5=s)W4CVZm_L~A}f8>v}ADBmIcone5k6*knnOEK|cEoi&>;~jKrsHTWqb>083$^;gO+i} zs_!l1qg8)w8P{Jw2KJ9@$1CvLJ+qluyGMQ6Hz|1<*n>)25k(n~fpOFJDukBt4B?Z% zw2be5Zy7&M-a{+l$StXn6wWL#BMJ0e7w|>`J>#Rds^o^K9Zz*UYadseZWx5ns(j3RN`6a6XL;sg^ zY!&`pW~_j6Rn%RAV-K7{2eZ}=S4Qj+TngL$fw@``SDtGy6#u!d9MYbdt=>p`nFJ1)sTWf)xNaB+VG2%XoXX#_f&*+nyUq>eu~^X$e_M9 z5v*);mc7!BqpNc43;|bup}{)vvu^ftDa!NDz;EmntZv`+&fq%SQ7KdNN2TdL5>T2- z2k3=;Q-Sp6zA@!uLj!d~j~j z@_lus+MWTn1tLS+TIlHLke-WLjRHOg72Th7r|RwtmZS0h22NLV)m#H#Gwusv!R^Jx zb*K_Osii%>z^PRC3sVHhCT-__rI$hZB$4fys?EZ04yeI|_uDH`N4(R#Izqn&MdcMm zK9Q>p+ed~XUaJTlY_DAcK9`JUocm+OV*^uDyHZvtc@?DHn_@M zt1Wu9L_INLax+bp;rs`~<()EBHBO{qtWHzl`8K$+R^8OF_i2lBE`(tMeMsr1o#)*< z2B(`VyWme0T+^^gb*QX>)w@zaCvJ3Th#*bmDrgVO33c(AxUs$l*;u2F0CB1FW5y#@vtcGlz6H%3OzqR#Zi zyF6LO-}tsMRVxC?&CgXJ{k`}yhhF;ao60dp@e;eUHY7A;I3?xiD>kdG#j-!^8zZr2 zocv4MCThp|Q3&e%2d-C2+!3TMhGY)?@yW51l+ZWrZyi>k^a}U0ce??&e z^cGSlL3(zwWp@oG3AJY5Wq8_K?B#ZPOjQ!l$%2mMgu#`;kvi z1#P{pnzNZ)rq(5?diw%6_E0{v6Z^ws+e3UW1|Gg~NKL2(`_;lNq`%yHVIdMNGM|-{ zo3WE!#4`yJD{ySks)1D?%Md?_Ef#<{`qhDsOd6Oocp)>+Y33mVAQQhGm8s;NDZ?@q zlwKY6{=kK9+*WAtloNjvJiTF{@+CYZjB?K9L)il;ujQv7nKuU3{ZcRL>FEqd80x9fOo z&PH@a0ZRh@(w>y9AuE{nI=$irK$Yb~;QPsfv@$6pgqpH0KiAhySm6J!fEi%$L}Y zbU9gs;Q{yMOkjDE0^jv`P?3aIG5oxHdg5b6-0kfX<>4eB%awGC{F)XnSP z*fYyvdaGaz?NMR`+p{6^u{^ggwqX$PRJLi(2MlF3M}qP(#-?`7CUBiRn>AW zxl!k*xO^@zYD>FUtN5v_tXD# zPLE77+{KZuyNd35>I-`J#L-}oz?IaCEEzXnS$D1~+Ihki6Eiprej1fw9x=jOTW#VA}4v-N8=*4Ve0cYCMxfQ?ftSQQsOR z1*CJGF_@GMviZ9A(ot46%$*Gb4&B7 zLBlHa^@>J@4LMT^0V5jk#AhTai`}!@$BmDT+%T_-_Qz~e>Z#2z3Bqm<~JXE#QCH@J6Po)?ZC_2NR+ z*jZi3Iz?wN;B^Xavk>*9@P6*2DmQM)E0UK3i>(3zrBmMAc0CSA7yAZtX5f)tAWQ!% z%csnN{?)4INOknH@mnr0ofCJmqX(uz_mJ@0;@@c9M1a=i{Xy$00X$?SVT$sn3Hi#f zQ~Xhd02fz4Zy+r%aku;}<;SA6h_(8tsE^84w@Vy2I0<@2xACgjrP`jdbEmn5Um^{t zE~OlM73v@%*c>RRfuQbDRF|GI{C~vctzY&Uh_diu#0NB9#}8aD0KJ?=JxkUCy`fa`3u$dZdXus_#@MaZQ(mk@)_J zzzew3(DuJwG?i`a!PtTtMYySA{!BT${zQ zM9E~0P{0MJbG)=?n;>Ve2ZTBeTkwJ*aXe`=hDsoHcbKk7V!gk(fiqyKl6H2zzG|RS zxX)l|J*c|oq7}PSt{*ydDWHQAyJThVy8->cEYYd5>m$J~y%>%{KL)E%WHn3i*z^kSy`|K93@TDN|Gscl~x=fdBb1dMAUq zSaqN8JXPmUo@x!?sZzPKWXS70R;3ku!IIZ?q$b&;82U(fKMi@U*mC(zdQOnLAiQVV(j5Kz88-AC zu+=E>*OQyjisj%;f=88ZTab}YVjp6w!7C@sEFa~4Pzpj{B~wvQaTGWH?t!bYd%ik(PfGy^_th z*rEMy6!56BEd@Bs|G&=r->UN-?MwUaZ_LQkvmei#_Vi0tGLZ~AMItlIz>w727A#3) zcP{rrPf6iK?dDCdGc{y!D>o;_hM8uW7^|X3hhI|((YKO5LFdFskWkOwx;XIZSXxhJ zP~^*SecIqsl*L|*%-y}f(6Qp};kIq&W+hOsj}TQ6J_ZUQ*wuM@04dc4FJ zq@e-C_NNun6GY;$xi{wh*OS0zDM_ry@fTj2E({^uu7!3PH~M_*HV3Ltr>v*J8N%Vk zc$+&&jf(TO2Zic=HF;~VV{BFne9^3_kbL6dfXU{94JW}hG*;4@Hot!LvaF2kZ3;O! zKd~*&3kQ6YN;;rT5EsM17!pq`iKoO)oGxygHSpu*r<;O@xDd~`L63sYID?fep4d_L zDJt#<$+^Pt$Lso{j9AF_`EIKZTtfWQU>(Hm2DLKg0TUG1kl4xQl=w7wghet`BI{zV z^zFxgIDj@23eotn*(QyJ$#N z%{|{178~k=jEkuoJtSAj=|{djaq3eZkbWlP_Bo5DO~=T`+ta7PcuKynKE)IJC5^Hs z+(}g-TJ*(9pTR;N!{p?PL9AifK3gCBroLa;3s%BqA-6Omk}o$-`Uu_yq1#H?nW2G&@I!x%v^4MWn`_a zV^o1*{=|{d5AWh`*TnUSf4_3Wxc4Pp`Sq3Nex+bfJ4ms0(Y{2A>6so@7_N~SVT<&U zb&i33dIl9#h78C@N0(o^G9+yoWWFoeq|@gO*hUl2sZZ%v3z-rK6z+|OQ$t(Qw$pJ* zNlE=(r+&{yE}pko?Yf6;s}s*g8DXd^Xn|)){k05i{;VG^EGd>_S{) z_Lec-RcZKuRqtZ|^T}BX%iiN5ZEIFt4?jlin6s*6!=2;V1tP_rT`=YPwN2_V{m)zb zQT`4cAZOhQTxlG0fRP`_#)Z=2+y{|&poNi1c-iQ7VHNBP&VF2+?7nG3PnWStQyuxcb=1#E3QiVJp6ezt{;-Oh2m~fgJy@b+%%_~ zhH*19q-9P+k1EeqRh;2w-Iu_{<8Noc*mg%T5(yV#m~0F%a6)(jsE-_9~0S)?7jBaRsAE zrvco2thlN#QP#@vI8sNY@UC5Zf5o{FcJ_WT`ZjAfs={Ff1|B6!8mn;&T#rYZ!mGqh za12asv?R|z{n_IIk=`!$2f29F(jKj}bp*{mX8`to+;wr66opLX=Xm8QIC3z`E-q`X zbS@Xfl#+R;2`Ay5U6U5LBiY0)o~_ci7LJUg|7~|c9b_D1$k!A6-raYdPm+i1J|C^6 zcpObeWm#z&?}7|$!XXYN8de@Rx<)@_^^gwVj<#E$!@w;zh|9mhor2C|a#N>(k%~D> z&Q4S2Hal2EoR|NEqn287LRH^6GS%K9Ae~dcDn)(vqn5_iNQ7SxCrSCEJ&=i3jn|IA zx@Q{s4sWVu+Ac>`O3Ey}Uo2ws%G<2gH~H&_^qA*wuBt*x-&ccjl6PKVt~4=R=ELtf zyezg9l7cZ$P1pLTM6P##VZH=Hs^PMV;jTRNrwVPAP1su`AXYS4X~g(Jh~*{F4?+Cz z8Xl`GOqpokyq{=aVt+F1?eX76mZA)L){1nmg*jPl2bn28?ds~Xr)>w`7Y~0eOtWKW z&;)q<#;!S?QLD%@q~YP)p1nq!$&ECo_)89>7@5Ou0%?`(Hofg{Cq8g@(nyp8$2ItI z+(O{E;egF*jOT#$9q_8nWtfr3-~qk;%VQ0WBJ4K;HkZMMtrn9`K#YY)B=kN zNS_m8f(LkFEpj}Jh3 zS%b4}B*z*}A3&Ma6O`}byySA8IlvcKJ6lv{7Tr)Hj=pt2*046PhCgb3#g;-2C#Sb9 z>~WPygaWI;jJEsL2x3FTchzT4fjf2bCTV_^p)uJjgJbU?_+n4h;*uu8u}0&~@Hvf? z^ydt1OZG;-?#-f-Qk=#DO}enlU7So35m9|>98FWDcsKnblWR&Mp+IOVcSz%7ELJbR z-(k05!FSV?vaq*CzEj?IvX(EVvF`Jt~I( z@#oG&gsYo66S4=PoA?~{;791m0YXn%|HwN;cSk=;($mw)(Zz!zO2S%#xwtnoQann; zUQ)vUz5v+zx>!H6T36>`0WDuurpxs+w;PIwUTJeFq`ZHQulCF2mLq9Po%gv8Kq?LbQ(?eO#?d>me9?1zVu)>HhONv9a#?~Jx zz}o4W=4QrI#rWMurh2<_?A2)Ll&BbeL-H_^$UZ+9o_^sokJ^^^cLCa?k;Q}D#FBc* z*Lk$Ct;Th0>!#swToqwsnEh?fir46kF^c&0tDJ%>bzh2*W00!)Die8p1+79P!jS)n zS`TrHDcX&a-U^c5D*wVKz9iiS+cDYOkl%-f?)&c)&rIVXw%7YE6~Y5IuzRw*Xz!~# z`$hUBYVE|owp12=QW{n?BSmJWeh{@Fbg}i^t6mMKq z8TitV@a^<3XBMKp-G1O?&~Tc9F4Sj@|9H?qo=)Fd{4iL!A+oE>mKO8M-)W_W2@-VE z5VJaoJEsUXs_?Cm^);y}H=btm=kH6_K6v=$ z%P8Ya%ry)3ImaDE7G=3#XD-C*3z8(2ig`$UPqGJ?SkJ8_XVXH8C5vFITMcI4=Nlht zHn{lGv~Nf)Ev8kZw~uWo)#8J7U`KUVqahQ8kz7y?Wly&^138UXm|qpzG;3_4CAlq!yF|my;QKhHCrr z5M^IK{&-Ho4`-}xBTuF+7cD3AR5T2Xz_D}#AtZ#40b?vglaZ_Lge~(hY@eI6?-(0` zPUp+URE5l~ttI<{r>>evH+bK$@h;fFtyMa$!QvgneL*ws+ZaL?)rHO2c1KC(sz<2V zc|6dEIXCEy`=INM>jQi(;nUE*@5$AgM*_$lzQDf>IuOU-*8$?QIrG%Q=NX&b9d#*~ zQms+dT^2(~?aiasN#o|k;DpH@W~5YL@HBu)RyqbW%ptP3FZ(psE>wkd&F9wa#kqs};d<4!8>&THZT8a><(+dXL%i1VydI3Ccc8 zu_$NA*{F74ztL6#Yp9eumw&l=z3okG_@OSS!5}z^oqSf|(5P?snsnA>vpGtpN=pV6 zac3_Vio$aBNLj0X+l*FIJH7KkKtQuPtrTr$@$w0f3#D3EzNrYD%mh*)wqpgUb*6Ec z$Z}*E-m<=jRb6SP|J^iXanN3ed4b$#166y!hbT)~;W=>{=eToKNRj>>g!&zXu0}oQ zzQ002dWP9xxa=j^0PHOL#`)8kL#(~}?EQ2qX8hAnJMxsz0Io4NuI-HR2JQC@)CRnU z+r)5Oi`pBhJrsyHpDo?7*>^=T>6GEC^YOgLu?tZMKb!TpjIz|DSGCm|A7;4q>n(05 zc<@Li(K1{$h5?J>1gCUB!U~%&DanqRE0H_lSKki9ps=4WuJ*RYE#)!Y~DR*N-RJF*_+6Ja2cVtu#Tb z?vblg9@aGve^Ox#@{ufd{>pE8{#5%yA&m+Z$S$$Dbb_M^6QLSqS*@pRGtHVqv z3P@6pgPbU)!y|*$oOhb^D_aq)1rmv9_=3yN*H{>MjSaM(`?hHw)yWs%-EgRH^hvOO zF58H|oGSCahS_8-Es#Z$yVJ|H|p|@MGJ9XVFl$Y#?T! zazsAW8(j{h%>AKq0EsM8rIH+x^u=GI`=88$J?)oYce41=#r zJW{U^L(E9VLif0m-TSV7=(r=tGhxLA22K9|s z(GoWu$C&peeX=H(K<4anaID(eHPMJTS@w2|$XY>0IhZp|p|5%S&>*Fqrb}|Ve{=wb zZNPpy1LwIbsLi-6gZ4W;ur|G_x=B+Rj(rDmHx8Jg3vxIYzyaI%!frQhb?}&Hjo5{Nek^Md6v* z%Z}(kZSvYxF8C^39EC7nEtE2=xygn8Zg+34#sG)w4Gm~%R8 z`;!YD+BmcOx%W#Ox~X*T_JzI3gXiEi4&+#k3hDl<)B{)jynuC7!9)_H27Vu2ZGe}K z0w#nK9tn3DElWG~yqFgQeRN+VafdEpRu=t@Jds_H^i|3%2*S7O7dh57>Xo*Y zKAXoU^M-8I#l`Z53;F*hr9f>79_%Zh3W20#;R~ck-i%?vD$cftb9-`sGEb{-_`0Zg z-_*shc_^p|CRGV4uJ043&$|45gvOymQ^$e8UQmaVY^S!Hz-O`x5N?@g7uMXc(5R1t zXPvsnZZ9S$CfCz_QLr7+aPJKq4WaNZ(L#>Cl|{H_{&>KTp9V`NGBL}<;u%Z|&hn^& z5FBcjG@diFD^`^*{$Q53=>+KG?7Yura0?BYFE4$h>Ofw#ubwy$V%??c0rJZb!m|7W zrexP2Q*ZI5aUI=~MiQS07lZ8^<1l+lqgCZt4&x*z>CiX#OZ=u&OsJ>L=_Eah_1 z^zgLGLLJz0<#M%^$8O_}ef{X#LMC>s8s{E|@^0B7Ug}3J3OdZk5Uh8N7ac4hzE3AL zy-fjpmc6hisOuRstjseUz>L;@|Csav1IfFrz^Z^e1|gLP<1NliT5{XTRpvjhgbqi& zDXG4Tevv+Np}c^lxuCPT$L8Gn?Bko&BExnHgQ?qlP9)f3#s>~v5PWib&2$(5OK6&X z15u;8ZZm&!jT6*$HhA2stzU4Pus%dvY#+ee&*?)Vm#s}N?OAM8F1WtJ{)maeP`nf}) zqF0uWE<*T!4wN0ni z4nLV7tLtIq!wMC$acvCIf5{oXoJNaqQyk0f-xs6)R2p)HLJU}45Juf)&!DT zUAltc3z9$91%O6lw0!O!FZF!?Aa;6b|6T{FfX(1|BMliZus9u;s4R{+rfD4w)i<1D z(F{Aqhi96eCu5i7@RhP5qrx`Y?hDY9Y;}D(8xcm;#SIPRQxeh@%aL&m!YDh%>+9-0 zHV+}HEWS#x3N~{Ck&^7yc!7+Ij;5q&XdC@LbcvC_QVqG{X;UGc&~XB>QT~eJO?L>^ z?&%jNWT3AFI<)pq1idA)Hs#^hmA}gryaEQimTI>Bft8zI_EtnJN|u3%$(T2T-^TQ{ znNNta3nd(l5aC=u+V1RZE*m@=e+tn%5#Yqb9-(lC{GJx5#*QvR&o|a6HSKeM`@-sv zJX`d{Y2RfzO6QeX{|Ua7=1aIUG8Z3R&*hL`M(2%e(2?+(YnR^ln+orLz(*&Q#$#3s zfWy=obUlvc>HMaCF@;8gY3-kjjt0Sn!<=MfTOcC-CWZQDqZJh82qRI+);O=lEyF-! z{Hs^E)iRa;Wa4TrizK#Y1_KNeVW}T3qiS(Rn7FEdgYw5=Ww9GY*C zboI|1_T}S<_5?sk!tPHJ-S@}WtW+=O5jvMn9z3}$Q>-hM@MdO~L)B_|EaLHY+6M%9 z<~ky6gSVihz^u82wV#1d^^{rAlTW-H!#29o_I8`Z@jLE*qNZ0~~Gt^9cNACS_GSQI_C2O3|(rbL->iu$5 zt#ukPysl6IQQCg<`nrgRi(5ncCK>aLe<4++nL_8&;1$^1hP|j5$1qn?J4ziBZX=y| zo-0{c6vu!^3FZzsyXo^%MrIO1-8nshA`9e_Fd5igUDBjw6IWdiJrb$k<~s`)1=H3DE)XGxLx4c?UUJ?+McZjmn{o4L$7m zRvDxe&NM#%1|w|JJFinz??^*^HhJpRBWyfs*m>`beo`5=^jjVJQMW2R3-;HUJZ6F$ zochYMg+8c-r~Mv^M)~lnS-xv{FL>IimkQw;_@j__0N&Fn)?O)W#L{^w34nvr2L-)@ zs9U#<7w%=r`g+kOB?T=~jgp>4oN{H9h&~NpFeYXbAIWpmACYvOqdVTOybd3r@syIY z%N9Gx2%2xp6N#up9?@5bil|2!mtG!#5r;mCQV_{5!pDzqrREL+joI-yOKE%lVB%4{ z=vf8NprM&ssL(ssR3p~D1%--M!Yw`^taxi}0 ze6rjeAQ{Act2i8z79MVeitaHj9Ip42lhs2w4jc!v1acbWVsdc z&*!kdmhpT@3pIy>x5lz$2c?iV`QJnRht!xTS6wSp;Ya0^4@ z-oyf5|8@SioVn88HP}c~69a_Hx68P| zKwH_rlO_bUFQoq1$&7%ftSu=;^%!Hbo1Ud$c0^|VCdxYM#YQ%1k=(kJ_IcOj-ELt{ zmFm6^w%e{sm^JQl!`Y{YhZ-_RJCJW#DaLn}5bZ8vfbLSnK^RQUhur)>8Hk-1n z#giNJmdBp-j|9-}I%W21Ipx7^`sD@|12ay29g(IAyWkC*TXViV9ta)VH+vX3CDNP3 z#yes9GhxVhCYAMHqzhGujn2Qx7ph|j0gvbO6Y1a%R@lJ4Gq$!?@C(wI^jpeb?bek_ zS>4Tf_zriG%h~+aXUPE|C)bcTrg+ILL6QiZapitW)RA3acW=8BF_);-ntYj_E8_!8 z^-bSgVMXqOf@ain)By+GaDsyFqq06|%8>uId7SNU#j+leK(G_Cisq47e-PYr`_sRaP?Sr}%*gh_?K_|S6>KPw?BMC?De2iVw8j2N zW7D4oH=-|vi+HR{ttKmf3a)(+9B@fhNY!%dA2SOSht+@#7eTe~N&`Hap;cP*ZkQ)k z1@Tbl$s0skYc&h_vqpMTu{L+9y?)pzswkalMu7kd>Hl3~QIn|l<~h57viXEfYsV;6 zbpwRN;!)s^s|CxQF{btx<57;DXH3R;<33!2>ONNk3`A^irB)VFo1{W1=+@1CpI+cR zr3~J8?}%skjxqS6pS4B_7RuENN7|#ooZ|_13O(xaIu5<#0wW7HjnqLiUJw+1+%-w` z;{!jQ(s?54;*kW@OF~e}htrxzbTqEb{)Sq;z{AVy#Em`nX#fFcX_jab-G6(si}SdI zGDXiDWK~kvHOtan=%K(5k*h-hb}DEG&>G1uEW)A@8>4IkYo!w8_X*sF7bqL3Q4Gb8 z2RRBRu`)`0^s9I548Ydram6sNqqiB|y2_al8z0$1=3WB0WS70b4_uPvrD;}FlPnWl zH99)W%O^xI8WbD)A5A7|3*I?z-CHnSM%Dg+pFBpK)}|V9jXvE{`Pi8~z_)iqXbO30RMBSnUMH5k$a^nMr?ouaj7U{x6)4_5*xhkopvPpJ%ioww(c!V=-Z=5e-{rfVuQE3U9)ctEaX3;cSI>i`gmFFF8n z-ZJgr#zXK)7d_iX_)&rR%B%ey1?6) zd~myghjpvblQ!s$&5CLb8m+L5WU==5_V%tM4Qb4qrWY=PFWoH?7EGIc~g`fMc#I_Z(LpGhV^^(Ms8xTj9Sxl9G>=&ky1K!NMs5oT|}Sv|44T z&Awe^zLtI7RK(3{+R6uf4>DLQ7s+_c-HYA=AT8uacY!U6mzK}A=^$A|?FSht!o)$kvawNG z`B&aMvDj`k^VI9YqRA1FBhs>k`mipbjL^YP{a+j6IxO2s5 zu;Tqoo8}UkvSqB7Ui=plo~w|jAE!b%>bw}G11#jyE3Jxdz2&#TX*iR5*E9Qvhci#l z;3^dJ!`AahxF3w_`I^8hGoIl zm&Ed~h_Ab97a4yMZD05o)jLJG8Z}y47aZV8>%*vI3=~oU%x?V0( zHL=-$X&~;MXBIn%(sM%%2Cud-HwW|~X1H0|L;K!?U>#N+x_AB#U-u=9u;}85)XI36yaI$FHbXk})KGm-l?>xFoe2z{TPlJtw@#pPA+TaWQ zbXxuIJ2-lKBb1*Q44t#gL2f(^iYs4UTzW7V-Y0X^V`%UsLc}Dop`?}T#XdskJWu9c z$9iRN%C4}Uq(5p15q7)|t2cYY+LSOy9)9I4khzpw07V+_ z7+P!eh=F3)Yth7GDCXOM3bu!2hIwF-rCqOUC?Y?KgGRoE#F4=3$v3N>Y>izR{Lr4>vn2L1US1?B1(=qOKqR{ltyH4 zwe+U;jGIKjqnA~i{CU@o7rRq;&Jp;nRGC4kra<3b-1KrkJ?2&8^P>c2?X~<3uNwRP zByau}Lj9MX?%-^{bW>ENZF8aXPH2T>gh`c_|W_ZPsZTloZR-}QtawXjudi` z2)Oh3fd8-BrsknOqYKpTHV)X zLF2iQq&%}C;iNU3Ys%}>=+beHrpR7YN{)K2e@Y_S0)gz1TKk?Jd{qSKK?`tk3_K+c zjPPAuotl_kVWsna?93K z=X+6M-rg|G2G(b#sAsBJWG|blQoojgQ4{9-ZmSzR4s&K&U4Kg4yuG4`gq;VGunPe( zw^~TrhzAE*-eLL_h?+e)B}n{w%`4zlhpvtl`P=V5uwuZcwYpm$YmBz;=CY8na>fvALSk6v~bqiMAON)73kf@3oE zA$Aqm$}~p1fPk^lav2+6-Cail@P@%SqTgDve_eJcKc@^C9OO6{ z`^B5*wT$aO!fw%hSN{=qV~fHh`PFyVoQnc-E(!ZP?BonqwporkhXKI$&otc#eOAQZ zAa4^I8J|U>JMDuPD`eG!6WRI1a11i4EsY6>WS#kX1OCF-U5D6ukwVAHp8*mY?jI+1 z3_yx>0bRVN5rE~9QTJ8VGwNoxRv?I2!XcitP&S%x^&+}aXjl) zB5Mq5C3QOgg)B4ke~Y%$QTgorypr43$oTQg1J+J=Y+t%bCez8qBx_+kJMtzLfDP4b zCvV2II#;8|HJ0b$22!f2Ca*@)e2wdk=FBHiwS)fv#YL1C^BZ}#Sg=_n-HI$_5Fiq+(m-q9!= z3f;8L4hY7ZrSY|8|A)Ho3}`BAyLHBbV`IjOpx`Ki6{JX!5-TWDWRzZ_BE1PHEkGPm zP-zO%OGZ#pS`dVQl!$aG5h6qgBtnD;Ap{6%q@24^aD1nH_kQ<&f9@ZD#Bj3DuFqc2 zTI-oP`d|$VoA*D>Xff&>4k>S)MI68_l{l5JqCnbJ zIgaz)y5?1vZTz*Vi%j~fz5GFHcFD=GmT+46wWz!5GaI%!E8gE!EaFys{&S`;1e#r! zP^#g2?XqoC%2~Y6tW;#zD|IJZBcm63yCYlssGps^l{?sjmB?ljhn^Sq7jT3_LSWW; zGR`zVFiv1e9cdn9sP=xwcf=@68aJh6WS-n*Qevqw>Ka{IzOD9s&^#z<`6o_FTVw~z zEU<%1jW54R>h@nF)^P{GwD!a1kh9qrx~@{kI?kt4`=qM(5~Fc7k_&mkDgWmn&!1QI z(H+$%I|b!-v=50D!V#&8vinQmYd~Eo&W@>`-{Kg9e!&?HmNGQ?xX5>4-@f( z^_dmi3V|`#qZzq zdFDXl^)AL54lr!vLIY8eQMuDJ zeO}0uMPZV5g)MiU7kuZ_XKw6`(7m3>d)DzMzfd8>j{h2J+01VCCzdCko`-|5Dn{CwDnax|}shOgPXq+2AkVc4it;!~SbB{Hqo zBq_$bBx67rS&*bBKi8-5qvO(ci zeZ29utc;U1kBvE9RxhpPeJWJDuB>;aTGhwrSXw=s2VFuG9<=`-vV^0iHNF3qzRObg z+yT&tI+p2v$ryn#q?gfdp&DqOpy8f*(p}Z6edup7Lq6$T9Db+iMM)vr?+4LbbBhBD zFQN|X6kXwaoAKdmCUH{DJUKJvKdHeFOyqqBv;H^aVC}#V(zgspCYTrSCt{92BgBm4 zc$p%_#P&l8dNqSlL-SlhYLb_!+Q)LMQ#YP9nkgJltoRwvnD(5!+8tg(O&GoCL(XTz zN_}o%3#4D9xV#uBxhGM2CH%>G>rZMfxLLjDxBtcv9st6Ik^ehJaQaVTxXFKt6sYO| zhDayNdm{7p?T?6}sD zl9XlBJIq*js-C_`DUCukCJhb+h9q#!uc(IH!*hD_b|)F_SJEOS;!kMbjf}t-KXG3a%zDxBLLmijQls_|yX_?+ytj<=yI8cKdhq00vjK0s014fPAxSoZX{^QJj~FDkOkTQ(S9X~YdMv& zV;}2AiPz7wt8k|r?+WgV5j@8>Z}9%~WZ&?_@{%9bz$NcrNWSidjHzEq1UJ+DNskR( zT0}OwxTKu$%N@P|NpM7`upO-GZUS`(4k(Nqj%?S@WgV~kJipZ)d2pCw-J2CgIb^-1 zhk4i#i>#_T^7@%swSHIubA~b*AUVA;QukGb)>elvs-@P;Ln*mRo&CP^xw#y$o`s7i z-$W6aRD<9kSSg_w7>$mY&6Liegk@c;zrqNB@~`NV50&QWGfJe&Qk)_YGdmO4k{)_C zQSD54kJwig#ckiY7RMxIi_u1UsdXwM%K zU$Zt|-Xnv|zXuD0)0%(AWPgf^#;eHsg&MAzjV{VE7qYJ8!}P;cLQbw1+s}xQX>8Qs z4;AtBll0O^J&*7b)Su+b;@pjUrX!Ji`8JwznJCjnK>idv?cv^l=s=i zjLQFBPSo51;PFd5zSbz|8RsoQ+*|sbwKPp2LePnPMMq*MDJRgb7DVFVbu*#PUnJG< zhw*9KQ+t6fr?=c*SVSlyXZ1~U#!Kl=SQLWfPM#zHaonF9QvQ77#2L)1)2d;@Jt*(V z6C0~6o8#bpTBl_7n*)|joCSH1_wlmvkJ&fRuXx-gQoiF=npBo!ZPwCn1_*r>8jX6I zjmMn8*-T&tx&sYU_)`W@qBE?#k;l5Cr@!GAAI zfVqSe{j-LMmny4vPF7}PT<^*wCSM7`W=fH*xR9LgYkb3~$aG^sb~u^iBM}+d)BXA3 zc@Nod5W}H-g)_VjI-AV~gkTvBUBX}az?bu1{(gH0mztue zTWq~vEdM4g$6Qqs9L+HrR><5qkM+)l2`({mN~zv&u3V5?dBw|oheRknxegi~vt>m9 zlp$1gQB3q;Wjx15^#7_Q($Yl_{6oATHNWAFcJJUiq|A$oWCBp>XLCrCjaTO>hx5sc zGd^tvJCD8}-nZqEf$g0!4p%KeW9(QT^Ne3{1;dPw>eF})H;=P4d}--rbt)PpQo8pZ z^p$$)9Gvt1&D&Mm#J4VZ^}kLBAZEv7*5{7hDynMFH&3};X%5r`vu$&$ohj?nj?LZz zG&twq>z0+0pLB^X$jL|JaQ6(BsmPGfzvN-dAbMiYuF>@ey;91kPH*Z;5e*It>;QWh z05jcYN>g@T+Vv%`q3~!vudz(`|0JMLrtMPj`V`Xs)K=neU_*O^kt>ud5&s@p#QCb(HTZ(tkK&QTX@gdqqM|(L*?p?( z0(MJi*PaR4uPmwCIL3GDS>N_FF=adB?bxqb4FD8+`sX_SF0gRtZCvwRhNBGu=-u30 zn1$T&|5`;rCtHT1(wA`POzdvRhdM< zI+W}k`_n{_%ic9-V{9>w(aR!Y=M;gzcHYPdQzKkXIMWke3P^X zuw0rV15sCCK<1%exk!K_9RQ!73jR4r_kZ7J!Cio_opzCcN59>)@RX?t(BMr# z4sWpYsgS!5wa7ox+3{%T@aedm7H6)gr3U|One#_h-QoB=!-XepKba#ZqFjQ>LL~N`m%Xjo`tsFXa740`@$MsFO6{ z42J`t6e(%S-{^UJv1>n?&i^@xx+L`1cbqr-_OTN9c;kOsEZxxm_0iCSzmDbW6QFAj z{M}+HP~xYxagH+wYqxA&%b=X7Tx{=$_*)VB$=^}7rgr=*WlMTcHOx3Ka&gejWmUD) z#HV#z!wiv)alXqJJ}=%4erfmL9G1Q`Ko;y}>m{4E+@mI#y zk~lyE-}UUPC=hkV`TH(@)E&I7L1Qk{JjHWyQb{-ezYnGC{7{l=Lyz=g-e`u~nSNoJ z1FJ02+(b94p^UEEM0DtXd9X=-zAdloLFX^~O6;Ewu3zpqUQJNe$%xT^vs9=9` zOTQLouyCaFg=r?b(lfG#y`3=~-8&8uJ+bX`xuN*>o4P*ItWxh9in*60uMHg_VuBDsWd~T`U@7}dt+x+K{$q+Ml z-!p|<2e;^0(Pp8Ua_5*hC$(NL7Or$w9!=O|9U1BKA^0{~LJCRNnPz!9*T$7UfLqMm zN*~&Q84N^dr^jLl+PYs>w}0fV2(i3{kvGaa>`ex|My+AlG)0L!MVu8~?UY6!VF4ud z6fuvPCtY_s1FgMYGG}g>&s#?10xdyCEZ+*IR>Ys4dL`pNXnz2P2Zc90VVDCyW!Pn+ zfdve7@&<&Z zgipj|;(_xM$Z|#qajmE<^nze@D6n+n)I7~9lh+!Z(2$|YFr9_9W2!PHcvR4i-O!+2 zz@T$8yqXZB*@CBNybV{R7-wV%3(SiEg`pn+ZF}!>Wbz`3+^Jd@eg8MZv=iwwmgS$J zF&uB%?NhCKTUUus;Pfxxiu6mTueocC_;op>9?Wn`l>!LWvppI(*p5cp3|&mAg&K$J z6{q^w(phe$Z0(wtS(wmTol+XFWV0jTuAm=oyE=cQGd$Do{G|0{O7_RQeCHfm>t+-> z(h}l-9xG6n9>viM+>8Ki`ip_mJ4=XZ)_8*J}EY-bByMQbg%)A@TasBPQPYc4*fn^+-A96Do}FANltg|$ashv4xns%&j2 z4l&$hH>bjiJN47V7{|LW$xqJNr`x5WHSLLPxh7mH2KPkwWKT~(OVgy;q5L(ZvSisi zkHtoey;yZ;`->sJ{P@lBWy%{TX*g=4yvntxI-Qs>itOgRSJb+W5QVu$aYMDyS4tJB z8Kob0^uuRL82E2gKm`VBZIJ~LLv?+KYObb7$-k_~5;snkQx^&j$Be1MOXT}#o8i2p zxOXrqJCky5h)zoyS>FT%WW|{*7(6{16N80EV>+6MtK&@O_r@CpK-B6TH#N^jH3@xK zK(frUeV6L0ixGL)3+r7}kC+-2A`gCH@^yGHd7Av@5!gMl>8pxf?R#S$v5*J0bcT(Y zTxI(L`lNSs)HuQ0v|%~{(gW&1s@*Q#wrwQXwM)0o4Wdv)5nb;C)oYoj4Q8iZ|OUQdjkDH_^s2Wj_C zKr@s56WlcT=Jjg#9LAD#Ud9^nnR^Qjom$Wqr>^=*Qu?@P-KC9X`&^qcE6*%yU4Ap% zt-Pp-{V~QJj+XAul79fq0JQ?0`WYu3db2!Q(Ny6ydN?3TPU(odW9S1#YTttbW#HyT z3r%Y7#|9fIv0BTi`%Mbc&mMn;s7$piX=Gg)q!Aq~nf%YL9?D?Sdge$ndCpUFhk3rv zwqbM}VFksL!q@`-nPz7%Z0A6&F?9|P_wn{9d36@{ROkZAOVPHtuTE&)V_jH!TZ`cQ zBq?VPDnyvx`fL*_YGupzCsBZHm`2woGWvox-Kh!UjC!oPv766$sMvRO{r-HqGrv9j z2p|j&)nwrlIMf4{rhJJgpPqetRKR6pW@|6|KC=uUOisVHTvxdvIqhDZlH&Kl<%(yk z)~_^__7v8`Fl1s=fD*j9CH}OVqFEtZ zc3Nqnn~(}vb2HTMj;&fxd@|68giSwMr*OKK2E3pOH zb$}dJvL5f=aX7Qm4HqxOP3j>HgU>%5VdJHR(b1*(aH3DXkW0U(LH+*atGe>R8cln;xgbby6FiUH@(Q>m>O*@7>OnS4joTj$%)zO*^`-Xeer75(7h-(DB!m>nloSQ-4*F@;<{n5=3#UMDJ`|@k5Id+QO!cdZt~M!P~gC zRBbII!*}FSH#>Qc-=(H5kiZXX^L!5rauxMay+?c*1h@7WDr&9h&L|C@VdMd7hKz2IcD0F z>EaQnKGie3=B#mNw^nez&5dMFtj*h7F|>~ZXM7Hnek5f|e?Y}e=4tD#FEeS|@6g^v zG&rlfG;TDO)?;AOm$e&Exknxzw%DrBnt8rR`!rCt9qSpM|1J(IqW6HJ} zYEJ32)~G-cBPTUiM%=^!Kfk<4Pbu_~g`?gb2t?dr+1vmjP&@~C^Lk#c&~KI+EUTC( zVwsIRB9ytM-7d*{eMI-9PtK_1?qYnf&NyqfYw|;e*@+LT=VmVmHP4&NKYN-P_;^gt zmzarWH9Na1a7jSvo>a#HmWX`jc!+1}x%j6e+&)bf-fiCvM>CCb1};~dbUE#Am#t&; zXmaDx%T8(}X-{c^SbrJ&fSF;Xuf5zo?f78yHdx=1d$|2i_XcH&`euVmYUoYS3bH=V zM%kfR{|K6Vu7!hY2&iEfxVM#Utn`5QZs`!6RxKyBVcR zuD%E6aC!Lr8H#vD)5YGb-F!I0V6JZ)0a&gqE&Fo#slOVm>#nN9DCbAqXN3lQu=$KD zIFUn=(nCyUXa^xXF9_3;XS}!k{s&mhD^C`A<}=Icxb5ML^L9gOhN74XWNxgkCx z&RV`7sdPKz*`}Buu3IXgCLORNUgNAdW*K83j{F71I(vlFRA-1)8%10)&Wjb z^{UBFl%e3{KCUc74|n^Jm@?kOmLDk$bK0O4t8URxLdaSQSf z?Ear?+Do*KVh+0<&W>*G-8{$iJ#@#b_YtG5!@z`uQpwqKPxT75B9##w^5R-2|2Ijx zy<%|V%=0z=Ajx;cCRu*XM&d}h7961Lv-_riRTZKJ;yEf^%kI5`A_0aF=2kU_Pn zdtSP8siO}R?p3Ni=?beYQi@h9yjs#PCqxCoJ0p=*bjs&}l+_oRBHKxyI8Herm5i&r zkFGl&{&v;6MzmXBP?mc@SdE)GmB-WmL#OnkyT9HjdIJdi4f?Lj%ZL*^TbqzpMZ2Ur z;T9p2exv*?P=Xx$|=#x6-H{_S3sQ#7-!}F{mz5-^5>VDU#2{I?^$MJam zzSG`J-1P8Icg6sTvoC~p_7laq51}*QB!tabhxwyB`bn?k18Y)qwMdR7 zxOdcjU3tBBYqFiF?*27t$tX$~J2mKi+{}@3FOw|8q?$=nt(X1O826yC?%tx72No?Y zFkGw0n%?22`^0v?40KG9e0pfDQ@IqB9x9_FqSAh#{3;`cn-0Q)i75aRv+yv)zC3ryl8Xd7fTI?qS6$}M76ongw`)>-FZ=pSQ-E|T&tMU| zs$MbwR14St@Z7#(ami%8aq{>HVC%5!+XGI!Jo_tD`yoK<{<}k8otVCJP+y{~r8Ls;H$~<} zeV`iNw|3rr@tY#^s1x|`?}JIE8~)>9V(H*|^$&xY>;Komv?td6`7-412XozD2lL7H ze;iDNTfjdJrm$S)p9Zt0Y}Y>xCc<0&9|p5n>Zi3Vypya_EK_A{5rKWJAp1pt`=9>l z_xTInB8zLq|BW%Q^I8}c5Ya3ymVY%+?=^7w9(13Y?fr+5{ODQ;X6N5WGONz|yz$>a z_a#{*Yv44K7y+Q46WFPdoUz~+m4Rb%OwTRa^m%aFwfyZtBWGQMN{Eo=j2XvW|F!`Pni?dX|7;G?q z2i`xPDL}ouFMTo#2W*cX9bN3RsfWGBE`Qh8PMz#EbXmv*QSw6;LFA8j3zNY^^dI1+ zgy~~)-+mHfetc1F{U`1|H9PrF3-hDq-}JSY3cq=*EXhjvbJG6X!mRGT6#*~fp{gz=rB^57rQXVZEq+}ZQndVsF>I(|%}7KMx{?Rspjq8Jm*SJgf2 zZb8&94~07Eei*pQb`C{AvpP`wSh}Xo>wTUx1~|NbkTf$%YKeUkFsC$3I2EEJ)o52( zSu)B7765QvM^EhJ9}-9yc|vE{!gk<@{nw8CAdY@{ydD-u7EO~wA6;3+ZYJO5&Ug=V zu-vwa*f$%1gbT=&I(Mslihuk?>_&fSt&*UJ(6}=hqI{yLzt#eH%vg%j9`{C1j&*PG zcrINtVd++8{XTYG-u3(fOz6DmcoG;!C?I}w_jf23+@M}*7Ci}$>o+aH@B7+@z$hC1Ya_d{z`520YQ&<=-_Q~*8~_RZi!Uwk6KiT@#E&Lhwzxh+ z>6NaWFv%giwtJFsy(izls;SsIjOMJcKySripLX4yMqf_YU7}`2Ja{0$+_@z|&isOZ zg<}UD4~%owtX&Y-t4;YYKfu%<(-r$(m@scH)C(vkWK|rmC*M6?vV2ujy&L*5Qm;@$ z(-rVftWu6#iZ4|3lZ*%24@*Ip31}N93i|^1AdN@&mZqNAC`_UIU4l3-owqZErCxmX zNtFCHaSJ+%u5NQr*r5X@zz$+EG3H1oex=)q-d=1fnoqQ8f@}Eru)3i`NmQ_my*aHb_YXZ;d=GrV%9%73f z5h4<*nSm-H*tV8Kk$qv4XKz~SXSqz7l!V!8bcR4dh@@pS%nN@$W&-tQLu{l;5Og69 z8iI7(IRi|XfU!AYUDhiYh6EiECh#cO_D(b1Bq|5RONVwK$WU#tuT8&bW0~w-V28w< z9c@?_w>KsjAu*T@ywDVqmVMe1zuD{bsKI7{p^9Cb7sD>U!|%yP1Z_?3`Ayd6JtGkJ zl_Km*y|z)^qeKYKTbzod+u-Mp8l*LPpUFUC@i~U0P(4OOEnOS8;44jf+HB&|va}T% z!VP0^kf(r+69qNEg+XBVDQ$*S5!wuxfPaUH+=vy5Bh|zB%{?=)D`JP$B+W3k(@kc{`FR;dp{8Oa4;)~pAgiL@$&n$O0|sZHyf zWgqK#TFE}yl_ga-=jquk@|=_BT%r8RB$yGQBgh%dE>RTpB1EKE5;`Ix9Z+&e5Vbdf zTO9||AgV#3>{qw_N7~?oSy4CrFrZ`x1i+y#rtC1NXHcoH^mvico~)8n?5w5 z6QMNGLz#Se=hUh7`T;-JR~ei)R5O&aMDV}dyi~IE4k93{n~i@Eqg&>3eM$~odL&&_ zt=L5MkxO4V{#MP;LpW)jIeEr=*UTSuxFd|}UTRWG5aP_v2}ie&6S*|(9`Y`XFWIJC zUi=yL*ymL29DZL)n0|M|E0G9kClYLdFf=x`ge_2W$C(w2e(3drl7#02-%L+o&3>4J z3JorD#d|I+foK9_Wq_E8_k*dWlCYf$1@GGXDuo}D1Jh*sB<|8V$?MmbmUG_cC`20_4vhmjHE9%*Wk0aoxb~b)>Z8qG~vgz(d zn$t1uq}dZ8)n44hYGiEk%O@n7-od6WE6nAEPYCDJH|zCO z=O`(1z$YR?ef`R!{hMub)8-9wPSUc2U!5#W+6amm@4c3N8aa=94z1M#=1WnxPh=Qg zet)Euq=JlZ=qfpIQ~rD$=?|&0E0V%WwmPt~LZ+$nb5q=Q(jJHix8H95y0aEDvi>+; ze?+t=42oLVN`}47^S$O2*X4 zQn#5m=L~sj?mn%wTu%Xk3)vT|T{l!TrVDJR<(vz-whu2`CLKK|Ct)jpGy@RL@6LYo z-xQt-Or~FSBm#ikG2*x^gK$>jRodj`4!X<j&4`r7Q*H3;>MpK1wm(5jYvNc;!oXbf+E-V!O zu;Y43r+}9b4k@WrW4imIc`c;rNz8J@8?={W-RHuAvMiK~Kwc1q?4y-K&vAtF4CpzZ zS=mXbu11N*;1^8H&(2#p;sayPY%w>pt#}eg0TRL%tK6mfAB4$^Wt#$xUl z?8p-iG=)__>AnXYRu9e=C{W>!kmF2*_*^>Vx9bp0Wpx-epohGPFU*Gmc)%bHHLx;X zzK;pxwQ+?E3!Kbl(5c*zLCSLu_BzrjbV_Chh13dzumgdE)$%Yn*l3YF=7gZ#;(ZH0 zH_zk6@$ZymaS7e$7;AF~Mf$Ibt5my#6>A@EU8Phju?gl347*;^2#Tj^bP4~qE8!BT z<~JUz6TGK&_$jg-id|Kd!%RLlUxzp6%WS-LH`o7g$EjXXRV?pF-DN;fG=J%J5FVww zr(bj!8J6^CXDmpmYQF{&&V4u#p$aLmgBAzPJUKE@Grx@{|MjRW3ihpsLv7$V72`1E z#cPpoF>U3FH#__41T;t=oG8RQFrNA}U&d+w%-$uUJb~TN_+fQ+jVr>5j}lHk#fnO~ zbd-oW-fC1TsvasTCyk7<(?7fv+GL_ZaG{Q4$Uu&%+$qKRX^SgiVu8?|hzh8g1UZy& zQKfr(dwVS6?#@S#43zKq$gi`By1N44M+*5Tf7dz?gwg^5uRithCXBTiqjAK}TbZs; z`E=wp5{`HZ>r{-jD4ne)Vjd(q) zrn$Uz4YSu1a>ziNWd%c(o_rPLAhu=BrPi}edyJRY)Lt0sjAMq9AGF_32Y%T=J%-oz z`S?rxR^J@+T}OmI(Ya=au<=-ZEZ#CrRcWq&Z@N@0S*GT z_U3KHTj($61|5J4_PgeyWrfS@Ixi1MYeg=4(DaPA$xt+Yc?X*dEyeQ+ykE?8jZw>#|b~F#-W;niqV)#@5FE+3^#-58!!qsi8Zh04pZ&!yRLQ@7{S9 z>IQdKauhqjs^*0z zpUqKG2uoIFg{_+*f)YY@N@G{HPtF5&k0 zssxYFRQ&x0zIbDvW{~oUFm;6VYq~SSZm6E0{}JJSO}H+h%PNCh3CX{7Md}(r=wf$z zYjmfzk6J*{s`=fQjP$Qvm!&yS?M|=sY^2hb*PK3n0yq|gepK|j;%_)?6V$Xbh^MlE zRcPOAz9X(XH%Ku%7n(-44Fwg~f+E3rYOqG@G8i;Vh>)Yc4HTNHDqYpcET@*Mb`S#t z_(h?2IE_*!6smE8r0};Cy)BfIlV@utZoLe%b~-bt zk<+-t6L!dGfg>1rExkc3nK(K*4ZI>ReJUkV(Nz^&pJXn$kypLJ_&Ei16JB-Y4<}V> zzqTHIQ}#!G{e}FK9xbQOhS?E*C;9iCh%rY+k@hQWPH>_ z)5BF943&y@HOvJUvsT=(%DJBgAf7=fuKN#Sbq|hL@p)aA*W2jiRNri0mA#jq=dCd; z)!L)1y<$+dNvOAxkfi|Pq=G(oX zOmIEnI#C4>9_D2x&&+(PgnTi9d`&9?Huuyi(6O$a-CsO8|hK@G~uSd%F3jJwUeS4YmzL#W~aY?7k zmCOfs>6Ladj|?w7A8v5YN&IOyi=?ny1*|DGUdR_7 z!*RHY99S}$I#!KQ$tEtA7XH6$=nCW4zB?Aeo7Gj&RUe+3lGQ~DAIN7eY}DSSLI)pC zV6@_-c-kobwC$h{>5d+98$MfBbf{n4;K(z5^vcHoaA~DH>=_)(40{2MhI6pQnLk*c zpLi)K=6SW}DMh2_AX)KjH2(1ftJL+FF5{?jeP@|-A&wwhyUDLe)^C$R1Sr~*t)srY z?R;R@t%y%Mv?@HNFf-zU)){3**P8a1m4cbQBzTCzTZ@blP@+!h^9;~^~c4MgWk*I_ak-!5K zf1$=%c=e;wIgpcoq0Z{3umGAaFVh7#heFR6pD1~uTa(7$c~{nCbZp&a?yWv;Mc@xe zu?TwD3N{d2(AY7nrz63l#HibQci&4$E2o?Vy!d^5IYz~^>nDsC_V$Uaj^S{>@!V6c zA`rustCyODk%T1L+*GX_1vj|zu6IAmh6AN#z0^6?6Qg%6&rK?5i4OYbLlb2Vg~Lk{ zynRSxC*{!s>}vn#I#OY^a-g(Bf?knkciIGk^$x5POt)FnDKSgW zQn=3~|LAGFs4Us|NskKZCOt6ZPnW$7d#g36jdSJh$yw+z{|>q7I(PBsomV|K??A3O zb?W!+#jZ#%0z~MZXAr0ogDZ2rar1U!mybNq%h^B~Q;oM)c@^GPv27g)TFHIo!(}<9 z(OxSuEl%TS0#Qw)^dL!bL5L$=rmS-p+GOUTz0=#ft(ZMeKY*%dh|;=5VDBvSb(B@>lp^t%yPG zJsI2IEZw)w!vpM|M?=*9bYTxLIyeQ% z;&7nY$h2<9g;nWgxwE_OWpBo;KkAis((1nK-5k6XmUJm+d<}rC+SK3-6G2(Y=Xy%s>n(G874?a8SNn4-ZWP^#uZT>;j_dD8+s8Z&fTAlr7EIDqP=11$b ztdy3b#XPx934O?X<$`D1?$u51Tb)a(kj{ov3etK$zV)b*+RVRJiX-%VD99RAr32wh z=F-05{uvP7`SNV#Pifu<4nj0Rm_tmRRdu-x#YGQ8jB)DqqZm8n99!6ov~!Gx!=*au zFt@}28uk1y?dhX@hU(xCMnpeHP{BzaeOgJXw9HZ> zTZQM(DMQxdEXwgNj?_E}v7WT!Y`LI}u)-@52WvpQMa^E!z!WeVDembc9g(?*<)h!r zp0I*LxJviZ8`n&l$JCACGom_(%oO`6CM)k-0o;LjixcyeDRgQsX=>gHuF=IjeqfHh ztd-Ce(Yo~1@^IH#tgg}J)+Tz;1ssd_wu$~mqcbVoaYJ;0++ynWqJ`|pOFp5^HRM@X z<9VRNl5PUZQ~(4E4W9+6$_!t-w9Waf60Q*xms?nTwj1CM-cS0bU@_eO;JQ_-+KExC z*5b#$$ub7?Lt=!gcTLYK*DD0^zs2A;ESwd;HGIimGKhh{d~^CNzMCrzYm%?>AUEaW zC~k9+c1|HbDmJpjDxzphnbBfd3DYZH>rRDoE~tUr3$cElI(|v3u=h%CZh%z*B8uwV zH{IFWp~%F-&&HqpO((<)Eexr7%2t$u#SK4i#;uOU>6b@9~)dofqtoBGoqSbdT483hqOmIjqY5*WgUm!MmWuqLP(et=4! zvv&#>I+T>zJy_dG$g!9moGFK=dlK5DYu1Z&gHC#XShe0sb?pc+j94)jIA_^k0j{jMXR++FXp;7;PKb#vTw4uKs82h*5;{1gJq%Sb#z9Nf> z5`Gi4HV$=N7aJtA_MUqet(4AVaRih5n;kJ$HiFoK!#Rjx3VcRQs5|&OgNzx{7o?es zTL4R-uq@GA`)SDv-2<2omVW{x*%M7Q=?MI&S<^dRo{u8iJwjd#;A&4sgwFBZ60ngn zUOBfS=8MYp;eg+&zX7SXDmDN}sUvwe+LQE44p_FIhg(>XwNncos7bTIok>p zT*Itr;>!p);U|9fY(Lf{hDz6IVlfqRdRe+#l8qlS4#j{nO(y5AhV?l%QQh2GCc)eE z8zCDiA&2JP*cv7K>_xk-sOAD=ZFWmzYi)j0W)o{#y@XK=ZAu)!GNX{8Xf{DV;u?sY=oC^k|Z(3r-mHlT=rz7f~P4O01* zYT=6Iohh#ssMjGxzvq9PYt=>2DRqIQ{v2Bv<{V_XOv52WnuAiNCfk)qQB-172NO?! zju0l0b?6SA3c!HsIXC;Qo;Ow2I*0bVW@>cyb^l#D&Ugksc}^6{@`97YF6@?!53fQa z#*T$;f2*hzXNS6!T!bn3#J}x~@g|57>YG{pd^{L~t={=#GW&3|oT>hw*1D6oKNRAE z(0kl}OH#8s%s2!5eWu)q9$QC=WYH2^+@s&H{Q*{TK9fP-t=o96B0jHD3sje*VK6qs z(~Jm%Hq8U2Y}y*C4oB`edN&f(MLlYy3>AtN@-xrf{5rR}X52C(HhKGwInx*)))?G=xz zgD4qeT`6Y_50JX<4{WCJe(kM7Ozmx=PLy6JgcS85M$vY@Mt$SKzg6-BF`l?r6u)vP zBz2ILbkgsTjfFy+{oH*@Xb24{tuCxS-~nTFGLkEGYk1jx?j;;+o)4mqfe(_h+cjDc zpab`YEc`Z;x=4MZw~Sl#X1_~#8nvgqFP=5#V2?ss^m>~;bP4f+?$|hoc=?9{e>L5Y z0^N@cqM6!u+-=WV6LkUqQfe@Jt`Big)ia8HK&RKkZaSooJRrq}@L{OYwx{F(S}5sk z564$?PaaMHbk@hF`=2<{Fq&8!dlU1pu+mWbvP( zmY^MH&X0Zu4H0c+vRa-JFdemM?|tZBctLh^w1J-OLLoO8vglE<$r0kNP-s*=0+m(d zoltV}gly@W`}yu|EDkP`)7Te1hO0!@5d#HiLe_vk0mVX#6Ya@rBHe=zsS|sfh`|)+ zC>p&-q9qA|g_lFMwPX)6=i$RzH*f!mp1k2QsWA9Nnh{z&T_`LSv58^!YNaC9&|5u1 z{dnM(@{V%b8J?X6DQG{82E-}3FcM39idoef7#PpSX`3OvNHAgyibaI9QO$k*pmrrEMiR_g|BOnJV7H~iTQQua^p-x+d-&-*&)Py%D-A_j`)^E-qY`IemJttX9G$l1J2<&VN6Jf~61Z#~*dtIs ze&Ub3s+3$%4}74etcUgKZ60N?NT)KhDopo9uBaOAz1|tcf1tjLI5Z%m(M25q1Hip)9hjfnQ*y& zuW8ek)vZXAInMY7;;g`HE)+AyzFi1q^);jsA`3N0BhmgIGW9D@Epa`W{TNzQv!PZfI z&ZkFHeS{|jnoq9?weOvWzf# zsryPAY>x-wy)MbA+lp64S+~uI`_U>tNWbZ)jy9fsLVc{``ig2$QX|0(6E*yH!M;{| zy#+s-A79&b*LJEu@mOudPjzn-)z>^CY9(|$4DL5gJr*bNQgP(9*$#oFy{VGJeB=oor}MU0 zUD28SK zzdX=Sd!9dKk^j7yA)P4~_8J`)%16Ip@8>Hp`CWdu@9(!4H*2_dEg6*~1BY;*WoT27 zE`|R3))+eB!v1-)vKkuHJ`bip?BFdgompvtst zt_#a)qt2PsH78y?x%Dc9PHrW;1&UNYF_&XtgTFM9G}x3OZ!2LG6i8YwwSG6fuRmUT z{cUgYj^D>*Duj01g*l2v6s06sG=_X7NQH|35ZG^Xf5vyp8(T1aX)P|`-donzUhMXt z3y`07%$~0gsW?|_ARqtJz24Ogh)$-~YH|JnCFEy=3LfZB_Gkj~KFbKjwtNE}>fg16 zGk5S;>;_$m4M!A<)g87VT@>BdA`jEV&tLuU?zM)nq;~V#`p10*F2RM{KZqtX24#6Yx*CV<>=d~cNmS*H#hokX%qO$$DM4-QB`&n=WZSG+%{Y{$J+m7 zLsWE~=5}Me{DEz>vx1zK6B>IS_$Rbz3$Vdj=JTxL!U}^Y###eddzQ5zE+GpS~n}dDsmS_{Vj6#fjcHh_zbU{(tN+ARDC5KnX!iFU{n${o2G~PMvhvk( zXD8&_ZLo>+6{&R=S?x2ELxs>$;obyair=sLU7v1w3xjzH<19){zF;>U>-L5ZjW-b! zhbPDevxJ={n$LBlIU8OXoyt7A9#@m6EXzKb%)h(S3u&E_wF`N5n=luHOxno9SUi>? z*vN7epLOiX-fkO(vvxK)rK9s}4b1Uu)twEF6XZIw^*)KXkvA;wBB5)>A8h|mxPWyZ zTBkm*_(d~0sp8EC1ySyHNe%yj@nj--aD-{9G)Yl%My9x6TW6l)a(m9)nCV@PNA~W5 zexaT3x*_T+PkzlDnqb{*7pd37D~H|1A3z`5Wt6Wfcz>Qwfs0rL-bc>uL+T+u4O?Rm zkICC)#a|`phqT$WaUZAnGEL9iQ&&BiXc5xgvD@4yg>;Fqd&iMO!TpKQhj^(*qeOx%ao(Mxlg_5CpxeCulrxV zale4Iy=aEtzm$-*X${|}?CYH1+`CYubCsrk5K7dwPW+LawLuGK%zuwUyAtCqBu8!W zl#Aj+bQOx^F5)lJ?{iQvQ;j~DMb^8Ad%VL}_K+wA5&p^OlL~t_XB0Ve>)!>k^w;pL zc*JAw)oVYH^IT4d6Qqyxs4Hclv8DQP#w_9i=pzCC;V%7u(e>7GO}^3JIEsn_ii(Jm zf(lBCbPfSUKtfTGoD$NEuEB zuDh-{_jO(8ocDPjl0ntB4{mN2hL7OBlWJYx$GGV-`TksJu!8Jzc*_`cjXcaG3a#;1 z4MuA&7$eO{2FfI7msn&NDfrG0%FzuFUC^u9tE9@5VY4>=q=#$gkyW#Rceg2U$@D@A z{yvPZA^~V{($b8D`B6Apnvu3km1Mbwz>3?4DfdB+Hn1hRkqlD+-(NQ(Yw;}&xMW4xYvxnk z#;hh3!%(9758cPK_>R2B2OU@kN{fl;+{%vTP4L@(?uT=+(g)sQFsSfm@}-z=*dSMJ z%_zte-xZz9;i<4#rLnwmYr=<;>9UmQ=Piy%b4qa4+!z->r!W zt8rtIeB8H3?f7(hH+(_> zT&khP3h?}4s8slOjA96vzyriq)o? z=ygGP-@_-~@aw4xlGSIEP##J0Rg?iodr?ZxiF8*Zq)DrUA@a6qkQ}Kh73F6?>0NO_ zaQat^>D(f>2}azHa^re2z`>lb{8M-*HF_T4mj9fbiQ|#>=YC{~Vs(PdXiva>xQvw$( z5HB^_IeuJ9ruaJO-p*oRxY;w~s;HSb{g{0v zm_=NOn+EP@-m6E2Wxp8dlbpr<+;_5)KY#S)QTxOI zS(a)0(zJOPca#B|ddV-qqajBs&V+CJ9=u5VKleLteHlogNotjk08q)M1s{@=O<)!_yfM910Zc z&6m9ngPDpNv@>n@x$BiwTO36_DiL}o@nv+si9F0>`$1fhpML|~!47ud)hfgQ{=y{W z=H_kfB2j~aVe8*PLA$xYA+8K;G1j?FDGR%hC9zte`}(Z$j7;gofSq>{|65ISuYn(k z;0nz%XS?G=jFB@Ft?p;s>V7x}4fS)?aCF(0(tqJ=e%Y(%rBZ!VLB!b3$TZP7?QG+9I-^6e#-9h zDxsQ1QJVh_-9yhR;@TyI4%0FWd#_5CYp}%<&ZRZE%83uI!!sCw=Ww}Ai*zCM;-z0x zO}I=rP2#tOBNvb1S4nhhy0w9JJ60QGsm}QPr4zwm--8zZ7{!;ev&B~-J|z66XSLQ$ zaRZ8n6U>(T^#W(HlIaj@SHFcDUOR!Cb#*t0^L3!a)kA+HkXu8JvBw!XMvo#FC^D3>17 zpT8RuA;&D&6UJp7GAyceK&YCHaUB=ugk#GTDe+W z5gApI>uD%iACVrl|za&bfVb_{fUqPduqbEwX>@3t?k*7W>& zh0Lm5zk&+ET9jgI8)=ij(7fDnGFq{oFUw1$ zU>@Ne#hk**V#vFi)wb}lC0{`lw2UOq%wqQI^5?iOrrAPdNhQkbcJd~Ca+Sdo%62=j zu@uA4+v^QhPbX%Qvu}4>Pk!GQTWAz;9xQsejr)1n59#-My!&Uzbe3E6bI>MJ5mf6w z$cP{eFr#0CsvJ|k{KQDt5F@;M7LOHPOhUF3I?+;=O4Awp=ylT-gh!HilgD1a8SZBa z;Gns*0p4NJ+yVYDWwA(%Y#T{a?cwf+$u^D1;JjA6vN)HEBPA-EIP!$;18YISz`Yd z-f_R__PK@fL`c`ETHd?;ZI?$zFCEzu ziQ|WYa->e?3Y*KQOh~QJ`=#beI*|`kJ*Up%^pi4(pOpyMYgEZo(6hdXF@>eb^+M|z z3T`x4S-*=;{ZNt|X!`Yl7y9a@n6g%o`uwD-4WT08I4NT~BTr>J1!W}!U9hJx`dqD< zLe4IG=Z(=)I0m46=Ldn#duzbSK}&2>d;7T6^b3DIqiz^~AHmxdI`Lpx|5h>9F5KudSW zB4HHKUBCy-2Q-((gAUphaz+GMPG|DMweTYDL0x+8cRlwUb-Kz^^@nF;)w>7b zl1FkPP^kcu$Y3y8@8>@313{g|OobVJ-kg;dci)OqskevyJODrdv~vZ(`rZ-fk73mo zfnDfl30fJ}cJ&E7Uz}LFKE7j`UX?_w%G1dl_F#5CM#fX2mcg>i+R3_Fh5EDJ`MwnW z4s6t&XM`eMh%|B8Wk`2-&(kIl!Y0XGyvK%?JF#w3++ATJotFkS-zIvCI)fcjD1(+G zJM%@e#6XuLQJzUAQJ#Z$V-H(BDFJ(>f{17D;!U0^z|a{*u7U~@1E^@4W0A#>12LiMl`=QyS_Fy5pp6OyPD#eVc*CI>Ybtu zV_aaka6e25Y$f>oM#`|2O6-eB66#sv$1zdX2u0_7cq7L*djN}G46-!DKRFuDkvm;- zWs>U>mer^KGX}`NY1~|~I#Qy$cw&^LyJF?Istn-~i$vUhCdasUeOyoU_(}TBTptEH73+Ua;>mQG(QnMwdRDqrtvmHI= z;oN)cZOiw)^^?hgp4s~byVf}kRKG1a(?IDC&hD!zS@G; zEFbbcC9n+NMG7|U%dF>~Ce+#|P&=F$GIl&V2yol_AP-&B>O7&pW|n>-lW%XJ zo1x$=j&|WE^kZ;u=@c!HyuJ0>RI-XISG%2cFnaS?PHl&0&!8ZAxK{b{_qg(6A139eZ$WcBv;;bu0N()QS(<=4o9d|*1Ro6r zTCGf>K1wBke3r&pT4K|XPU3=t&E*Ppt-8iW?S{C_pW!(p8F44f(-w8&j`}@UX7bs8 zmr56t#?WSy5=nQV;@$+IM_xHrt=`B-(-u$$Fzr!@{LRQ$t<@9^G97w61#knC4vzY& zw|SWC{JA8sgA#?C}fh)=Nt{OGod^l^qMU zSVJFMz($&9K3=@&_3LX;ZmzqWN#aq5O7fHLX5kqQcAN7ZcA%@aZVYVhNe}#jNZkCp z)g#VZxJVp>vUh|}L-XCG<1^%fk&OXM9{#3YYCm>|)F^c3kcMJmyHx)J2hw(!;Am z-I2AR!>R1h4;=AD>%Mh^+_4$!`24yC4}BphVcoFe+pHW|z-}p_b`!r}xtfF9F~r9# zn+#YEL=hf%evwXX4!o|8b#`eb*UD$MSt^HgSmsl@PD}d_2TUF)yciU}2U#*sEedE(d+7kGql0@9vOV5FYk@)bl0d!}^$o7t+ zm|XW9xe>{50$zH#&?|b15zcx0dR}Ui_GIs7Lu_9o^R6MJ5 z>s!AUJSxFYpc^CH(N1LH4F#-xGsn?gyySHx?*u{k#!2t zIas#>J<W=@l6ff1yt(;^-*(w1QNZ-6Qv?;^U-2ge~qirD_Zmbk=3 zwfMO9gH4ynoWgOWqf|xGrF?1sds7qk>=HuB&>^+mQb*)lr%cU8IOGu@~-=Ux-9jQ+@*Jm;yzie~Kk>a@f(7k92i{ddqg z=CPMfsb9_Wg=}~hb(-rX3*>`5UKs~lStYCl^2sv^TC6+Q}(aVQpaoT+2SFJht^~4|FhbG@7 zwdg{DU--#nSQ{Ej=wFwnY{Nn+l$)d#-D<6f{g8bGEbOPuLzOZ?ed-rp zHc?b^pCh0=`y|pqg~K$-Q5eVVO5}F;8&ZI>%uhEJEU`2Wx|v;h&N%kzwEYjI7d=0J zj&R!%54!gHzrH0srp0`SMyi9Y0k9wuQD!g+hv#bzR2bu$CL!BAh@knL)e+X}hSNEU zXE+HD4*EBtC#2_Uw@Bb{Zj}hSgyA8mc=D|(J5;wl_MOb@Zc6pq*0GLkK!D8j zfU`=bpig*b+$dHoyu-~1Q9WGXV4r0{E`t{)h!o`Ce8!mY>GyN@(+2m&qSbtT8v9h_ zc(59&4UqC|%9EZDgVGS*ViC;!9aAZO+ zjhKBuo`5FokA5s~lq`o1bCi-4!v}}ddEHld#0M0W(Fa$I8shJ4yeq0kxkh^lrdIx zO@5J*I%`BpYVs$-5}-#}M?e&aoZ5MW*-2!&gU$re?F@p-q?8|AP-^nX=^_`|O3a{@ z;2q$gEJVt+tki+a5M3a`aC<2^5-=>Y5xov$;UR>62^yyrghKv^m6UVCo|+`%QHU>K zx^9%HcxooUdI&~CvENFn3g2*IN@@=KV zw$z>d1a5tHA4}tFu9iV>#~W_V+*vjm(|J*QN-bQn%FUO{SZ1i7WnnRferm1VeT^cm zzi~(yE))!l+@lng=dx6>IB#78*{m_HImqXr%p!wOEJd&N*)D-c+F-8TKwXLIEPb6; zWwz+uzF!6UeEp9Rf+(DYi(_WOkBmKlAeYC>u%=lXnHYpUrj=oh@wbhA4|^zoa;0EC z>dH*qT7{?B*HOHerfFXp+_rzC1Y|irq)=?IrC3)a*TxDfun4XMU3hfLx*iV^HShF=v98S0Lp2%2Lg4 z^4>VPjPgqEYcvXa-{XBa_h?26Z|YON%S=FFOs1nr8%as9_gHOVkjsiY^Q?5V+5&vG zouXggt4-nMw#?+j`iRDd2+_$=WJypc7YF7;P2Q5396-iDRp!u zd^b}QkTlTA8P~+EUp?1E)>|mhjets>aTJYvGX6=O`~&yfU#amnp+8&8*WX$TA?SNe zv&~1LWskDA2X$2#xM~rodc5AaDHuqiOW_{BQb0Lek5t(NGOzgLUOIgQ{GOwP9tl9% zQqu8zhO;C~_B22fU&w5~$)x&N^FICD@<_`##gHqE;+sqe z>#`fl-9C0=+uStuF|`DIc`hL#_Vp{B;k$AA++%@xA?Y%X7Tay*VqXPJ^D9c}jmLW- z4*AeQ{@8_GO}^S)Uimxq_Cua4gimU7Pn0Pub^r&;_0{tvH{KkhN=&u_4?Z)=d0RAT z8o>4M^k!O$(Gn^98XOz=H7i1m!j8br+}U^s?qvsz)7`6I*Kx-QppR8wf7DxK276^P#ShN8J5vzwo z+fYU&l9oX75@ON98+UbE*9`Bx6VQNJ@!vQ8biB@9zgwH_L+rf3420&njO7+WBhHVS zElB+28b2Xad3CI!Cb!U^FzkaCfq`OaE^U+074Nr9{RfakmY-zW-%K&QyT{@QWMOq; z19KV0&fI6SWkYZL`H!Nz7k+R92}gF3BFmM>y&ZJ~)#q<#y`RkAgC4MZT5N9Pu|xhK z{msocBx848KMIbq{QliiSwp=7r1L=mR$K2RD{{H+ z>@T%EIN4IJT4eSU8>rn=MShDTQkgH z{y$&$wTQ!59J}q_k-v?Zziq@A(kd|Zffc$s`UUB8q0;iN^4fLfRBCJoYDf6y_gns@ zqaMWmSmaCa{K7O$3W0QnlIiPbmyChi`}Q^K!mj#l0!=*&G(IhXjKO8uK3nIa$lf}} z?W_Xsu zJvc99f0V{D)nYbzZ$_sW9YlB~jajHM^ zBLc+_PpI9Vc~J#FvU!o2-`vw71Erd3{V>Qj`H9@I3-Ypa zCBJ%7p+tb*aK@me{Y4}v`3=bOxmm)&qfj0?A88kb%f%GmnnmuymJD{0UmLlug#Krn zMzbZ@QZl*k6*nc#}c{$mv-HgS8-bHCW)}FPwnta`K+IvpE4O= zwQHD1o2j_OPw+IQd$mnR(5ChQB<+tn)@==PV2~YO3*>*{4vgzk|5WVXY$GRC@mW(vfmL+&F!%v?KhU$-H8{r%W*bVwHMD80<}_pQLv@AsJXmX_O=z92f&Sy-5b5>%y@c z$3A(B6g`Pibg|RZk(`u)?aAbx(U-V67aQoCc;v;$Hejk3eQMSerpsSit%LDXjwkc(WrdLljQ-EIo;5G*>84}EBn zpP7f?NSd7Wkh$wdc=V*^LI{jpIG8(P%2vDxEha)RcRApgj-U}ul=NosU@Ha6BsO`yp zK7@~^phdmBz;O8S`--XUEnY(=jXDYOy--hE%P_uj<_Ezz8;#JmKt7hBoO>2bI;|LS zzVcz{U7oy*R3axFP<~t6w3=_WkQnNDSU<%+M&7g)Jvp8dXEh*L|2hDLe-fk=O27ZP zG-}p825KW$RpIF^KxFcRZzQ+9QDidl@FZGUjno!!y~mr=p49t(|LYWIJzYWzE)OIs z)4(^x5KGb7FLmT~|b0Qs(b(mXHGFE8C_*kWpNKq`jBaZt@t^?G5m#}Sf5E6z8}_6kjHE72eChv5_esje6TLag zB7T~kDN9K-UZcNAl(puBe+ixaI|eBM#{)a|pf)7&d^e?UsY=R}k+oI%Vt~7Lzf2LQ z3BY3Yk{4*D}|FRZt@;R&vFu2GY#&KJ$0NmMtK;` z`yccVSQ|iq5$uy8DW6HA+LUCmGy~G1PFnAut%4Hf@s)M}-46F6USrMeD6CG$_^0y- z^d@Cx2uW48%ZcZld_Ne8Ca)cqeVTfF(Nk5!-Z|UdG71k&I%Q+t5_oa>c7=4vmf;3g zv$__OA}|%bOz^ulv*l8A<(z^^goP??k&TQL|C(ARFz;MCkSYx4IISkH461%~R*qi# zT5wkQ9H+-sQP#}{ON$6okjDT#?pJ$1Gm?jcn(iCuV!ha66jLNQzHZHv5H-4Fe`0^Y|L!t=y{zj}T;tq4aG>j9a6Ov#z(XJohMF+ZOFL=SqkBZj@2Vw2g_d`~zJ8=?HO zUJs>IyqVwoZE7CxaYbJxXWb+hG?6318z*0XcTFu~{Xg>b69%sI8pY;Aed<|PmMT*M zMVQy*KifQ{^4Prczji`7#_sFD%KW>;e(?|w-jP_ODFawqLf|HJrkw&m?9UuMQFg-9 zkPM<>J2m71Va1&aPj6CS6*LmH&eGfQ{&sf{Tfg&CwHU7al4H?R1C7LR|BF9F&mC5K zjgi}i!@p^L;Vl^WZMxGk0x*CHZ*;n}n2#OtZ2>G4c9ek4v9KvK&%oXOd4hTox5f+D zBsDt4;-UV73vaNG)5v{A(7i&@Z9i6Nl9H{o!oAo18ccv?ZN0s{-1`Jio%j&$%NW8? zjC5Ifs?yk)?Yx&-vIOL<6gUU#m^%2GBvkeMcEk=gs&V4B$8ARM5{|B*b05MYQQWBM z*0xfIYWt)}f=2K?uB(=lYA+Itp_(o1SS9B5hSr@kJ_BJq-KhA~bOjIeAflWZ3u>B9 zQ0Oy$Ze!F>aQ7WBwxMf8MLy;Cc$3HeAqFf0xox2MBzS@DYFBIg($0Zv1NObI#^Ntx zVoVvG^pg3PA%Bxxm7~T@0s6AgLl&<&Pv^x7t-gub8XQm`+?5@u=;l%eWs)Hmg*;e} zoDB7$2AvD!0j&vMS;hYd)_EVl-4SFoQ4$}mmmoL0^C=tB9v{qfCzuqk+z_>_!~yVL zP*4h497j5D!RzI16?d50M7Q2t#Du^etwbEvukKKF;XaBE$lq~x2(ey7)qT-j<^9W) zJ5AWL{??AaUfr0*<5~RGAzrphdGr&%3l6F|>~8Gr-J91@iCZ;LM_@ck8G?5$jJBe}0N;OFH z73i971#zU8DN8RM3bJexS)@>R6MA+Eb886Rnsu+2qtMv<2z!$6uft%S_1awY=78=~ zf;9|xw6;^@+%C>>qMi3~t8I7u0`{Q+i)2Al!t`TsJlbsyxPX!N+KbAB<|rAoG#TnY z?XQo2RhvSctw_$3S{!J6cV-x=2Itjnw$Ptc-B*8K zcTpQ$bul6G+Cz%iA^86O>V(=xzXH6YoylFU$R_&Z;lJDK-q<6Mz? zBv%_K{jB;^FVDhao$m&&%g0T(Gqf|8Kc1U%k&F(e30O>*&oo}|ZGC&!BmFFmjKDUU znjvF=u}-2sRWEpHB@6$niDoXMf!>Sxy^wu-&ruGD8f{p)SPqa@qzPZ(!2wO63GuVN zELB`z$yA?Eo~T~XF22>TZRQ1%T*wJ?TMlj%I}~ksDRk}*hq7ey-p|H)ZzmfXCb~*m zea1H>B>KM{XqN|bwx5ZdyP%Q^p-q?gKy@ni3SWFkcG2Hq)_mN)lj?DwYgCR4bu=fz z|L4W4@V{SdmZqebjY0*Nz46;xe(e9@p)xGp?sP=|2U-Qv<^vY{x*%E_@LN?{o68HQ zKou|fMXIn`jBoyaCCzCc&7Ri7;myQ11810G!oPY6B7*!~U&^y_ZORPndACaCfb5=G zIr-8g(c?w`y2pCbRF3Cn``w!Y*J&5i=anqdTFC{+=PNVS`i=e}zH5LMUu;#U)HuFc-<6-|Y`u_8z%V++)@U?^jb=2m& z8|aQ0hIeKLat2?Bd=t$V+gzOMd^3nWiOa(>O8xgv8V8%a4}BHtxvtGd4S3f*1}Z5t zv-S}zd0nz7pXxxG{x>1ozm?XLWO7hdW#9XKO2#Onk@Sl)t^3-&{5qvY_@6lIe=nqo zb>nAes}tv>GyTj7inPfo_8&7qu72hPd0AJ44SgMZk<)MVXk+MEPSnk+HuMIV!Kl-F zbph+mh)Y$FN+lhQ6DGb~MGiaZdsXm9euLhJAd)1Dq{83x0-m?8#pZK>Js_iki<TIpX&a2PWZ$y^c({r5zbS{NzLrI6ur-Hdp4X z%)4j%-1>Wy^DvjNt=PJrpr+tukX-cRW|iFw;l+HzaN(j=3%1DB3Nujt;c>{x5oc=1 zQ|o=u#bO(&(8e7`8?Q`nixU3U$`}iFAbMe z7F6Oy;d&d4S;Sz5iYRg)IQ8`!*)aQs?4lJDBN&T{?3K@td|jv--S)UZ(Rm}jh;kc& z=8V9^8_wdLj{ri1rJ*<1d^PFVe1XPnN4Upuy1hHf4(JWN)77b#nk4TjvfA-+>HP} zPAQ?s&>!WE9yygo3zzpz#YW6>o=!AAO8_=x*G%UFbc<9J+GP)=h4 zhvxNiWquixFcgD_aFj|Mj|j!63t4@fkV$!M-dw^*H9}I?WjtI;QL%hKEVfVWVHesE z`J56L_#Ej#;`Sl6yVxO9sPdwT9{(A)vgaveX1m?Y5JYjQ))i3!gnsDMC`m=hynby9 z(^PlyBMEmv>8TlDG8)H;J;6?MRlw%=nu@|Q>)LnrN6*z>d3>vTq-Un@)_6mDyueOJ zOxde{Gs68VG~TY&R6{Gmw&o$j<75_X#No#w^7=9kCEj?Wy1Jyo@Z$Q5om-uT2gaz% z#f>FgpWq?I0CaGg!x0!wtn9PLDw(UI-syHVg&^FPW8h{>7q8Zz?d>78)oj-q z!?t&FW+)^2MY7nxP5bAloFYFnP|`FnjGa7NF5_7$FLu8H$pQJS(Vp zhr1TNJ!5LZoU`{agCkC2#qlOTVk&fp0WY-7cDUjdRUyer+T3!U#F?L!bOzwX4RxYG z<3LBbhFKQ^CGy#^*JfB4S=Ti}@y`c-RwXQt8H7I|GL3Q9T^-r!VWn%j#pFa-IMIcW zi(^WIM+Rmmd7`Af7<(L_{F@i=-%4lKOtG_-*`(fC_y+KCxW0tD-fPGIy-=%s>a6y; zRLigv8L(Ae_;%R!mAd0Y8Go_g8{+W^#PC5R+|}pdmT-LIjzf;3zZIn7#^lwiL3p#} zqn_{c>NU$$lf&|YK2ZI!#)Lm6*A+Z2sD2MDXwBs5_Wdo@`M_Zv{cjEaIo3!^xT&^q z;pnliRk!z@BGVEDr^h6=JIpJ3#!_bo5f&X*)Jx<^y`~hQQszy}4PJ`EJ_384-YNh+47Nt8!rDJuu?NPcs zJ8Z|>K6|lbjAwiuOQ6{}6;cPn>BE(O89x7~U#_`bV`q~RH7jVlyYcMm*im&R zs>0aUaB*hN^8+<{RjuA*TB=fAysj)4EdJ#>>vF#T>PVYG7NpEA&3_2Erh;hugJE`N z^Y_SPoy=CUo@wRHHA&&>i|cya;Eh)#u?A+b${7xsi@`O{!dZoyF&_%KYcJQO3_g8n z^Nej{GFgHCejc!x9N7SwDB0{O9ccfj*VjHNe8R*KVlB*NvE$g2-;m32SQIlOwO$^rzk zfJPUUQj^Z+O^!dyALB;J@$@9Eko4JR6OIx)+uFqXZZfoe9np(Nj=*))k-v3%ktetI zqpcG7>3LoWbo02^A%;{*3^Vm9@SPm`ZIF0I%8AYUIA zHKwSWAsrHy!@v28#sER*$E}JsD{G3R&o7qa9A9o&r?_Tn36pW{;|)Icjv@f4I;E>L zc)X7pOV%U)iWt#5_Bm0vS2jqL{#LQRo_I|5)ae&|@!w6;K*QnMAQhm2ra7Zxw%U~5 z>}f(-Vb-I~1J3DCwGEZTA04?9?Aj3_xG!;`r=q55Uar1+^q&r53dpR5pW+akVPLDM zlIYl5CS2HHRd`#+N^3WmR9u?)pB+lNYYF_+nJn!Y>Nb?0bMm*SU`Rbv(i!S4&VO&r zd2bf{XBMD&Nvon05I~)x>u>ogWwBhZ-{Hwa`>qddd8%+?ixVWnb(5R97Bh@kkqSMu3OPT#cK{&zJ<{Q)So8P(R@2gq@|gA6M(EUPKQ!&@B7#Y zhbtNlVKBnN>WgSxa z&UUx13l~v;nR9LuBNG1J{IV$aA!6C}Nv4SC*jwCyUc@L_aA}+nDxgswOf{UBA!UMa zQ?2Au0ZL+!Flf8y`ORH}zNPVwAFo^($-!DAa&3`c)H7?~kp?VZp<-|7`B2WbP2ARP z>)V=}ywr$=PI7#(4Or`hpru(j^qz1c(igKmWQBf*>T3n6|DsZ^Cg8HS`Wxc3-q~Yb zxY5FG;{d%Nffl)fBiaWB{zAp4r|!JqGP>M(Uye8eyN1ym^~ksx&AlfiMn zopWVBu`7OYzNwMI(Xs`kxO*BzKI^DEndWl3{g5Mf$aR`zfalMC{ky-VwQ_W5qm_#jbTWW^1lj#M>(B@DsnDh7tOT`6M|=pL<2J_#PMpuX zJ^2&DOxw{dcC^zGv2z^A&@S%PQ@Vi^A)J}x`H1saRq%P1suRow5ZiI9g&wv|4h(Q9 zW=0%SJjo{RwnwlZ`%XEEap2PlZ9wOx@a zJ~I`uHq&)Z@>{zqhp2}&!wayB8nBY<$ZL5gRB0<*^LxM)ENBbLeTm(-sJAp0@a}kt z8a}ma$!K z(lcgExi-dA|FudYJ}NhNu=f$OP2^hQMqc1y1X#iZ!{}CSIOtqgtr$E7n|(zAA8_ES z4OYGejcQb(?O{&=cTAs+9EnSGp}DR+Cm5mLRMH;iKdA^A(W{cha!oT0An9nxtB_Ar zt#{se3&TmKzvD7HFy|-tw0&1^?9E!C(7riORsH(j7H*>L)z%ZAP5Y}BJJ$Ebv?lk_ zi+kZ}SCCN`U0nc)l_5RmP!qX{?^!Z%z`Rrst=(8Pn+s7SX*dyB ze4acMI;SH4aWvpMPJHicPd|pckpz#1_-&4jP`1u*Q2dFiw`$1YW5AtE|G*z(!_YW2 ze*Ee|Lrr19O}Z2Nj~IXS?%}L%@@t--2^toNzp^DER!FS=U7$FB6iZ3Aw$( z%bG+WP#%y5BL>J+TeIKR2NYyx7a=MFZ`bmXak6n%Ai46Mi!)cQWdQOmqOzF+v-J(1 z4J}SsdBmi4-RU+qiQL}D( z%z%#(y!ZYJriV2IWo$;i!;5Hu>_25&1<*3rHP)BI*OybWZt%8@|5RlZ@}Nz}5Ff5y z^Has6u!aSZoxUX#^Y@Sz(wdz@p|gP{DqGuro22uC&lP z6f05;-kVm_Z-dcyyxHr=CflGLP2> zG)&ensI9$@F*XYaaHG5xau0p$jpxdbhY{6)3n*mCd?)Y&iM4qT@Qws!S;Wu`4*(0p zrCuCmn9<$*fX`$m-M29Fsv+eY`?8*F24DbP(J%J`rWJ_>-I3Vt%_)8ETN)0t%q#fhBvEGRH zI@>}y69h=R@CN8nAsV3=xUpmIObDIZl$`Bncr4Ke^y$`r1Wi?fZU@&Z1`2~Xu^=;Y zl^8~`ffT$QsX~A{f%gOuxzK1OeDQ@MicpG_#8Mh0WbkIn;AlH^D^eqv*=}$G)yQ^P zXHipIxl6%fkGI2qWW9QbBivH)_4<}%Nb0CbTVRDtsN5iZBG+1&;dX78|&rXpG!9l7>|8R{a($!r@7bZ zo8TIc?&o@g51DrW{Kg5*Pf_E@b;v5PUxNi~v%i^3>0kAZkwn2&M*>6*`+oQn=dB4| zh;{XCUC-lR8KY&ymT6y+s^Ah_t@$JO8NJaaCUD&>0HmSS~1;sn(bvS(89P0oC9vCdQR~MH| zG86)=BDi04&i1~2+nveUnl00{Uln-i()P(%HL~a()Sy%SA$j66fdf{Z~mAQP8P|QK=!{XRh?GKu-ok6}lc=GuF)O z86&3>i-J}Gs!Bj-0*Z5FDtYE@nE|)YF)s4Q3CCWVc$4}3JIdB-eT%;Te&qvS`CC~O zrdi~eIDl%cSUq^u0VY$El**6=-2F!en{FJkmmx#vj#$e~UR*NW+8DE+#^2T@I81tv zsB*26)fhw)veyM7j&UhdARK#6u#epGdRjLj>>xRW3S=SXVzu`@i|-K&~=o=MOn<^XYUdSNproG*TPvR80EgY^#-`W{g|sP%E7X; zne!%kuL#ZQ8a(dwYv*Ahm&x)`C7m^?)uo!s%7bgug3viQxSkA*Ggq+~FTPldme*|(-^^CnN3bG3XaKegn>0qJk?%%4?# z8kaAG>-w;(<>8z{CZkh&%f?<6*`~ipC%A^N(zHup69cO+rTkk0>MI)q-sk$k;W+<22W+)(YGF?#W-};CIu&udJSK zh2%9b8)(#!Y~T4t5Sv{NV6$Yy7fWcfD2NFtY8sg?mHEZfSy+k6U(9lN5O_e25yps| zxo1JSL>_(7>@CDv40XfkE=v5I^&|0sm4fG?Z;mIC$Npq&D#OJ?io@whN-b_KLFw50 z|6}dFqng;-_+O6=6%iEy6=@bw5Rf7$Eeax1BcdQR3L-@y^cF}|5JV89cS1*MKuYLQ z={58Yp?3@f5=cn7gXewEIq$jmx9+-Y-TVO|OlBst_w4NbJm2rL<)LIs9=q~x(3tf;qaldwROI_q_4fN>aRnci-s!D zk4#^twO2jeRDT#JZe2l);?Na@Ajc_XrKcQ@f^N zZDmaMw5)kduaUU!)R^^WPs;v8wd(4Sq=IA}ul=8) zC$Byp_n|;W!@Rm8(bA>h2F$Tjgw0ZfrKdbi@K8Czc@4Z%34`@H(D>aI0}?R8011ai z)}|*AuT{q=*ufrcQ89AFV8#fE<4*1SX+*s8FeNwJr*cSNfyRyOUcLQtuR4n?Tqpl* zduU{9(c6P&UO^DDiABs(#$K20Y>==6p+D8=UQ`ge)}futOP)7me+W2dYh~5<=t$%Z zwE2xsGFBUb){A~*?gWG=Ou|}72+s|8rMB4xs(g+aX3U&E;cMum&wR?IFEg$x?Hik% z!Z+15xy%)`Tu@k8@ciLJ#EXIZYE zg->qhsz#K#NpTzt{Qr-jll)^RnCP7=U@{#bc8M{xN@vTrG?TxVVy;nYSHBCoXzXDR zCa!fhA}Fb}kJrJ|@A>N?w_89@Cn2v+=Ym8mpgpV~1Fj9&_Z|}t4W%pZWM2}3;$eVL zFiS)x57GJxOb2qzXY1;6&qMWDQ8m+htNm>HKP?|g2<~16?#~Lk%;8InBHd&1Q?vUt=mPv zi*+xQ>SH*6HK$_Bn1;4HZ9<8sztyeSK*lMZnStx=El(?{neC%eh-by}Fl(+^-piFg zqxISBiO5+tB@V46`$d}iROF<__AFK()STE=%FjLgJm6{ZH$L?HtnAA zyltYBDZYxnLH~imoMzq7BQ*%`Mf*OcS>J_?^?D~FobHy&*U?5=!BNIbHPkN!ll z!u~8?Ri$>_d5>!K;dz#Rh!IU+e7bQRoQFr$17Gt6ipmP$5$dw0>9sd2h%G}qt2-sd z=H}VO`@j>x#-#5eHaVez%eUtSdBTOo#x?4(%o<+{< zCP;OH`m-3{XUW}k`KPc-F%rip!+ACD#(JKpQfN$X%SiWW`nJZXvdg3^PvLOD_Szi@ z>)&{jLq%1NW+kZu8-{Xg;ltbyS6BH9&fa$=Sj-GU-KE7tT(o1@yBe5ONEAlbv@%}~MohPoM#wJ8vs|hEc%aY2!2?^9xP+Zg?S3#i@EKC7Qr%!#;;*2*6 zVdOV}7EhN!JiSG#4(_n4p;Hyv8f3Di2I$IXmYa(~6WN9^Ho`EeG4T=0JgZ3R9;A-u zoQxl@j3FUs5#G(L#;{{abki_hh%s=Z6cX91Fw9zgbI^Fq2@&uJy~<{#4>3$eKc?Sx zf#qm0%1Ekz>MX5cdc@=n z4A+j62VI>Sb=Dtkel)CA^H`#`1(yZ-=-yBqAiJh(23L)SWyntE>vr(a8=C1!^CQgz zboZgp$^U-=O{~p|8XvT$Xn{MAxBlF9&Zmg1@(PjkU5T6_q>gp)6*6}-YfiqufT?rP zQT^8KNkT@Xj2-p+5JHQVlTPcG<`LG#sCbY7oCGoSWDOCR6mQYMRZIMIn7tle+bIR!22+aFuW(&kK7=5>Ypw4)m-v!}*?>qhSSE@Z} zL<+&~P5rWja#zxT39q1(A1`_Y$|bx17{f_t)b6cf__tVHDTn~l6QC~CwWkP^K93t8 zf>~JJftdoCPL9R3bALkH9GuaUZ;73WPR{5Rte6uk^*bY?NnerSV7ur-VtW7 z`*ifQ=X(woGp~NJn8slF3exv$4zRl^-{I=Ik(h2vM6wy1A(Ck&Kecu>DLQ}*b-(X@ zd6;z5_M7Bsw}>K*Fw;5ICn284;nO-5q|>8{BEnB%E`M|iN;^^M?3VtG8i=Av&Z$iS z;AD=E%C$VZi*M>WT2#_$tn8Be{e&W*4f;(f9z??a573A(B*3sp;iTim6XE*fbkirT&67h8uGSCO9 z7?s5AFU}-}HO1883R=w1=za;6uijMtR`Y}@z+(v$P4Dl4uXxaNQ{W{xdN37JThzv% z5D=V>`OY|8&IE@A|G32JKnVhtDtD{}U8Kt44?s7({Y27B?_R^YX{$*tlCtSEXre9I zbB*d&qwP+2P~iDRR{o*#g1i1(uR~8v7Abb8oE?c?wZ!OizHoJ z?HZ1sA$|(-gRN3O_EbN|FdPX1-g}D*xXrJ93?|=Mg#7-17@k1zsZL}-*5Kxoz)f#~WP16H_1a*1f;fZk*c!uN zJ+p}(qftb!^51-NahdDl!DM)GOIM8;mqiV|F@abC&K3m^skH2J)5JTq#!t1oRcBT1 zer^Cq3ZWcC3GNjkkmOqt^PKFs{})(^)T5ksKcP&Xz3e!NBPfXIC4jl447y%zy-)aN-@{Zyu0ajOjy$NHr~!4eY;1^_>cxebMMA1h|m4vHe3IR7iixORl}dVC(1crYawX%70%LTUkO4%+%(a8=ySNpD1^qNdt8I$9=IB z*ro%J9Eqb38NfMyLU&v=2Oe0@LmwsF*}V`-kC{hS#Smv$GguD|F`nQ95PtknK%lgS%-QztT zIc*NjKv3y-?=cyT;j=}Yn`8huJUf~gXES9+XMapW^C)<27m&vQ^_J6p-{>`O*gJvX z_y%QRv9BD%tRD|Cj`K(~+p~I;t4oYr2Zp_F9;L1oTgSXc6NJ=Dk+yRK773qtq^D7z zu3KVvf`0|umr2-oZTR^t9HPCwOxR=I9y&07rfes>^U$pDXn=U=m6RIm`&JxeI(zo_3YlgX9*Xs zZs_wJxqyNXW_l!&^UsrBzWeh?xocuGDVU?*1Dm$9e`n>rX(DAUjBRKs$DMWnXj{`erfYaQ#huBv!z7=@4DG$8zCkf<4*igi} zz|yDRYCyuR&7T|cN4`%KdnNPCIw)o-UKBiVZ=b}X)Q#LfPD=3$dDibf)BA!=pEvY< zInq5L>B)HEHy4qoj+pR-+%q}?DHXh!N30a`$_km|I_AN7lrxP>iQWG=h5eeMjhU_U)1Y+ zc~(n}#kewD!P0r$Mn3Pn085NiyhwVvC(t7xAF`%wSouz-ZX?## zIp>^lD`+5ZSXp4HHPrW+{`H*J5O`p|Ai<102F9j+HUzBBX%9o<%=5%{5swc|ToBp+ zZVgY6Fe*63A`tYx)6gV75bq|-y^@#|i_Lwdf?YI9>yj+}N2@%Rs{m5lwIm29(Ep8)fuTii!~Jg; z42-@G;sJ#*Ko5E1ecqdO<8J6FuMqu9M{Tc9N=VN**Jkq7fXWSgi-j*Cu0)^H$zs#U*C{?KEBNnrDrnz##AFrQSxDaU|v4L z@AaRm%EFngiQD-k!xuEXO_y=9fFY2`%JV+v{wMTZsGm=F3-O)TIxEGpI=Fl$uVjjtl zu&7uC{X)%Uoj1|D()UAOeHg(<+nSRp9qZ=?%DIM_u6%7Xboem_aRjKm&NQP7{{w!o zx3qG%m~`~?`z&JFuVwPU6&iZxvWek1EW2n&6s;lenNN|ce21?z)VaEnsBaa^k|(C` zMi~B`Z~~1HLmkOMdspjdLo>Lm?^c6`OkYtH5SQzW;PQ}z&7_tRCOGA4RaeHPXXnI! z+PaMvHuopgN%Q)fXHvmIT_n`UfAlXtKC%p;a0@Ub#Bm=0QLyq407R8<`X?05*19@MZ1Z6YkC=MWlJJWo)`D513mm?*h%Zi; z^_oVt^xl3&9T(~4Xy$5(XnsNhz!jOefFBb8NBi^$#uGZ$wl-cf;hQjtfpfRFcYrkL z^Ci1G?LX{81+VD%zq{`1DP|G>^c=53Dg9a(0j-kE9DkBTEqH`mdF1&za?vrbsU1>m zrRTYty|fKup==f-@TBM7qmVt`IQO*gX;kj`o1#u_tHV4WCfW#DjkQQ)c4D?Yn%xEa zto||At~6@$Sm5ELErRPc>*qe??zl%}B9354AGt}YlT7jDB2>;Ass7xPxj#jjDUbPz z0Dru)g-PG60mDx2)|l&XdHR`VT&nrP;&f;|}vk&Kd^6W9OV zI~{lf7Ia_YrgF?{o6Bw*tDD-4Y?^q%vm*_HjMZMj7|~^7l1Oc#z1G|pC0I$tsBeSl z(xW|ac}%pGa==Dk^$?y%d){IJaQ_;?m<8w#+oM*xP-R6DuOZ{244K79 zL<1y>rfKIXV-F_u;QQE$Fj0z^^|`i+VmmxF3M*L z`l&H(+AL+=O)lF}Q$_;uY~j+lz3?#6-R2N(;YjUMvfEecH5RQrF^vF$p5>i6Vb@L% zkrlO;%T?_6gJcUTb64v))~2MH(VMxUv;Yz`bv04G|4YK{CO%hu%srOAFRhQ+o1k5W;a}BzK z)!sC3SF4%C!DWu?$70O1hMG&Op0edFIxBd}e?%siFi#uBgF=_{VfGy7M6D}6X}!1C zld92^+#E2q;0|BsI^lI+`4~)+g0&Zed1US6K>`R)TcL&OAX~iG=5ok$2!4+98~F2D zCOE)<5YuQtXVD5!h>|W|(6NY%E26R|EJUFdjkPgMgP|xItV}hAU|3%2LlYt(!#`7# zrll+$M<#eb9n{4L5tT@MdH$_JS zs}>?&9}<20bLa97O@H*_t{Xl#tCTJfGPK(VnCnHneaK~;Vm|(tAmU?J0LR~6Sb~t= zrU{2Z%dN9vojW-oNS~g6$MdJ>H~=TWe;;qJ0Kv&aTcU`eZ7@&5@#d7`gFF`#mKsbJ z_)LdPi3zW)Z7^{nhzqPF(;S&^N&Jx=@k-`jsK}k|x#eDItsg}~!*K>dM ze9J|tE#gx(W~Q%!F!*lZWzX@AB1+CUU9zt#TECD5u%mBy)#|*M8E!w%xTenpFjn%Y z(ucoCn>OkHOn-yJe(m^hP%9tBx7NyD4mz=jTlp%c4ckOBZtb?Q$@<)tPSehlKn~wOc zgrRetWxN-R_ja^+bK#X_=XsEu(ke3OvjKP?6;K?zN^p%42VJ7E$23LDNKG*JqR9~5 zNxOwqqHY3BE_&!P$`4QMzy~>nYTcr}dVWB0a^HboZpS5Z@#c&mfs?X#jq^@|Atd$q zB<~Rd)O8@{4Q#WVaqsshV1Mf7`^dsJhkx(Co*JMbz8~TP0>o_@1};f&+FbKe`+P6& z#|5V@Y95`zypPOFTF6OE5dHVrO>DB?JRVeDd&%`QzqUHDEvxu)KDyDQ>>5N5b zKto#`k>}Mh;&;ML|wC}nT~d$#+TMXrSv%95)f9lOpa}r zTg4B8EZIa(wdz*J9hv;0jh{iq?#7_~>F-xrP5LB(VP^=;O~T5q<1$B_9$wKIPP%Ca zsD6do%-Y8;cAH%o$`Qre3Mijio4$!*k>L-|N^apzz=;+Yqa2CP*m6OmQ8I68s(kUh zO1tO{V&fYz;^)O9qV(=;1$7_xhvDFo{b zXmt0UR6J8~ugFKl@Si3D;+N{wm$jz4Z*HZ2h~KEnY|Ka(ES3<+OzMMX32@{mIvam2 zm99hQu07f5spp7cXvJ*i-}Z3Ri&i{ zhu)-*#+Vn!cBiBZYV}RE;c9OQvdv$<*XW2yZ|w6ocCATo;aO|d;@>lch1o5ghI`>C zuD%HfWBMx??$>)4{f{u9%EIe?8|f882OAcvvnB?Zl*W5YpaHnqa3g^Xy9Q{+m zWGiIzy6$8*5M*MV=-txB1Pp<#_I3d5!%Fvy%Wdadzoi5kTpI5}G6%NvwT&UOm!8J# z6jfXzcdA+S2Q^7=c3tAEd!%f!qfX`%?1R zx2q4roVLO4q=-P{OK0aD>^9c6<(z2j0TT1B1rRXc-o2r)vkl{>9Jgky_0gLIKHNNR z{eXYYBVE7ICa-6i4s9WXh-Ir)FSOtk1j}wFvgPtsIi`0!Q~8{Wik}LBUb{wBwxDaB z{Z=PGs$nwgX~}4{4vl_`m5c7&e$sw*zU2}6BFXxut!=I4t8)9kEre2N=bh|6Yn6m^ zYs1+Q;=7w%$OI$va_8KcpJ)Ct5*T}~_N1%g;xSjMfH($wP0h@(g=lyJk6#AhsW|Rx z1&EAL{LIG)D>GWI5oE_I$tw0Hcc?8kQuSPm9sk<|p0^Ks9w68+7J@o7aKA$(gUUU) z;uub%>rlU(sn18ch}1xc;ATyIfA&e;;`3i_E!jx>{-a5!9?@A?rdq6Y-30`(M?TB4 zT(FY#Z5Z$6oBbj4E81Va>IyeQR=~vwE@0Vqgh`+5)OV=cBYp*?R8I`>T$YhqPwHJ> zRyMe)Kq92o@tk5Ezay~`QJpcGIQENJ;z z^i6-sDzf~0Ck{-1Db4?W@vmo}56JxE1N`-JisS!5qRsRtLH4f=|9rB)dA&|IFmS51 z8w~ySC5jzrRrgq z&j!3qs!jhPg%zxN)C@Zr7{sY-4=0N})8Uz9UpJ-LZ7}rEuYl&Pm29T5gdPlD3 z3!sX~NB2|Tdz^sa2cUTUmX=Vq%WH4_zZ)L-nkYBY-JP_2XGv(y1NK1Db-lWdq9At8 zvsy0QB2up=TEb`W#FLoU5}!MYMCf`rqi&@pIZkA=c@ciDczF%eJc)f6xtr;hP?fIW z=||Prgbn0dmsv}(kpm?jqBQ4+^R`M%FX*ob*EY=dG5dsko7bm+GYYaY>VWkOs&u}H z;MB)6*=?6O&vJhAKK|i}CEq;AIOX#;baJ&+X$LD5)pkJ)_F^~z2{=U6d`b=Xm&H%k z-|7D8_50;ui|HT?22?X%jtIt-cfgbmg?TC|_bQ^C*7)O|w?s_TjnlHHy`ycMnG#NT zzZj|a&x&!@Q9d}0aR=ct8*lKZu~ zyF?RT-dMVkZ9I0Rs#i6~T25x!LY}y3D0X??gg61n+uSs>Yk63*f!gg^QkO_eE)^2T z&GJ=b!%!`H-D%oyv}w=BNnM_{sdm-ut$Y3WHwI@dtX!82mY=ok3kv!3yiHac%QdB? z)*I&@e~UdL`(xTH(e&$^z;oYDI+BOf>9vi`muTp-%>K8hty#NBO#`fDfI%h7GT&Ap zTeXP1#VVs^RVGAtZ$1*}FO;UES7e=yC{6J0Y#RV*Nu6dN~X&-SYYRL7hU=U-n0T>@Rga zL0ORnLjQZA4t$TOu1$UEqg5YeaD8;Ylow|t2`q+2CNDQu)PBh9w0RWc#dNpk&acq1#7j$wiG70CUdIr%91u5BWv!OCdm1Febxrlg+Y#mPw0aXSqUN zX_*iHisnd)91Z^0$ai37eA(Zh$O4TU5{+#v4zh>~f{)3#>=w9`qh{N^mNDpbz?pON zg1Kp(fX(uTwsmNsTaaVzoLOduPZ~YUkl?jbv37wlwrx%6E}q37EmWu&<8#dt7gvnC$+dvU>GQ0JYV;gb$5=p(ht+Y!W{qY9+CB)x4v5 zL|EC*#j^C)P$Q~&Iml5DS=lfL4W_e1wMV>!RsuKgeqp7p^v3S!qR&9km)S7-BTSQ?fT92Z*vFM9V zG48PK4&&*%EJqMWx=G!y?GQM(oatqAoaIEMJ+YFfd2SNXXzykfPgicQ9|%=3jl-?R zAvoQ{_5RrVkm$>-BT08?hpiFY8_{(@dmR=nxmkzf5@d zuH5~^!V+Ejre&+Jo%MslA2oG6y*3fXwciNiM8^+3#2-a7 zCni~587-JC&ryi)iBgzIxL;av9lS1w60N&Tj7ZvAi=ZoUdWqO;Y_-4dTgv0A?G`28 zT@~QCJ3q5+Rjw&I)7Xb!#_(OO?QRX{2s*AMbgcHpaeG!{TFZxSAe)e;WZwIDXmU>H z(S4c|5iv(>_cwt=vn($Rrz(1O?;!)TDHK>(!6lk$x&QTR>?fhHWPOk%~S|Kyq~oAc{Ht*IX?CX9!Q3?h=-<8=2w7WGUl_Y&jmf1s@uO1 zVm&;%qibdo*X>t7-(SiGfj12dK};(-t+>JubVJ|$Pp=+XLrtOz;&?{Wg?l?)wanS_ zfV(8D9u+- zJ$CT8!Jrf#*}KtHgMA<>8e-k`{JLJge-*Xhl&dTSC{jo7WC}yxte4k0mh(jCRBE43 z6weA|2|k%U=?cFKlq0!_-B~F(_|4Su>Tg2*`eCV5 zFXiu|Z%hCiZSDQ@$TDd96VPlVmx;|LTBd2C)98&e8Q^GwLlhe9lVf)RW;osQ{eNQH zL57E_+G^fqXo0Z}J7{Mw(=eNVHSODl|7Pv@P7`EzjCFW#dabO+W9>}{_U z6gwxaoHR>SON~!{oI9E#i#qXl3hVdYJPusy1ZMdkmrc7<$};bUh~dDGF;jo^)t-MG zH0biV^W?vd8Rg5u!pCQ~5)$nqx7_UpH&7e*>AniQEOFDM%JVZBcq)BqB)Y%8(ujrrEzqctB$FwXzvJ^z09;X_~%><@%2`Qgre3+WC>*8l1Anjel%+j~|O<7;VLHadI*`s8L=2pG}fq{uB2- z*KLosE>R1ueEZ*5fcZF=Cw3_1hKqH%_d}5_`{w9En6hD*HKJHs)jKO>B)w&P2^+1yfxCi((mxKU?kE< zeGzvXkEu+>n!@iPsiQTBlwnHS{A%dZ9*7a=8S%bKQ@C>>1F*RXl zoqx7H(}`r1aOynzR&^i2_;FpkO-X8W}`k3a(Co z5`iEGZuuYeOZ*yy_tC^G`BWKEqr7(#71wB=6ai1>eF2Ei7QPc=U8BL<{(*?bHUb?0 z84K3W9tZ=D6bkR26L|03Q!_Yf)(tlPzw%(dv#%-2&}K*6nWYEgbUg zz-+xV+tj$c#gOWQ`)SkXm?=_qDc3y~*IAeQK;!M8D+NNRFQD6u-wnL>yMb9t>MpgQ zExWBM)+h34dK$fxyXzk;8L3-48%Rw?Vul%F{w3?PJ>;Hh!o&6>S~F~?-|OugQwu$_ z!&tN0$Be3?P{0?T-PYf0oC-nUW{G{A-Iv;BFxX&3F+TX)6l)cosNJ&frH!kPFPshX z1#;egCw+%sA609g!*nElaR`IZ8$?6|iW}VnJ^C(aT1}h2H7g&Ix^&7MmEU>tilKUC zM1-W&^YN_Jh=gR{e#WaW&yAxW(ZCV})w_4!6ORVtL#@DUA7kg@vSA3HDC+0T?&Z2&s>AVbhenZt~tP__a@C&N$@w^JRs$ zyyFw5@yhPye78BWMGBgIWTOt*Z?5b#m%`J-t@`U#RD(wrrFcTE>+Avp9>)A3^Va|y za;WmV^o_dv#jrD-*E(jMkIz=_`hAs*3v0jl3bw6D8+4;n`40QaCn@~e$$=6E$*2KL z86X+hIuimEaM|v-s^0P8JUM48e}R0e^1DJeGk&%BhBLCs*{4K#apY0P$9gTS>f|dv zfcB71fFw|NR%I#_$@8wsc%cvJwd*}RCdWt02?v9&)T3%di`GPxc0XSCSz}*w^S4E~ z-UNab+}d=zj(jD$OS?|y!q6}HYz(y?DcC{iTgTN==D}x&P#T`_ z3=Ue?a_H>5h&fi2*mzS60#Aky6Qe!^Dflkb+u_GaM(h_zP4;4%d#p*A7{*+`e&PZ8 zr=&U|hBHJ>-hpIwzPjG-w+Wdm*&VB*wAnq(rEOhi*yG}nBYitjp@4Xt_phe9|0O8O z>x_pSGGbEpOGx~c)3%E-fg7v|1Cd@fefI;pnBAr365UK$a)u)GJE3RM7i=3Ay}-(V z5<`c#(IEzzEFZ$r%;wCmL|^To9_j@w+=hG?S=ZU=KstGTJZQJ%c1lC$!SQY54Ej7Z zw3~4%3=_{BjzBM6RpdTrh_t0uVBN{}Md&+9<-(hp#NBYy_|T9;SVGnJGPK+eqMQHg z2q3B2^qC$3=|(B;MtRcSD>A0{n6gpxt}O)I{Igbxt}U^%%OzNwyi$Z&-=~<}0xa06 z%Z=Gnk-jNrMrNpcGn~CZQ1K-gZ;-_Bwgh6!Q=qCt0#~D(aB0$KF|^}-1LTQQ&bEeO zoNgSR>NXiix|J~)wW~R#GI(Qeg&5IQy}il0{d2ezXNkP-!(atvxYv<`vrwH(?5At$ z=(BHpzLiTza8P5t$Sa^G&f)NecB6-&fqs3;!Q?!uE$!(Oh&^fi>YX}oRTKKO;u*91 zRl}2sV?o(8rgn@IBTnlPBC6Arap{R zBgGb-87xO0o)@`|oBzriO1ivkdh)Al@RmdJe1X4>^!c*tE6>nEk%gYEUcbtNxRi=9 zHhoqC>jEV8&r$p`{=+yl`eTccgS$kl{?}VvBU~5f%%VSqp`z(01ztN3n(g4*hPyW_ zMkHvQ+j)`av3U9h=dyUJh30B$Y&Wh?e6Mfj1;Q(u9}8{Aw>%$MsEy3t3VOeq$#@!N z&^V+Wn2E2)U*OJa>|_u?E193%>-JzP4A(QuxEi!8k&KT=U-0V&3l$q3pi8u4j&aep z*HKF)F@Orc_X5&pW!1zBvb3w~%J$v#0=za26E5h8qe~UPTby8Xc7D5ca1`I8Rzo{K zNwd4c7!r;){U*)-Xl9-`2wtYBi=i5y!OP*fU&T0K0@LkjEQh^H2Ae&(Y7U0a^TIcM zCj_nih^#-~=hzW20F=;#&gxYUB01ogNFy;>MUs$efZ%6aqF0w0o>W#ji zS-ktRM^PvJ^=O?pKhGaq1{3*2_ID-gblV zNU4)PpO3a2I!DehJlOvR#=S&LK$YIf{A6`1>3C;{e82-ykK72_ZLvE5PHDk%vgQdR zw8YbnW6hj0mldjOPhUA6htz%&sAxg!vhsv!1T{WrwVIBOk;IjSmcZplgHA5WF56ne z?^?9GF78I6r7n;-dQ#PF+1`%&oh`xKv746Th`9f=@anf@!64@8FoMIDJ_^@z>#{)P z$5MWpV|vSQ_lBZRAxBC0<~#;E+iq!m13@R<^&x6-=|Y;n>a{1_5HFg)-4%|4UkE*3 z(1&q8&1TrrCn>&%2`kS2EKiWL7RR$JA~saFqoN=gB|~=^J#r%v6u0|&;pH!k{A<|q zhy=yYmuZ5ltK2#Po__t{#5JP>H%A{To8qvAVwKARhW9A%71?D6i+e$LDq5!^Fx}#P z^GA8Ar?yoVm35M_OSKpWqkFnR%_}I>5)ttfaXpQNNeN!LR91atp3|nJyN<|M!_bc9%p zGYl-)o?J2&DT4*3K1si)KK7ycloN}nZ!OvoEyT1Li1degIO*-cgEXd}LtMl!mBDVu zR!tfLRS!59%)a>c*qS4PqhQhJ30B;0v-^fSe>)bH9C(K682R_WEPhtM&NBU!!ZAbN zyoQ5m@kZTpr<@$?l2Szol0i`fsjXMt62+u|Wt?*)v>9HNSyC1c?afR zGL`5)t8#ICJ6vK*zkISm<_7s0!e?dd{9KNw0fyVg4m~4mzJerKA=Zb>YVyg23ePEy zcXda$+%hmJ;iL2A#bk4 zSOwu)#d>|rUV#-9?9WKFXr1LPz-hGTU62S4F#fU|fxR(BJ4$};^LkMKR4OsOh)c9C z4NDjBvEHEZB81u;lzD06uAajY;Y4DWyQEp7H-2X+RF@;bf>PN2j25V}h|CbH%Hh&g zJm(p|lV(!8<<`a`jLPnL&09Ie4!O0r@@C?-gkwK2Y_tiZP}D+7SY$5B3_wPwcl>`c%I29E?i5#Mt@Hpi>9nw?9P9NSYo0#xmmKSEmQGrdFNl|`r- zFsxg0Q7Lqx&uQBo1g|ly&DWzpW*w1U&7@aOin^?E)mm*LHm(At&qL0#dgi?Zvy|`o zkgGBlQOHjL+MD+(D$*=nv|^k#CN!D^{)+K^S1>2af3kzJDh?l6Td%ra1+RR*T`*|A zrLQ&$Uh>A5mOofvNI@Irq@3PCR&-52Ko#3QBuu)~a~0BrpFy2o?hqVwk~6XOW9PRY zvP+_*Oe~<+rz3|P>xA#8kZXTwM(PezD+akvg~T3&!OYhi?GG-kvfMsf)+1E*9=$Iv zdTEr<`6;X3y6fQwCwi`RhP_ph{x{5(dX?D5k4sTrKcCdszMs5Zi)W|Q6|c+-1R@({ zoW>K!(tvKMpqJx)|FbElY0DMw(OM2T?KrJPl+TCGQ@hj7MOmp{+_r{- zI$HO(D^DyE*nK#v|Cp~OS_;tun3i{TC!2*LKjk*osx01FgkqdM>OWBf@bE_4g&4D4f@D03RI6*nJj=2n zP<<7Akg7yFe<@sk%iSIiJ2&dwO5hmf0^FkOAQyV_dQVy1`@KAc6MfF@MqThZJ`Y#F zAaas+(BRB{yPeawIO<*Q1Nf>v@PU~>h|7&p9#h8M10~Ha&Nnba>FtZCIRW#(W@O_q zH$j5=;>f`G&mt>I39Jxof`SsDmS0-l{8~5uApb%fkQter!E`(?a>>+?Ec;TI>1nH& z0RrY4Oqp9y={2&jr*4y33aT3d^lr)p%2Txc@Ywl59ZItC(?So^z}q!ATO?#2s2pyFaQ~6Rb#X0f zt4_eEUO2iz$;(Rz;1DlISDqhq1Cb{;$SJ_ANSoMN4v->-l76 zD1whpOTaD(sxYfuyP*$(^u{2P9F+qr4ULl;K8sM{WC|N4%;Ba4EdUYgh0TAk4cDfO9Bk=f<2Bdx$ho zblX$SKALi3H^mVPs;(7$QHql?o^vdb*&)qXGNuV)V?4JFh|gj$5_d9CSvB$18-lL< z?y`dR&rY-2E7K02ZsfBK3J`PcoE?z#@^;QCv|J_nZ?7zW7}3F`eAva*RQuPE6%RwAA1@0n2MqK7Q%gyowS(9TsgOoCM3 z*%wgH2h$Fu6?e&X9Y{Y-di32u+S+OMXbF059B_l}?% zfI3d)=jim3|kr`Z+t^OmKxOBD)m#3_%?6|eNYpL7>{gqwu>od5Pctn-aRjLz%(lveXA z>3!ahJl3e1hH*f(mI}qn#RQLN@@o32B$bSZ| z2dZ6=bR>=6!#ZjrTc(aR0^E`|evWdZ0Jjv~C#k zNB%;oGo9tMyzzqa%J(kp<3(@i%iHDmua@7zYGFdhsLyO2Jtwo1>u0`IE6M=HD+ktj zd@dX{tIh<1Kx~yo7~@{seyx^;JYF27zzvRPuQfnfClQ`loV6X;leugmyIvl>2(L$@ zrK%Psn8H+h{CU{ZW())P)aL0EU3_X2-S<$8C(YrAJzYv;C=Ps6v$e4#6hURCP#e5Y zt7b8#MQPQ7$UZRRp6K~kA|KnftH&)UVo!Qi2`#!22!ePmZxE-*Jek_et6%Ox`o)U4 z4{=e<1j|9z8hgZkp!B!(aV?;(<-SKqeD5BJnqxXeUXYBh)8pkynOnB@oT(C0se$jT zXf&O|Uik>W?8ZDJgFu!6WlenuTdYgIzC-;>&xgBkEjs}+AFscvadMrJzS33YX8^&s zllX|SE%=F8nqWJd$sUaflo@Ky+=EX(Hu4}_Kuz?{aW3Gb;mdcnKZuWfrb;ldk_6lk z9ykekU>v7lmm?m?yM@5LSAq;o--QCV9uPWeY)md$SA`djnNtoHU9CZUjM=fLDqo;g zl)Br~4VFtrt9OsKC)3(jUqjCVI?rOp7qWBT)=J(fM56}enPPcrHG^!~e6?fBV zcH{P^PUdj_Ie^?2-^dd@I&ntC!U6PyvOqsM`d8}pG0TLG1l`+Pl%M!Oa<gRUS#7sWR~cZuqTIM@>=&XmMjsMLi>!51B-vi!`ca~1ZR`lJ+9mbbd7bC*&yGV zYJj?0X8-z0)FYF#y(74{C0PIM50WCX)kSXH(f{#`$+fmF+I%wx@9*!UYA=l_Hn* zo&Iw+`nwUVZ4(xTQIN53HxR<%U$4SS)8(&ML?bdxDO$*nQaF2+8RG zkgb4kDHKBzzRg=M2k1l2gpiD1fjr#|(TLrZ1k@6@=Mi`l^uq?L#WowmUQgDZuClz- z-dSdeCrD5&7oZvCoOQH-PGn575oG!4BC29JPZVkj(_uZokZRcEA!pI#Q7s7w$I94F z?R{kW2^XWiQ|ISZe`PEeX75dl*X~00r1YI_1ZDcptcse!b}sx*p$D%YQBV z$b(4@&&Im3635q*(fyvBAyhpc;=-3S@@c`2%LS{K!jjCzp|crXB@TUD#tW#k))J5C z56dW#GG~pAlll_cr@Qok^5=7=zWPB7lpchj3GWBvkJI{aJ-jBy zR7slZQ9!@;$P{r8WC(wN^sy5&9P}o3viOw4#e9Ac@Sv2P!Rov?6`LyZJS->Z2!u`y zbun~Z>Dl^XB*%~R3Kv!ZCBJqAHzqj5>#PH@a#4yMWk5>A+iZgCFJS@fG#Xw^bYW-tF%VfqHlr&bQl~8!@OHrdU#q#1sjymc?ziW!s`kq+l6kan z?FU8AW42T7FJ<&q6PD`uxc!c2tTtZc&*PTO}SD;CEUZ4A0(^#15;oyw;_Uj2+X z+x%ujG3W2uk}PK~pIg1qZteUzs|EINh`n5M=X^xUvlIIlW}d&pG2uri@ceha&x(ox z#X3fRnkw}tK7E^>LB$ZxU z7$SPI#PnMJH(p+zH=PdKC*N%7w_Nzs_o%tjl0^S?^|6QZ?@Ai&`#-(YRe_;zy42sp zflc4|7*;Ucx$t2BYH3*B*ub)Tp`wWBoH9GF8NdaD6FM`UZzpe6m3);L{9jE`f7a9W zuXZnFG-;naao?+7`C7o!yFYHPpVPBhw*O?TNb}zv2Op{JaBum*|D9_~Im}ET-N66p z%RkMz^XxA8{#z^js%-bhaGO4R2EG;2%-c-r>()po_oW&)FIoBTmHmbPpP$~pF#Y58 z`X5t&nwM`_xbWg0@Av;dh`&14vcB%;WS2YdKFzsconP-2|E11#|1XFA`(C`zKK=A9 z&yGyyhGoK+?2+sR-Y;=sOUaCLcV9Qnn^DiCFyE{ccvJk`k__wpH8Z4}8Xo>%_Wx;o zz1M%Mf4{o-oBw~tXJ%qD_kCTc#P?g>*MZZ@Kb!J>eDY$V`41EdoI*2s!J3Q;E&rLPB+P%;Gwpmw zTpV9;`IPf{`74wE?VE42C1N4W*-Zf-YJiQL2XzYOx&=FS{78Scz696CRFe0x!Yo0e j@ojrWQU+sQFzEPKza=+3XrIrQsUSg5S3j3^P6Njtz}VO-b?SPe0EE9*6RH3RT96tRpoGusqM9`1e%LDT23u zB4_`^y3rET-=1_yvkotl#gcY^pE*5MWaw|RoTzWD%=fsyt=UqZ{x-`EK-QY$`U!?L zXY~DUKSq|z9xA_eIo85*9jaW1DyP4@l(O`9nkvpV^8YoeneK1D;?v*maviFi`#V#W z)8DLvpDCY&XZ>&LD^}&wZCRoF`y62;k4Jy&`Yu5^>gE6Tqs;D^tlOEy4kgko9{sI- zk@Zprn=^jmG!I(aPE4^2UDHEJGyjR&8}EGft3Um#^r0yeFMj%W=@+ipQ;jT^^E{6K zDOa?=2nh%!#?LKNCVleAzSA#|)c*g*P*C^9%#FZ+2g1)oB?rQXp`i!DJ0SEx_?{&7 zu7eT=n+;Lv&y&b`2?{un{0Eb?f7!tY=BEt5s>}RJO(N%}B>1u<`ne+se?yY?zje@o z+xh1tdfSUeA4m^@fd|IVJmkRm;3V<`u*-qu4^AR~YZCdlCh6~wN$m1|lJ;DhM4y8X zJ#afePtyL+lh|uklJ=aEME+Mv{C`0bJd~t8KVs}2NYAe%(F3Q81MzQ2;y({3k-s}h zzrKYY4m2LuCE+hmqR(HWod=ThKoUJ1n?%lgN&I|T68&T*@z44s^$t#=p9=K%KF?+y_PNJ4t_cCTY*YB>p)i3I1Y| zc7B_r-j|cefjT{Y{O|q@OX5G2eQklNybrX5fFG*7G^GVwOeG)luB~$c$9hXGU(_rue%`a_9Y2@w10jQ{XCweU#}&xZ*G!tG%Jbx zNlE-?T@pX}I!V13CDG?`N#xH+5;ry{skbtTUyV+J&rA}xE0V~sN}{(zlgK|PN&7!f zV)v;@@PC}dzE36T*Xv2-+>)ffXP`ZP{O|r0 zCh@o1l8mD@N&M~BB;zP2iJx>Osn?gJ-XTf&k4vJ5d(qJY#lvyHhq{#jI-bPe<|e@p zOVZy_N$gmbL~m_L^s_LD-6Kir{Va*za^aQy&|2APt&_QE=i#1XJZ5!R&D@&m(s|(-b>Y%dPib)Kgwk0RbrsiC%?nr5O`R}iPEB>i)EP79RLHyo=aiP$ z&nTT;RXt-))eT@QURXL2#ioSoBIRLE@xswF=2c9Zd2K~`xOD2m+6o{=RY*^)Sb*f% z`ts7EirTu0@)_Z(n(FB@>Z+@%uVF@AT`8$?HFa}mPz*U)9vL-tilI;Dl!a*YTr+!0 zMHsD+@X`yH6=VFTv0l$y1cTY{JM%+<11LrxVjm0D|F-L&zMs>7XJuv zY(277N5C5hhuMr!P4zXUX!Yfni&cAQ7|$pYH64WGr~|4>!D#p-A)~2X3Uv0PT9YX?JueTQd6$D$5o&# z(o*ZCv(evDXe$1K0Dw7l}V(%Cbr*eUW)q({)z z5{+YqZfGftPEA$Jq_*Z(%q_27hDk z3_TTqaIC;Qeo+QGKB>GsQdd_oOJ}Oll;{hcQ2Q1wIyq7uu9{o1|Ckb9`r;8FREHbsNUi%&naPCuZ~;!+0{e z0>+w$krS$#TSZN&YB*N*3UGJ^A_L}r%HnK4ffWek^u4@x5!%P>Q8j<1?uQJolCP7DZPeo*mEI=1p}>BOOm z`4w{#LRG&JmvjIVrIqu_Ditv?GIu7%f3SL11!Jum0Zw40ZA7NlzN#EfBWrg0IliL0 zqOPhOIU-I&Ke`=#GNxCBE7f=tL1Q%IjfEMICQ6hLL$X+edxcG`F-!^-s>wimLtx&t zspIm{nlTLh7&T+()`mGKIHnLmgcqX*F)GkTj=0i`t7{fiD=$pUDr)#AG*dhWp>0BB zPPnRe4h5TnNp-V02cQ<(Nyc(*C=p}y^sjUXwW&xmZcfdN#Nt5ZCMu^es2ir9 zQ!%#!kztk=S~>|+(_BmhX{d=n^RE@9%a|SEV{;&it8g4)#VkX z+H(?~A>tVu!>*~>T26l&oHAp6g@eFgQ^Ga1Fm9b#)Pc(}4N(>Y)3oZDHIeFBp_+0h zo+erW6@=k!!YXpM#5kFVwV5i+q}E2?(ILB|YBXZz=$aZjrxeA9kxN6QkOgL5Hc{+{Nc}=(mOUP2Jc&@1~EiIQTC3oOcG0co7iFV4d zC#P;5kI-PX8WXXI>tMAabH)e5R=pVq$LNq>T@}_1kxDA6n2o@UX>Lx{%-XP6To0dD zGd!DgIaB9)#)pEV$CQp3e)jNl66qW#>7+&s&-I*DSu?ldtT|PYd6hG2Zm6uNK5K3j z*U{CpW}JOiMfLo7X9*?Esj80DgKZ{uGbzS@sYcqw|2JtVtDj5afoeDqmV#%&|Ebpg zNjVN&)|-_7Kh^Y~^AB7jwyolmf}P_`_YVZ)A3y9;moRN{r_$o;OC zqv?7VUi+%#Z*}7@%J!^t;l&E?a^r7G{*2td^>)4_alZ?1TQ70Tg?rAG<%?Z-p~6dC zc$>m&U3j6AujOeySleZP(^NT)r+3Nr=z26hMe*x;G=8hSb>X}JEb$H( zevOjT>B6;~9WGqU+3mt>l$;(HUZ(YMUSGSkzbf04;ldXxIer(eJh@DCLK z3Ky>V*SPS{6#rTmUi`GQ%Q_d{)+zB$7yfT0XNL>da=Ki&meb?HQ{R%~-IL!}&t;#= zdedC^ZZ&@WF8pvMC(DIrD?iM3$7k-kGQ|!Y1|Ca6PaN%bu{w^2pw`6~8H_iu| z_++VX9j{tvNcnj#{Lz&XuXo|A^t|B0Yk9E;pY)M^_1UHPGhF!Ek0rm~g%|%z;+6~d zjFNI!x$)I%CRX{nUmw4z;<*cN|Bb}`F8ox*pXI_^#mzO3r{0BUye8$ex^REHZ2vkJ z-p&hA_;k2%{{^yNoi5y?aNC6!Ua$IF&{xm96`kS2J3C~1{4U)8Cy85byim$5ap4WB zJ*!-}XQgb9u3zhaZH;QDDwn|3x+Tqp7hWgzneM{d`2YeRttYpfJQu%br|g$*ujW5T zjh7W}{`+J**SPR=75`cnzV>9v-|514b;@?`aN*fQC4Y|#AF1SfF6?W^V!!0~yYMlJ zKg)&td65Pm%Y{!={KYQ3^LWW$>%ylf{(2YQp!iq0@GBL6n+wlAPReh0;nNj=hYN2# zM)g%8PPV7Pg`cG2!wMJf`Bd_^ zx$q+u{~8yb{-M&33)k_g!-c2wLK;3@E?mbe+l6NzEcx>Sef_FL#j9c$-lo>=^)9?s zjnf@2eC?B>Ii4;T-l_1k(S7S}SG48A+nS^vN?drCS`X-QZhz=-@u#ae*5$&rK5ZA? z+9LJi8Pm6&TAyhyykU^!FLB|mN}shZeC_vAKWkjLXRNGmtqboel6a>JZ@)?Er^|(R zD*i0>t@YEc@Gdouv^*`x^R=qi#owU(!FJ)TUr7GlF1+hziR*rA`C3kf zYL~`4d0_w_-Cm8)QE{Ns#b2xRqx-G-!#d8m_&pD*e!1|3pSbYa-zq;Dm&8w8cvpYP zU+BVTsW@P{@CIH)WPe@wZxnx}3$Kkx{stG`p!(}k&#|>0YG0T9Ylh4A;}AmJ;TM(S zpS1>#N9~EvIs?Ze^2Ddzz|~QO$m=lh!xG#cPp5(V419-ypJ3o!20qllZ3E9S@ZAP} zo`Lrmc)o#q&T{lH(!kRUe3XHw8~9WM&oJ=m2JScT5(CdN@XHN6+rY0h@H_**#=r{= ze6E381}=VRq4J6ie1XAVV&L@#US{A=7kWLVfj1cVG6P>>;42Kg z)xcv0zRJK`47|<2Z#D2W2HtAmYYqID2ENX~?=kRp1OK&wcNln^fp;4CZw-8hfj?&8 zT?YPp1NUT0zs2<#oN+pzGy|6-UFM}5xGX903v!fWSM~WUuEFO74E!_$PdD(> z4LrlZ&oFSmfuCvMSq47bz_ShfECbIo@N5GwH1H7yZW;L523~C7=NNd2f#(`{nSq~c z;FSiRXW+F4e!hX%8+d_%HyF725t$!@w^waKC|1Ht;M1pJL$I20qQe^9=k_11~i2%M9Ey@GA_w*ubwc z@Dc;R+Q7>Uywt!e4ZO_2YYlvcf!7=OOapH)@NxrRVc@e2yw$)f41AS=&o=Nj1Ftmj zH3nW~;A;*1S_5Ba;MW;=yMfO!@D2m7G4M_UuQl);27bMPcNut{f!hW?&%k#Zc-X*u z3_N1sp0geQpKsu42ENe1(+&Ja1J5wtFE;R-47|j^Z#M8U1CJVbrGejK;I#(+3j?n=@Y@W$!N6}f@D&EW(!g5{{0;+O zW#D%jc${(ymZ8TfAu z+&1vl2ENd<_U6W{Yg zqW^xHX0=v>k(9hwhN;>#WSJkoUz%?By*nGT&#da^_Ffl7R|Lysgq!l6fz9_r8q zqz60n1*B6Qnh#dud%jQfzmW7!hYpb5?$D!2Z*=G}q@Q%?BGRiJdMxRc4n2d-Z$ z_w*$C&j%9moeq6H>Fo|(M|z_}&m;Y$Lx)MPcIXJ{l@84Z4Dsa-y?}I`L)Vj@>Ck-e z5TESOH;^9f&^MAE;n0gn4|V9pqz60n64I#-y_EExZxj7*AidL}myzD?(9210bm&IX zPdaoH>D3P1OnPO4?mgw!cTzpGeJ3JLaDCBx%Bk=6rN_DG3taTME_%3&cFQ}#m4B3r zKFmcAaM3@y+Pl|9f90Y-bn?h$i+;gHKjoqychL{K=m%W%FI}|T9yhu2 zm$>NpF1p%9&vwyQyXZ?@^h6gu&P89~qR(~F!(H^LF8Tx)eUytn%ta4y(LcW3*FX2V z=&xM#r!M*f7yXWle%(cHbX{-uk))kWXrqL;Yn`7XNJMbCE8 zSG(v-UGzj3JbqTg}R zue<22F8T!*{gjJ-+(kd^q91V4zjV>Jy6Br+^b!|6-$hru=-Dp%Y8QQ}i=ODB$GPYW zT=cmvdbo=|)kUA+qK|UXhq>qhF8W8@em3W;y)ODI7yYS={=h}Q^7`m0@2M@?*vcebSpMC&5G{oEza&f5r-?8C>CgZwbzQ}*{iU!hO{)h z6k804xuPiAbyeWXz*T{(H*vkgHvAZvhT1Q&e+3pRR-bP7Lm?|RGkgN-`7?eGVzuP{VG_Pj)m2!;j?MWp-Y>=D3B}I*;EPnxgyt{9 z2M2q{dg5PU*#+LYwW*#^^jkXxy$quHXxgh*benw%>E3~v?Cqh!SW#wLDEb-tV?n@U z=$hS$9kMLoYq}M(0_#u82572xhXIerk-{Q#IMEQTCl%?v#`FgIeVdOR&xoek?M^2?IUUK z=Jv=@uxa5d!lu6|mNt#DBz?@ND5NWy9=H?|g#(KYPMd<$y(}wsP@rW=3hNta#Ts~n zI}rV`yW1-7wKja#&pryZZ7a$gDD1b*gOjgbv?x@*D0AS1k&DxPEzh9G7srZz$gpDT z(!ga87c3ju!~wl1*}Xj&8hM$Wck&yd-QPR-1)qM^)m`&(fS zk};50wCEq6mN6;TDr;NO7Flf!kd?nN{HWEtiPF!N)wblmEL_^k2*&znTCrkC@Lu?` z&`3_Z?d33mOP=|!-rmNJ-tJ?qSd_ht&p|uwZ>cfl`j89PY22K3h4O+x=_Y7s*%y3A zrPVkv(}VP?e!_{5`4}OrJ8aJd_EtjOtvSR&D;n9;7ZOUAMGd+5tckObpL3jQX z!QBC9-?CKC)}qXzm=fk}pomU@XD>oq!Iuu{9^bJ3nL;-I*?|hu!MYJ#XD*doJmK^B z4ll~gBF9Gl(`7YoB-LIO4=5% z?YIHbS}sp#H!M$zZ&*`i8%hX~{HI4Xa4UG{fERtcD8+YpQ)Y+a676HpKR_o@_cn0U ziSjr}-k8B|m+_3pYN<;Hm%UK7p4)iAwFBVEEDFY2PYUboA|I47ds|cHD)I@`26`<@ zZ*9uFS7W<@?X9OoSOuUD|I1dlc;8tf@m65`kY_EvGgW#WL3~(CI}<68ypaiV?!Y&X z-k9#fH$UXGnIPxqOi*3B@h#K^O=UmZts$q38e0A)61a!~O@DLW{#QgPB({g5yl5>Q|>TboYigiaT+ z5s=-gN^G?nw^H^N%Cadu3pqRxgqZ1zWs4ctb&IpWycI1zpJEA8{}00}D78y5vc+WF zMuFMnRLnhKz6Z=~SRU~daug$VGzg|kG&j;^NT<-)e9N)Otw(~VrQ~cdI9D)DliZ>? z+mPV7H#yfBoNG1blbW*w2|hs}XQ#orLvy}|glOk(Bu-YGJqD-vZN3;0X{k~vGz1l} z0ZmE;CN#wnvJ@UkO=T-a>Yt2a2z9av8OY%QC74SiQvW52d7IU^jm(=M^)xM&gXaNd z)ds~#*COL)3iOi`9~!F*%*!y+=rn5-vo_Wi8YPR&iLo{juJ?whgVF3`|I+16W}>DlLHguwKk58X_E})+%OgpiS&t20$s7 zhCf5ul5-Y|YXfa2(M93>J&PCzE#9w{m$WNpZJ;e^t@wE|3o*q0Raw$jjJjJ}DNwz@ zL{!JI{}7njutG4)VN!zBF(AlYMid`%R0Ymg9e z6s6W0oa@NI5b-QQ%Irjfc42yl!P&($y<#U4LS_#Vdf@99FSDI#{T1gSNQmh$9SJH& zn{6A39@gMT4j+#}5%($^=P71wHaf!yU_t_&p@NLCZ<%7$Mib7EMNY*`XXu_UJ!get z)B%!?j4A1cI94Uy$L491Vg4H7#d?xvP*6aRli$gL94Md=v>G zvmFVn)t4vxUj}e{~L^|afFG9Jtuomx zmK2fOB7@LS8B)48m8uvUUW>HocO5}CXNAGpYH+U7ocC(ZwMb}ftur{=ndYe4h=izp z2NK#oT?VJEIr*mp1SkIh8yB!_Ng5OQu$}2hi*^nsNIPU8K^LQ<*eL#B%tHD)#VW@USUbVG0jztJ++r|L1(e&Rn8mEmq5E&jQ>%b3>Z62$ z@j>1r*UJcyhHDUFT?OGA*lHUkP#qQ;C{V@%DPZ4+NfY*%30jO{#^@!OamlnoFzFtT zMhF1sEt-?D=~uv5e?36@5P2Df7AXm9$t+MddpMd+?gq-mhv_y|lIb-HM=ejXAh8Z4 zL<~Z@Q{}U5JD8>?y{9>MBf+Z_EY)LhdY}lwnTmvvnSq3Mg>0nRYCR}7L*!{>B-n*U zAA_#YsY(>14wGA0j~^gEWad=(DXd3}H7I5sCbzQ5S!7Nq`4K3Ca`~qjSX>86XR;_n zj+mNSyzNSEr()I-h9P7!Fd>x&xt)xV+M^hCw?sIx0P@4?Xr&x5vth-=g=Q*|(xZ`o zi;5p|)C&$&b^{aac`Fj!b~3%n;B3>Jt2O63B=r2=Zg6&J&X+Z37ZQ4gwGGbQnsbll zOiOcOK|0d>u$>u9(<_caLIhnu66~)w+a?k_*y?QLur{j8Qe4_z^n%e^M6Jry7Q!ZY zbQ&e(A%h=ESf!YBkQEj$B!g&1yUNxfNo;jW0Fr~{ZN;GDKP`K$$b>tkqn&Iwo0pgz z%9x7}`^~>^mLhD?fRwi23WKASX=-LAS=stENN9boH8|IiL9CGolC#s`++lEbF-@5} zkq|O_kkF%5C|9*Fjfy7cAxH>LKN1|Il%K_1e5i*!q}f%@WOC8MOrgUvmBpx?uA=to zPl=$!zYiti>I#R)o6AUels645l*qw+XN}rRfQ_|ttgcl>Hjs&f_%nn=)GpRR42L&g zBMTLSksmg5hbjbnBA}vR4@ztiyEAmCgq)17Pe2swpi;=yXJ+8O_;PTP@jf(+hHMZe z$;tuxJWwz#ClfIS(G7EDYia?~e8kzcdw^5InuG-Q)^?gl#74~6;j== z<5ZZ|YEz6lcy3}#3(2XNX@@BEO{pD;9tC;3UyqB!(*jgm? zT6&$q*{(S^YR(-<=rP-6aN3&lbInPChoK_MPor>r*uHe8Sv&ubsHi?VtA z138mLF>=^TFh4s-%I#9j+CZE$W>PFA(CpL52oFiaBu-3sOROA9$f=k)P+x`bv0-Jv zr3LGe(nF>}bAw|A)70TDWM$9WkPy2{q}LdnYc=PSOpvn!2`#hJ;M}1(-$O#k+>Hd! zMp>%I;1nwo)}D%93C;{8bm;JNy@C&WlEpMRPa`KSk&Ofuq0P3H#BSD5h#anVp@{Ic zQfnoOS({Cq3sDja(HYtimMOJCF>0d;XRrYBLuNX|bvP%YE!HSzZ8YHw#bi!6!&~1o0Qxh#jLwVXSe~FkVkvSeO}{>on)HnzIuL zz2(_qaCT|Votm=;2|b)eWM*ejdm5uOEqDkLqIN$LEY3D(F&7_lW^2w7n%YUVLQ`dmSsP0%ekh3&X#O`<3|^rawV}jHxfmcnWaijksr0{AF>7OO zU`tELEaYo#RI{MfC)`8 zmYt)p?2%pCgz^!iINYXgY`)G{&)xitI@mr0#>DOT-w8z@Vx{Oge;x{i5NSu+hkxnaIG z5QG0MU=vbl_NiA%so9EAcS{8S1~vd6O5oUkxXCKo99LIPv!%Aqz57nP6@P68hNOPY@q^SeE8IO>-6^p&wUS z24}J6oXiC6TY?1ptIg&-6sSZF-3^NPy&6{yidmbD&Ts=IQ39P|5g8$MjbhYB6V6ae zPQ^@Tu$0tJ#jK4coS~k~31^60E#>woR&6%N8CsFUxs=1yk4R?riC(Z8`C>A&RHp8O zu>304h7Yyb#tsmCD#;MgNIBVYmih+;-5iw#w(R4TJSc&~k-@gH~3y0T~J}H&2J?vn!N_8Q$dh7P9*d~X@|ktr8##ZA!PO#oZ{#g5-2l` z$G}wDAxH>LKN4DI7IX0-XSU`Xp*bxibl5I7I7>9=<>aKo%aCAuYZVvM^(sx-4I+(J zEN8-soz6RR6}OD>A2Q}7D|RD(Z8|@V)prJXf%KQMND*_bJDqQeRUuxkh@o;%&#_MY!e|c>(h)t~AzKv9-JrVm0p# z|ICUlNzZx7%70_Y2y5ij*E7PCt=r@C)%;Rq*Vvq1YvhpIAWmK< z3}=U8>(U`;0@QT`nw)_&t_R+Pe{q|z`*8e>jGDb{3C*SQN#@Hv4n*rUD6t%C%EB|Ffw?yiVhR%U;+4aaF?6vGL8{SmU zJA=sZHCHp0xF8!Z1u1Gl=n&PS1=fb07xHFXx_vO}VZ(yBhnjBOL+$Q|o2?cslV$q) z#jitjhmFi#vgipO~T&GVr%F;9R1M`?S8b=vIhzE z;vO;XO+%=!iP!q9mZ@+@xE}_@XZ8&YcCp+ss;a_7RgpsjjsMjfIhC~{Eczk`F<9|} za*X9;ERTp}SH0ZZ+dY;^#!46GA}}2YP2Ud{x3`5`JDyAL%P_s~wO54qWfeucr1#<4 zZ!r2VaqTyV9@qm1P-7xC`s~uz#Qkqh4#T>ChU?JJipTc2dwmLWpb}h}e$Q=5h?e(> zMG%+w#CgdVUX(i<&$I1?&@AqHulzM?LI^$%_|>SIH`K4D(q-+Z#8=T9V!0zw26Gx`@1)^M1~k zyv{xf<%6*o(qs*_f^nnWhPFfcicjG~PVVK%wJTm#G8Uc~--hf^{tv#U7m%2 zycQHRfQk!Mi^|X<)tTmrsLFnV){W(6sr*8b&s)mjbDjE9Rci)|*3?%xIlEzA`+dj| zy;*p8caWA3*jcg(k@I;AzZ?1J{3ccdYJNX_meqS``yFw`-q-v9Y#skMFNrs9&PWWRz}2{?Eq)mRpI4!L*%zF`t=RF0z&~f9 zxrwXU^a@0Cr9nsZ@Ikjg{5p{(5@_kqt^DtOO{K?ExOdBaXkkn4VF=dz zImKZe;(B>Jz}()0tZ2b6U~PLF4H)&d{smlg@71`>$`wva!5tSMd)-!Hn{Yp3QSbGd z?Jlyl6x5UF&b~a;G*65?u^|PdV+AMBw_0+ivBXN0ptm=I!}ij;&u|Zuvp46Z0Pi)Y z;I|FsKl)x6l~>d_-mNWD&+qL1IOuz#(@J@>u%UN2e%-ObPV3zo z=zS^jvK8&Ha(53rs2^s!-rmRvD4_&Oz=9}Nh?_Mw?B`uTN8STnApNI5%T6~ppw4(Y zn+pjob21C94e^ZW)&@KMg$`ulmmtOGf;GC!_f&hRWzeA@0=!A!DaIDDwIJ1V$uoSs zRg4+*=54|O{5f(}U`4;O|GY)?HaZteg~0m82^hjHx%ZBOjOSr)jFWgBt|Z{M6fFgR zJRhx_3VyWic-6Y5+hK8$dk1p|aI{3d2kG1vV z!f=orqvMsa`iEL-Q^X4JGkeo!7Gq!!Uloi^z|=Fu&j<{y?Opa53N}Ri(B&`gVYJ-? zBd*M4E>~+7CaCz^Xg+`UPz|PQ5={3em`*0sS~A7F?;@Y>I7zrb_yYSVDy*g8wg=Gu zM+I0v3<_TgS~YJLnupos2&>my1=MOeekQ)U`-P(2Vs;;4F04)otdB_z=Z$nUY;E(t z_arAM*x4)WeEjR6F}i(CvvCMvKPe*K!eavKSIg4-pzDNvw$lQ=_OaAm)cY$u!>6v^ zdXeU{y%N1uq0hfaSFm?UBQ_}XcQ4*`&*KB^ze%)Cp|`(yUhZjW_9ltWlBlm~0UYJU zoalfUV=v*cc7CcS-T`I70S-PJMKQlE zlr>^o5-YeLa_pXOu&{=1F6llGHJk>S;C_Duxp&zkH_(s^-wLdMVn6A(Q2Mo$9xJ%< zPmuIDB}KhImpzOeA6WnA{R&NEpEykn3jU1~Bs9(})2j&b(=sr~wX8K%d0zA*HV^MwhIKmC``b8o8HihXEB z@jIjFd-hi8o`ck^w&uD(a{YilYe6ZJ|S5Etj;!rI%XbLEdj#1((cLKib-EusCgmwwd9wKTOa`@vc zK4>t$E)DR$xF_eOoV~(mflIDU>CMeR;ojWU_;>Q;;>nYrWexVG7on=g&Bd@}n-=&C zHY#XHtEh9(?f61_#KB=~$a4bBy%XKBuaONY)8&?-9NN0#527Jad|hHRgaXizQ+sm{ zLgC)roF{Zcm}8&sG~`4rFq;BfyuH6iPqBdb9ljd-4M0=>O^z1tQC}hkM2~-hRP=b! z{^;?yOKQ3NnkTPQwW!rEA0zcn`!y@;0$h{xA_W9ok`fhaLE}Yb${#ywbi~8#u zz_x_+5rWOPVh;TqkN+M6Ys;W9zY{^>zo_;W@7R6vatQ6_wt>DCA909?(q^l4BhcGQG;eG(4)Xpi>dEckC_Q_m>{+7Q{E-{F-AJXrgJ1lx z;j-JmI$#B{T#v92y6yD%epN6-=!<{jRp_Npk7EVXg}$irMDKfj^cUdHDU9wx_d+!5 zIJSA|`K~tekA@<1!6V2V+NaI@LFE2Qi52`Ea(L?Ev>9zf)tiC$sahE&>7kF_9`1Me zgJ#S9B22RXDG+-sc9HRRv@o##eGwvO!7$y`f%X4zsItKNE{B>NSijSuiURAu6jTMv zof}xc%b~IY>-RVm*3ttfauInAIR^&TAC{n`b`I2h;k?pr`(?Kb>Nh;qQxyHYDEg^m zy_SMAvSEU=N}=?YP-YfS;NVyv@(|8%_du6ea$+&c-)!S>EiJG<2kpRm_Ng;zj^|p@ zIxBWgrdZ|%p05OH@5CdY_&;!I1XIO3zaU$|iHNt{0}G1{2H{wYqi??>H>ZJOc5${jwN&!*a=(LQ_eQwTVWE^+LWMDW~XFT^7}IOUU^RbvI$G3wsL z{UOFvmW4M0Fcuss+|&CG9$tX;X2B|>;IZpvJli8w!gjevwQ5Gey(nw{@C+hMEcYE* zS1-rzG48t72ua>+WnGUMbum71g5XmOse>eS4QE}qi@N?>r>2ktoQFC?;y}Ymjih+9 zY6W74`r$lqVaI4R>r zK9EVsSk_0zMk(W8>o_@j?*nR|E7Nx~eVR<)!So3-eH+t*Wje<6 z0GYm->3vTNIgLzzCDI?rrA$k~QZ_&8twq*157}=%DaI-vdvP&pIYA6C?Eh@#OXY;aI&F7t<1BRZk!y0=N6&M&GZc z`4N8iIT83-h zxvSKb{CD%h|1ai(^F=^cOOQTuK^a~nfNggG+7w5>wK&JN-+!F`W=!S$tvSZ(5n{*| zyoxQ4J^jzpnfUAT{q+|sco$4~^3bY`nFRyjgyGCq0iU@HlD2tw;oq$5s$a+1aW)*x z{^kkiSeZ}Hwl#3k#E-SDP)NY$?D2c~3=AvG3DH@Z89~^vQgGl=OMgC}$Mf-EbWWx} zz*ocM1$zffh=wyQ@)eVhiCQKmfT@I66!_=`j~)8OyyXxrieH&o7T^^X^5MfW^-P?C zjR`2+9wCJf(`#hXg9>rM5rjyrMWSFi*uxhrol~$JRCwId^2VOD@bOEpZ0zY54mS4m zk4#2~p2u9n4rRx22aMa#^?nUZlEASEjteAk%h{R(YfI6*Y*gThpUCW(_nT!Lt+@kF zq6zZsMKI@nkEauJZeab}lRO@M_9*JoE0+XO*7{akrS0UPn$Wn zi5zt_f4`Z7BMG$NwGe3w2t{{dQLyhGre5oXhqpk!-O)WC;qR}|7lgltryX_)6o7L&yeUl1aN&o# zUk$APX#f7xBH!a6DzN@tk;$Q@ZTX`gnI9mNkBEKEcYlIZ;yO@#1xPFQ3-Kl++@Bbz zZ>qIC3VhjSKH4>I@9@zt6tQ~+M83ZUuOS}pJF!W0ycO_ocw&#&Z}2O>Cp-k5{&X?Y zc!F|pZlxa$KNzq>=tlhGX8`wRx9`lLD3HW4kuYW)!*tp9(*ZRp=_dlmXGt< zlxmOYT5NnCp0k5Z{(S`)62FG^q_CXI&oF6XvFWpN+MBm8;hh)UP3j}xirrib1&SiP z>ZhKVuN*Exr@m%pnOA6dJ#-jHMcp%#-?r)-<`l^!yDgCM-uwMJSqFegX@hgN27J33x zc?!Ih|GYenN90rtG*=ReT~p>ee0+%&tEsf2lPVnzhTuZsgMy7`WTu40%ODT38s~aa zFaXdPzUh#DfF8n+cH!|iZkGs{W-7$Jlp_5e$!_Y~u|fA5S?=ambQn)rR^Pzq(^j;{ ziq)ru^0$S(P)X!qP>i>cPZ7i3T zh9&q;-P8(C&VLhO9ldA(Z(>~do*sAQ?ELXpMqY<)M~*9rY~|fw%!aq#Eku@PSov4u zI_Pl-9F0Bj;sy!(0sDQ;UIC|u=UTC=v#k8mEMGG>&0OnUZpBKo!IkZ6{!l>u!-y}X zd4TeK&94f`8$JgG3sJDp*Zhot283}F`f3Z1L2im&U6#|HUs@KiQ4@wGViu;%Yk8gO9fqFhd$`F3RfuUa1x)bMz2Py! zOY%pjNAm68VrGH~)&v?irv%IKvc&$luhP}eYB{o>6+52}hF>Wx@`@=Eo6YzlHC}Ss zU`K8jRdzCBGF<5Jp{poKVHI|Snl>#Y@fFGw&tNw_e*j< zx|urwN=Rc{Xcu%CyI7na+SfiT79Y3DOi#tK;UxCW0;Kt(RM3p zb80HS%IRMUir`VZC9YBbDpBBB)-M9up*iiGyBi=<$1^ckbjO_mDmWu>x@in|nCV!? zaENJ^c$2WYWshlNd^(z*hH%x`<-;y1eCg6mG2R|TB^XYTCG069XY^(Gd}95A%~hnF zHIUZV_J(O; zYH7-|{I2CHh;>O`|D6U`cqX2q9sh$Yq!ro2h}$vccyKQ8(q z`g(jq=n)B_fBP+jo(4wFH|l-Q@?E*G6%6&3eGTO1yd)MtpJF`XT9@4fh(0?HS3m0S z;4Xc0PJ1ZjBgCC0Qg2hYsBv^8=1?pO@;603&%t}4KeJ2P;DWIU{$O-#OCTi>9gES- z$@7Rnbb|kiP;|F?87=+Wm>&bNvHljTxBG8+p>Ow&gdf8FW8&<9%}K0J<9DD}C@X+2EuDu;vBKKkVvJu*-RKM#FCsdrIIHGw_ zdQd#|*Zlh+R^vgKQhU%9xgL@6VtgT6V2<}G90`ni*puv7jTT172p%!muW;g{?2lZ5 z#gVyUIF{7#lQVu;;{U?WTAIa%1GvlQx-S%ps4cZ`l| z1;)A(D==Tv>oTiYmnwEjJt(tEbXJLzRWGy3bXJ*@CAXqC*6OTUCu^uE^_-Xh(8wXy zwnnBMhOd#t!D<`76a&-zNX@h}6?;y`YAJzfek8+fOvRpC$1g}Y991yQ4;jKUL$UID z&R-YD?q~pr{YFmCmtvi5mBX1v;br0C=QNm$2C2D7a$=RA|MsHySe_$b@BOgwwlVdT zd<7z;n9C^<)yqxmU50Eab?e5(BTIWD@Ni{AdD9M78ncP@I7i@wA~pX#E&$8`j` z9u@72^IhjA{g8{kLDACR7g$zwAJzyh1p5?41D6UZkuhXEo8@DR(`kXjtZie{g*It5>|e#&`zpkV zLO7AwA89@RQ|q~L-3sJ+!hhO3es@ab512D=hf1yd;_OJ9ed@2o>gevP#C*;6B9!=z zTh>LHm=7pZwaM3fw%7*mvhQQK!OwRRzu~Z-c>qY`SgcuazEF)xC4Vs%ns?B>^A}sb zrZXL;O9}o4`F$DK7G;G{1=XamLcNS9Q@JO{96F_N{kS$F75^){y3wE zL(jnQp7_;hkX&!%ycEAg60-l#Kqa2|1&MrdM?OB>p|QlrIj2JpAkAfjowBO8w>5xG z@h%*?|C=j>zhWf3rj~N}(OKd*2YNJ=I9@M)DT95U*h2H11>LW-wvDfZc&s`<&jIZ=2f{shG!vx**A7aEBJ#r zQsAz>o&UTMjE>3_yZdMad+XFtY$h6XZMyGpoCDPvrz2&?-oA+2DYds3zXT15-#W>& zI$twm5u8oEN`L=#a`&tB1HIxvOz(a|tZ($03y*XP(dAK@!EIw9i)a1vM=$UjLDT&Q zaU$w-O$2Mq1HmE?_T|PCSGY*GR$H7Ex z2>XtDv5lD!JIRV3DVOFe&>HAv$@Psk-t2aDTCi~g{%=o%36Hc|0{BZHxSaqW;3>0z zLiE)T_CZ+_qPy^CD6Hr|LeWjV;mjS71BE)`cW{t152=ANk94^tC)U@Y{85>a$MEBjzmh{p+2yn#ekKGN ztH0T;QlAr|uLY(~h;EkaH1P)~;A7`fE8>9hvI)(5mt5Eqz_6}{x_W^hC*HY;L^>3J z->C5?d(jUkMB@{pT|zh8QtV$tE8?(lLjI4D9gee!-vi09e9bDQ= zV0Lxd_*LX%mjLAt!6@ddcjYN5eySIJecF`hD{u=uFW{WakTVED1dI1&-}k~3d^cw> z%nIj1`<hQtHa0gC+51NuR&OE$vr<_Qv*9Ngn+^ykMZv zTH`-|Y~0izx@+EySpxN89R&}GzXVF!8>SL}PQ*UB6~=+rWY9qTvm){7s8#$uVjZgg zEkZR9YY{OH#&L1)+c*L!(3^#W@q~caCXjzN2G0Uo z*G{J%Iq-Ox9lK1_cS`z3MW zFQ+T51F>@&q;%kGK7%f-Hcf++9(>J5NmT5Y926EKZ=s003Et0z@5ys&hxe}%E$++9 zA6i0!*c&;#VgiZXSk{+!rR1&ci!KsqVl$L5)HTKiC;?73_B08wAQZa}dzml8BNBU= zEVyy7d}}ba2wQi!h)+Aj;gThQ_#DW8XVLpS`Y`@J6SvjY$lR1!xOs9S4;GKXu_ac* zJdN^WpN*-x`(U-c!U;f3o`6N4=H|;eY90jt!j@Z|M;YhfpUHXAJEL5T!_iora+kdF zw%%S5bhzzObeeG~4!HBw0e7BLt54Oc_vc2vpQw7{Gey1oK2hUe*DG3! z`0$dte`a6tLIYXA16htEZOa7r!?+^zpndoGjpy{y`Ei>^LcD%2m09gfpXMByv{DXf4ax}hu8A1@NmsjS9@ z=^mWK#k}WBcJP)Zc=uv2*S%fY^XLS_EDw4n&imdb!yg&%DaY3|53#fRNzgnq!V;7l zJ8`(`YuYZ_IUOg5qjBoolREzl{Qa>XvD0eYml`g#V{i|vyu-@xkgt_MZ_|za2ZQML z@aM7d8PN^j;(6b`USAQ;$H*i48=HO{^6;{U6Rd+bTIDZ8iFmB>Ec&$)H%8E@(?6DO zc*ifao88ZT^)2`9d%9=@uk4k=)&8fkr#JFPdkc)nrSk8(pHuTltPp{xoewk`8rVam zXYll0{DKp^FYo27KYwgm1bdZ2%vrnaF3d7wbB9O?eeukfGZ(UO?#r1~?0!I^*+=%K zcye`KuAxPT}8tRE72(`20*f z4h#Rxo=HPQ#|TcbBe((@hPl0$u@0QS3!3t{pBGOkkU5H(`CEAi@eN`~WIAqD0&WH@ zZl9qmDblU%oLkuE=i8{Q#(p^EyI&*`IOSu@fikqIGu7~K8>*)q7TH-a1FxZC>+mfOF*Zv)ot<-0d1a~Xcyj`pr{+AEU()Asfk?fvUj zqPp9F{_g2!CND@8n-o;!daCaLwE;|)q>{@&D$d?YW&6UW^arV6lf2>5o{TSAI zwv5a2-LWx<7fsyJp0?4~)Gk)k<1q?*`uT3+UvNSLpv5;oM+E85ar#ZbS5q_~gBRqy zP*6L>bVji2>aiNTehlp0mJ-G?cIwuQV3gwC! zGA-`)Fe4PFg-(7_u70Lw7F*)cSZc~e(W3A0d?uegUbKwgFzTEI{PFun#8f=FwaWW1w^BMU;0%oY z3Eze9*<_wSVeJ(2esWo=r_lGpyAZuP(d4yo3>nj$=MnPxvr~Ru|Gx6p@f_BWzmDfq z20aabV6cq~>gb;{dyr*C?-YL{&Wg&*P@!m(_={~J(A;M>wTBD&#xXzAzG1%*e@x9c z>`w8w;e5k>CH{1pZ`g0epGxx$`+X)a{`iLdIkQ20uNQyk%?LVpuNx{wr*PldZ?)ik zY~XvQLo@`QC+05s=j=l8{WK9$LoMDHK1lJ1w>ZG9)2Kmidb3rj4EvfD96`J66YJ+9Xa>5-%^@P@k>YMyq!!WAIjh1?fJNNHF!|8lakDt>#uWt)5j>rh zm8M7DgJ--yU03iCE_2EX?iLkvV<7^7?cl@K8hGLCR^cD<272U%MxGx|5Atw9zio{( z??o-g;U$b;U~7w_A^d|@8b^tE9Lq6>7j8hwS=2$|_ID`OwuUr9P?m^Dfn^_qM&J`X zex$LG+3$2r%i+$mo}J9bx+dLsD}HT+_J_CNPil_ZDxO*5>J`F7HbXQ*9&i8QaqoOQ zingLVx`)WPz-NZ-=<;@T$v%HX!@W)-{a zG7MRUTxb~WIFzy9&ydVoBY11TIMjsw0?ss*L3~Yo*@qa%!Tb*+r^c&6>i9Yip?-Y2 zuPGlG&r3pljSHWz1!D+exQ_Czu;-zdGB}B!xAFC9vv8mmjOa^br~N|{RaAc&&S9yY?oQbnIvrkc78-_mVzDqH?KKJyMn2{mmD52t z;-`gU8(;HBOtBf_=tc;LzXnX`(S8hG%DMU1V)1JKLRNT#sLt2)3dCt;HvfsTvHzRe zM}vFb(;94GoPGvOVqA!6BhKe?Y6^+V_Xc>QiSjMEEs4ToSeQ@g?4xCi@Rm4H7Tu1Y zAyUdVnfo0H!(rS`k9#^-8igXSbiZR~V_52Vl5~SFg23UlL1NHXl%h}-L|1~Am z6SMp+m!w3C{UeW9x&UVbSP<~-d~f4%x!oUZv08u2rM<|H^=q+SFX(`bB`4;;yyz4T zwApY4*hs$yOz*ch^rW^7EX;p-@%#3MWw;_*nCa>6q`ttNvt7DQ{2&-XubW#6zWW=t z5>vs|QAVxDc#F)30Vl(< zQbRgQ-isb%1f}7pHdg*Pe6=@Wi2og(YC^p{*lAeGLr4CF%|HWef%F4nd`wFZj>Ng9 zubB_;@PG>O1VIfu!b0C&h$}t4zPs8Bo3?ULeb?)2=KV5{^^xn}9C$vzAGqEp=(fKCEH{N@~9MSv=(vRT(247Pa zOcU7Kl*xmILSNI-AVsL+O~MfF@C9Syp%S?Z!#|&p|AnuK_YR?PE;@HYOE6sXF)YT@ z(U^D~PVWA`rZ4a%9x`)~;^_P{dn5SO?UpU(pUTEC_cig9k)c<yz0-sf?}L>vubu*G+yAWu7vK#@;bBt9I7 z)UQxMcvzzQ;S=yKq$ji=;jNy0OeG{?`CWv*wB){tdb;mZaR4Ge6C&S-F&QtSU%d!L zU@2#R$Bss~bg!d*FxtZFga&pAY4OJtf6RM0+RC3qwB(+}9*A?G*DxC5KH+21U(|U6 zPU@Wdtj<{%&bZVT^=IOk3kO`G=ti82JI`}*zIAMn+l<%+;`|FoTY^Q$GoB6Nd|{$E z<3d|Hztn9Bpe6kkL{852cvHWaa%7oJv|uhP^~yA6vM^U*n(OsHX7AnO}9N1 z{m^XBgyxr)91)705NzCtc{ZNX{iYgcvK>E6z}Uw{;g(!0(T-=9IPDP66L{Y1=)iT} zcQqA(^To)S?5=n&A}?jBcnf{--X8At#l%@(_gm7wG4C?eojB(Uy`j}`zEi!J7kJKh zA5=D3vZJZ>3EsoNn>gpoNiZz>LJRv69%i2NEr6-JpETC!)Gwz3=f2qGa2PHK{@=MT zCeF@rRz2Q|`KCtju77B00$hBszJc8fU0 z$we>Wgj&pb!ozi!Mht=TdXgzut*@a+L8%p(rA6NCnykA33 zC^n9-P5k9slywPQ3y(lIV2nM4`@ax+6XpwjG>U-6d1dd-Dx5tDLM*eKxCEBplI14F zayMD>zvYdRyLG3BTd|AK>6ez&LjEDRKga%V2+uV8Ym5gg_M+^^kKvD@s>m*kn31^; zqv@D^xZaHR^zHA)M1O}gfGhks{=OOZ+b>1%#$)iuPlrpu&qNpve;vZbQVyAaqA`OQ zPuQLy+T*iEF4_wH$FCE?0{bVeH@t|Mqfai;8^UdSmy6zp@3!*a#WPT_;|U0Ri$Q`H zhk~9ED@G-_-g7+&RFp3Kob}*{=PF=WPPAu4z7V!HAGU!{`zxwL!A(Y!*@LM+rhb3og1hX0W7TT zpAx@u`aHl;~c!xuy-Ha`gVurSLgKd5PP0+h<#1s5F0a=_pTtu4lyY|8vz?^E~o^nl6l z^U3r4e&2t-JP*@#t4^KTPMtb+>eQ*r&?F_bG!)cGA>HQ(#%V1O2jg35%Rdd`+IZ<& zQ#3Je@&kvEp3DzCJ%_vejE_kXRHk-7gEktRKEP% zQA(na@)eh&T3enY9p*cP`9K$*r|=#w{3nHXcHx7_6UZMnMNd%t$1Z%Q!tc6pslqS0 za7^K+TzIj>93c8X$f(R)t>Tsi|XrW7Wx%*_H^bx>oh~r zXyI9G^xn+pXn*7_nlP>oqz$>|l2-q?mMyh3k9}UtmUF%I^8`j6?Oj*JFWb1ps7`gJn#;7>8m2b2K~4A-2pg7>5^My+=%q&!qKTP( z_?7Jus|}u))W3|h+N1-Qp5sv+Urq_Cqt2SftI0z<=CnDwsr54A9A4Yiby8~%@?U%x z1e~o4*=N8=T+ppk(sbEy=ZBE93O(cRs$=|)gwy0%#3bGZV?ifrG7;4ZPK91 zxtyrg8OJ_%O+=U%qkIvKaiXDXF>SQJBsj{!Hvtc+^v8#~R?R=ci$l{ORe0&2vN;j_+eP!lSS0?x%;Mh<<(>!){eI1Ie_BHjj7KOr|=_1K1_DwVSL;k}O zH#m=c(frl7+zCeC(x(jCgr4sq8rRwJF#TI3Exm2bVm%`frvF0y7Z0A>%6g*h zBQ76@4_nJB`XuAI?l_I-^1AG!#GXK`%l@-Mc02Mc+DuWuZuX`5!w+Xu!qLaaY1+J@xJj=fKKZ{h_1!c-KkA;kAv$V)ca5*7t_y zo7UB~Z0qxb148+QT|j=ojrr3W*LiKFVdB&P`wX^W*mP(An#fKV9K`8Ft3d13gHa_f z2`hQ;W~*c>K?MgfV)7E78&Q`#X(AOtjg}ZSBvn7EpLYZI@JmKjT=NOlisYu@XIf8| zUw&*f9&wIN=m&Onn9zm_(`dZwWmhtpVr>QEH^$0P8Z}#03v`te_cCAcv)PC8EsY}9Q$JEiG8k}MJaj}AdLTrUcoibVG1;9jDDN#rgWk<3pn^*c6(b^I|2RzGxEUiup4;)UZco- zg;Ko$BIG5~fx?<#pz;vnO`%WT6F2=6>@KNF_V%-t9_v zq`8HTw|-`(ffdb1a~J!88tM4Ts--1JWCw6`wOrd)A#tDG&xmTBTW)+wJv#wUB1cZv z)L*F%xmEk$glw#?VL|-Q_sQ%&jMhW&6kn@(*T0CiQc-3InwKp5mfS6K)uxdHFTRV+CWS-@mREa9z=}Kwf5<@VDw-mgx_57lz9*Ery`01|4bUPuG1Y?Umhq zD0>ejKX4flx}WD|bja)f=zKd5Nk7j=2kt%G`qw;$n$A^uQezdjPc_v5Q-og{3}j4A zKNXtyMDbsME#K6+xB<6ZOo&zN@?bOLUZKE$(GA>(GHtP@xCu3IlwsdscI(72BR^O; zV?ZZXZ>FN&b^EZ|+4^#~sx*1rpzLyNHF*bjw?9&^3qq4)yS5!v^WU8^qa~t zvi#7m>tnQGp4cRNx%6#HX}z+7c=>};uis<6@7`uWhM{{lN^u48m5AA{7V2q#^5DGU%1vavL5Ebz%Bvfy_YUGackDa7BBmMhWc=@D3{wo5_m7gn+{O||a zGn&&dY;gQPF~2UvpGxp71r_AW+@-F5Z=UN~Y(e$a2Pp43c zgAq!R{g7SNlaqisS~fphj@W*k1~4+c;e10keh$=l=jtc91zCco@lEciqCn1FJ;EPD z9c=c9K zsj>Y%H^-McRz`d>{Kn>?MTm0~rbwS~3dESqUBCexqP2F-x%!LINu$4i*Wdpf=wEi$ zj?YaP5zp-6SFF3s}giD)g6EC;_u&M$Xnj2P3`2E zyjiQ{2ktFGFeZP3Ld@=;pX>PiNWOzd_~TDu03v+O*0|^uIRBXQ$fxoACEXLi`iIkJj+LYuY}9hY$Ji06i4B%Rp4r13s@_%< zUT)HRnf^AEvUPx7+>kfQ^;aD?qpzSDJMQr2_=mdc@=EE+K=_A=>Ox+ooh?G!3Ex|0icT)VcDX;_O_c%4431 znlE4nx_M5jwiDq&R+*QXMDa*XexHB10jL2W@kMPwz92E>C%Mpn>j>Cwkc!3h!6A?l zmbLRkzl9F#Sn0~w-r)|C{G98+piIqiD7$ihNg2qDUPk&F@zPLe44Q@MTW1m}%k%Q@ zP|rkeM)&^O&GHoWS5}Rszg~FL_18zREZ1KewVVD-f4xSOADkz=tAZB|!8cizUh-zY zEa3LU$g5Tj^3u1G;toPrG{27p@Cmupr|h(_T)IjrsBtU&D_kiV?NN1+R$L03zmJ=r z3Fd$+kqZ%DT#Q(!9Yu&cLHvb7tkVvMc&`v~%sOyQgm^26tH9MwoUN6T*{rb6PS z8|rGB5aI47Dwzx2P2~nI9f$KL^kQa#({hIT$O%~~s*{~~v6gvh!EEo*ed8h8b8fss zl9mAt9H5BNcfOAOINLBx@(WK9nh`nz)K}s;oWDtEkx-uPshJTy9w^I8w833KhHZpoZuRIU|BZeD=di{RZZ-Z>J5ib(VPGCj;$lJlL|Y>Gnu5w< ziblaI>bDy!beAihRo7y5nkyf#vx=JIad|P3f|I#{!-&xFcUtQ+06#gD*~QCm`y@vW zTuRtW&nF?7ecrzx5)vnu(K9p>+^h_W*a{|bH~d(Ox+u&4^8^hJ_c%;)EMEwsWNs=` zc0>af2bd&&mKv&V4h^ck%u3ZJyG?WR;MY`+^Vl`WOs}7fLxZ<`;e+Hk=tE67N1^dI*8#Ni23!|ZLy87Y9?it5X*>!V?{0g z(_ocVv!HWA`wp6SXdC@ye)JoJ{X1a;(Ho_gGucJnkI_JNtor>#;<7Jl*}Gd~O>0Js(M z5hzG=9W2);yJ|DL;t4#rQPD`-*=CiC$4%21zLUf`xOn@{j=qt>BL+v^nxkq$5ikC#aJ5$-kD{B zp>~7!uB~hPDdkU6rR;O+ODdT7--%)=VqxCYQ=!R&) z7GDj14aVYrVO9Ab)ISKKdWX!_aGhbe-1y{X;1V-fxw(rEjQ)!qqzwP|7_oycZ)79O z*MC**KAWnA@}d9g$z5%}pLngXgZ%Z(GA-9!-H+#bdzrOjYsQ`V5T(E*7lI4k*la&% zn2kzR67LCvxN4a+^L#!s+CRPeQ0RhP7Z5Tscd;#i$QjHGe31%jyAJyX$)T9c1Jc>W*3UX3!)4!cvwxWk)e7wq))h@Cly&{;3@dp>*%}Ep+p&NN4_m73ua*J3EUD z@^efn-5LmVdaL^*kxveX`~Hq!*?udw-G22+5s|r6`g}q%y9z>*%*;|b@a9q7UUROi#tnyj6rdK9pU+v&Y!X9+R%!Wi z-)Hym8BXc8vlm^R+BZJ(v}M>U#&ZuyU8qyCKhAShzS;DHA9A~L*fVXTN%Rl4rQQj) z3rNky&u`t_)61+uM7q$sto(W1Qps}l@h}wm$b52dY zt_eCQjv$qw1$Vt+eU1DlO3h7}*nklPhGaS;{WW|HQ-#J7Z}u0~H4RO%98zzNI}qDS zXN+gRI}Jam+?zmhMpQsPl=V((Kr+{RUN0}xQ{o^7m>HP~&8w1i`*Dfvro^&M$0diY zNe)>Pui4_=a6X9+3p}ie1%6%+dB4cCsEJ~rKOip7d%51MOBBjYuZS^)%i^t_r8APr zTs?JI7HfT@!i+(Eu+?+JY+yq!UZG0tYn8xA<#X^+iM<-=o`&qQ#InuDH4IzZFa*Pa z<=zdil3J+6S*{lB7rJV3uGL~18sb@}S~U`tss`Hx?uyJ_K(X6bWg%dy%K22Ka$c|0 z8Hv`-6{*t~(@V6XeARwN*)#4l%0@eQGxMS2a_M73yJAdNweQqa=-?<~K$W=oEyM)V z`BRX0k~NPtA0X#Ihf)bz$4ejEwQja)QLy)RMUHhv`Zt{*UIL@~5?SyeCMpy6oa%Vd zb+jAlOSU-^yW3CX8qP;}7j>r}R&{gb@9oRgd0MZTyUXvQ_ANXqx{&`H<0p`cm)Q!9 z&FkT1`WdY)Z6Onl+)uHPgI)`CgRN0_!>n=lW;en#=v)p6LIl6*hTv677lOGUi06uj z>IR)3Sox%<=h(PqRIJD+b8v|5rL6&GemU_KS-bCvRh#>PKL9~9;U~Wxj z#`GyT@cEU> z84*)aHLHnUtwVuZm(^B0$-okeR9nH3|B00Zb|rAD9l9~viR`#4tfl##DU8&oHjzDo z*a|at=Aa5A1I)V1n3*Z*dJ(>4GFYG=PIp?AQTsm4bA}^*E8@QyVU+Jne_^r0NFG)g z$@dzdK^YNPKUxdD`(>a-lL@Hpje%RK>Oia`#$bUXS-z9GyvoBS92OIn_j}5VS$#Wl zD!+vacFjJyshGx9UAvJKv-{5hTI^^aiQOufIANnVBW5wlN*m0R{*$7cCLpeqGk zMCb>B5{~MQw$~ss%GCG%(9yP`8sEc_fodAw;2}#i9_W-qhNOLPsGA^<|xKTY%N6 z1420{;p8C1xt%x&@b9_H$wCj171;=(^J8@4kvz1=C!%O44}Av+lZTj6N5a~exof39 zmy6edtJ&y9f=|KOB$vfU#{a^wnP?&Mo-l!Y)PUysn)Qr=q>x{U(2I!6ze zm74(XF2AgY#YFPUX?sY1(be%_8GpLgpM1ZQA7te6<#mwBFvTT+yJ?jhQ zb--v0amPJQKk`5e4L6uSH5;FzmHx`g#n zyrfKHT3CMu3M;pLg9AVd{g!9J8`bOg$T(1{!`>+D8-cR<+6nu;OC!KODyqpYg=SO> zcD1YM2$HGhwXT}}bWSS7>@hJc34Se*k+?yS&)hg_HE;IM9nu~ySJfhGoIjRacFyD4 zL8)&HFtpE5MX~w=1aO+rNt&AVH&^x&fUJ{pg{o!YXu+W_`Hm>LtdRU&CHHm7Gh7k- zxkUewT9W=n_5521S$}pr-{wqAZx(&0Dmn6?o5-5lKQg-7&QP>#J;mBAaTM*yo!6Ae zZsXz=92Aq6d|x)0C`Di|Y`2K0`K#Aj#YmYZdt^iQ3;)}+*Xe#!kSBWB9Zt{CmP_^9 zhX(0fRgA{$Pqx?BVhRb9=7_?Z$=rs&zO8G#X@VssZNK}r*fu4;+JV#bRK9YiV`itgF%@EG2hWi*}>pDd|o(*mbCpwMVvzs9lt<7 zAno%E+|pul#TC0OTS632sXdg?kiD>q+C|1`9X}R7FrAbRtXouHJOBP5k$qn;-azj* zK3uUI{x$fjGX*ME0;*5M`lF-Q)HQflte)tXGrm!unH7igICbo?ipCbA9tjgG)Y)W> zTAw=1G#V)!M#}kSOm4+$VQ^9inQ2?Mcu+8~>IkO?c`Uqt7F+stdZRA;&&8+FAv*HU z_bdIgb^A~5La#B3!`&i8oM((>5ICJYj*hl@se`3@UOF_qv8Bg=uKE6=YDnQyORYKX ziY*!S|;ke6I=LAv@rc&6m4w zDa5Uhv@l8~Uiy#xJ)@(;uq*k#mmG6m88LsdrXwh!~S4Kb~=uRb8wfVdSX zTz{5cM8Ab3!3jr6H_f0X32*no=kxt;M%%zp&A)@Led-PB3Z}@PsNL5!X9X9GcIvfC zo8D?fHzQ8tFgQsz8jmeiflI$f1t9m18*N?|MFv+J={kNB#!m*=-c*o%)U;92h#^P1 ziTHp9QTC%=rb1QtvJMRXxeakxC&DF5PY}L=KrX#ZA>HM3>xknIdRt1o8>davpcLt4 zu~mXtzBwW)+Dm`Sh~<)L-6(~zgHoOw8Bt1VYB81k;lH4gKZr`2Dc1&5w&spQK$Bla zCC9mTgqTaOr|iN z)765YhPuqLcBZ_xO$D$6RK+eXTa+ToD2%U-rwy_{>+50X9_dDum3QTr3~H%ns!jjY z^x{DkAJJI+Z>GKt>fESYy(j7h^~^6H)G>5o8lVs?w)7gB+kFV~{ob38@i*qpS}hpY zvk>I{eO~>~F7cX7GrRLVxOXE*(jSpEHU*;bd-+x_v2v=6H+Sy$bJAWCM zD$i?_iPmRz`EPf2>}%`hlBcvGDVcs&OpJW;hIq}ZUjA)j>auTOe<}@JN!^fT4fz4P zaTSVd@eMh)d}W$(B@Ow$yvFG_3Acj4S3it#0yO?FY`%js>yh3lQ`=^aR(SMK!v5%&1;3r)RUHgt zz|lyh*MM#D{kG}t_c#i*ww_1pgqO^>+(zaSG9wQLU*m|zwiwZA5bbxb-00p~u>%A7 z%g5im>-3ntC-JGjXH@6Jxr5%Z8{zhm4_@)a)-V5Jp%QSmBJFC_uE49ln^={a@X9-Ruw@GiEzE7#Q6(zoEiC?sK zvTHP1wK#E^C4S!8*)!GLE!R9t*xK4zmO7_f!VQ+NrM0u1I~v8Prdq=0)=s@XQ=ITk zOW4%f*&92N;)FU9hCRA;EH$pj7IwB+A{DO=TlL!4(9O4gPMb~uPzh69b334D5@^p+ zVM3Ejc-bXzPOxW~FwG@A;S$QcbV-=d;u0Qr3FTh;-9fI5SuR13fKx^<-p>jX=D36@ z!!;-*^~S#lb-K+(pG~xR54(L;{^Co<#%f;nuKx!)z1b%*7hxaS^+R5Ow!K*>DKtQO zgJ$8%p_-`Kh0oeA-#VURz*jB^FCoPqBQ_ zx|Obz%GqK0;=jW3dFxjCd3*uO=l>O!t*u)b6e%NIUAF#LShlooWdzM*zxB(O{|d|I z)~&r#SGjs@{;x1>YTep9b&SKX>A%3hfyHcX@Z-E$Ch=VwWeBYy7lgIj&k1#LVE=4zJfcUiSZMrLhq73NJG=u1Qe3Y5 zEshuKOaFn}h3~TyYMA_wxNgj3>j#bX9xOZ9TlD#bc)Wd|(ZT(0r=MpnwUsI*PLZ34 zvbP=;#lMpIyQ{ZoG;`%Y24Vb>ouB`8)99U^|Fv|==mXvgu?~)Nd$qNrM|>j>Xd|g^HQA^016T&0iFpqW*yF-1H#Qz^ zUevm&4^Po}ced+_eCdkBko71nr}teww)1cv|G`|X1IMQAasgG6@De!U)T_C7>?#IT zSA7`ozcoy5Z@Y%nBt^^2CP_Rd09-Bezp7>;@*>qJPIgcLU^;^*elU28YO8cc?9s1@ z{8T(1&aek$>bIfpopESe6 z?F}&;4S4B;D8gGbpy#Xsy-b@_v(B?~Y;RE#Px1N29n$}wui+^ zE>tWJ@HUna+tXs73S+q#)mTn!nZ^Dkj4da&7qPs91m0hVu`0hevArx-`Z?k4O>70R zy@{Q1rDD*ZH1;8e=gim5xJWU5h}nslK8iU*F*^~nGch|U26vUoo;wrMmzbRu^EJiv zC8i%SeHF96V)_xY3o-o^xv_dxI@au5gF&B0hCS8^JG0{8My7(k+Ks*R@Y@W0+Pr+x2$u&VVj0*>PFoCq2lI0 zL)?zClX?8}4*47raeBYl>f=S*Jc!)-p`7+cwEcO)B!|F*Z-}5V`)Zi{zW*&IJM%d? z-r?Qej-s<%LUDjsqL zejB}D@z85inc^W>;@^qlq1dK!#Y3{hKN-bCvrWAe57838D2j(_o2b%Nm5?p*cSiBh zZBvEfAzb2TM)6Q@Qy;}czMssv-0A}THtnQ12>6p3=UN;T+_baeAmLADjJG&wxT&w= zAmUGEeBI)p;--FzgN#3!ae&1^$4$E^4nqE9#xBIw^@fs0an}+#PeXS#iTzMH{ zw_MX#>J>BgXn5x;WhtnS`^UhTq~p~#`EB|$A`ooF7{>_^NJG)E#o--Q6=; z?A2H}&O*2MQtFk$gH+eVhpbQ5Z1S!jVwLLtU>17t%j2U;o7rNbMTBU_=SPk3kEE22 z+pPWGqOzT5mGNkkoawFg($$}{QRx=f{Bqza(&^E6*kq!)nZ-2MR&2>0+KT<^ci~n{ z_Tz998X4K8OwLlLvQp)@9!` z#p725W1H29KNd7QsZPHE=sNmqIMAl8Vnd{@QPIm1nIkCT+LhWy)otgEqfY%;zL|xX z-1f94P^2oZJFYlB0#aVMc;3os)@r>&OINdgVg5em^|Lv#=AfNqmRx8BgP7jXKx z`PJH>37zEE5FNx6qB|x;*S-U~5|!y?|6=Ia6ui!-8apdQC+Rmt2PKB+IxtvOudUqy zU4=vUyIs^+HiJJ2(P=ZN+D+<0*QZU=Og4&8l*u6JsjYIa+QN>X=NGl`~d z7)}mRt=|FFActxWsH7p7WLV}`Pvlpk^j!UlET`D^)yIRwhgi%kPnPy2{Ej_fGQ_#Vbh_dhNBv)OO=17+ztqoJ>bxtgrF>#G-7aoi93d=G$7 zQxtOb*f-1tseD1ZRJmzku7{#rtGCbfkA1>iP=u)k$R&zU4K?Ui!#UgM>aky#i-Ffj zsVoh=a%pTW*IC==dO50LFFdxALu0EP8a~T0c>5fGigNT$9j+X=g*nzoIX>H+ti`=B z=Kvx~*Rdz89?Zav&-Wdnj6(@08NDWct*Dpxb{TohavgI2?#RN|@CqQp_y*p=Gd>Uv znC8FoPK)x+Ey`;$^e3wKb_1r#u3RlquJ3N2E1?MGDjG1&Y2}&~-IVNL^;9%(_B-I zc~Oq@x6ko>mGuIy^Wrs|ruM<@ulJ({IH=5j%&JEktIS8Rq>t;o%kDM}U0wdvPJP{O zvr!?ow2*{C*BkjNM1LsGyKIR~(mK6_Qpt28W}(d^0`rZ?NxHpS`T%0?HgY78wuONt zsK+Lu(++w=(3?5X+p9OY0(hl`_L1lM>PiCSx!&Gj!RT+I-dkw`o=6Z7&_gUO_ItNI zz@qrM_IeRY)t@h-MZ+z~0R-k-WYm{%0;!4G(vL3&dr5Vb8}-|by%_D(iq4_;FlD~2sv?<6 z`V|PbkXdH2qKNKL+)pI(cHp5-AzN1qM+d$|cq9A>t+n zaeMVTi@4jUjx2XqzaAo;1B7siHdM(4_IrCse#`{Ei)ii=eb%HynmbQljHnTv5nNB$ zVEzOM?$M%5BLp@w%5+HgObAI&!ol+=KybyGdUnh7DT7{A5(M`%%LKs{XL?d#g_7F4 zXM*6)w@eURai*Vj%arS$34%M)GC^=%nWj&PN@+f~s9FduJq#FPD*_%_03KEZ+}lh4 zooSRm0YWPR-lfpJ=|v>hwtO*;TWWM`UGA{zWbSTT)9Q7Fs)nNC`Rm<+mS+gzM6omQ zPlDTPr@v2S? zA1bXDS$W$i&R518C~|(xYdg;G+)se*l6^8eeT&R2o&EcJZ@`Qtbu_y4_ z%?kd32tFzJyMQ;@qLEhH@;}K1oMJ-KN|>_HL}$q)l?)i5yb$O>Z?^%FU{Xa&JQttH z5@EO&03eBWsLSExX~`6|E@GjH(-JNkBb@4e6*9?1I4N4Vn_R@*CQV0TGNsHnsai7cJx^jGNVs!+Wkh=BCJds&^($2cXOu6tUZq&? z{(rFtG-hW`eRy`KNWeVI8!JDg_$BDD9i-w zYqLzqGsT%gAt=lg2|-~d7+uyfA6v%9(t#Y*?w$Gg;Rb{sc-hvdO7 z`3pDRkvk;6*Iy*pxD{XaUV85xlK)CF4(+{6DM_sTC=A0k4Q6*& z^!a_#)w4`m$SeSRMcbC~=NXisniBHBxELlAw zkw3aU$?@ULExQq!eJq)6$9~+qAA?=qhpbusgOBa76AiBpd#aRYkUxJnRx1uCG3!?x zC!eH2B?Bl+o&Z*x=NR1ws@1$c3)F}}Nu*W0)-?(T#{dIXNo^pkcAi>A;4uHjU49jq3;~ zaZ;E#S1J5MJCwRq2~)y^c`lxWvJ~&UTm{#3Wi2Qql&3~1VOp5*P$8jL>OhTa3lS(J z2UH4uII6Q;Tz}$>@rO$ST$({OPT%ALPGMZMr7bKH5vwn#Qo2@+aCNxb)^Bn4S|+w} z_I9xT|GzpsMX3xgoe{D1-%+86NrkU&beIMts&0fFXW7wEsR%DE@t@zmutI4Msi0`yTu&`kEcgYLe76s-xD zkglDt=2kr1`F5tNIRgKXy)Tx+dYpKYKXhtm=Xo()K3$fouH`S2lD}wJ$VLFo3IVS_ ziWKk})Fl3*U$JPIpNnRG2}s0GGJ3->xy41GZLx^kO;Q2^ZHqAtl<6kWC+RaWT)YdXEz6X z1#mYe_FV8F-Mq>slHN4|%ge0O7gTAYn=zt8MR9;j3IhE85PXVik@;l=KA2BqO`iiL z@C6RsE_8#v$-pmx_03yiUJNz_CCAPIpYeDTE0` zN?<5VB_Px`+3){ODJ-o^_7yfI=zzm+9bQ z^;#v;#5vZ)#Sv(u)w%mn-w}ekp}v7HmZXJ|?v@=3(=Afw>YQo;-x{z=a2e!KA_%ZZ zx&T`k16dMk|7%VAuK_V|$!i1{X%}F^8u;ze-iQs2MPOYQ<(XpxH)a{RqpKyKR?4McW|+>$ zq{a2m>IpYG?NzD(EBccz=b=*Atea%n4Z(e=78SoPjNb$2rKWfASCq@N3NnLKvY3_W z`uFT_A~%cNn~02OaeORei2f)cw2w~a=i343u=cEc74fBANiuttOcy)qvpfQV)1*%u zvhQ#k0S97S_^6ZX?H94Zk=2+#=WL4Xc{Hw(-)??Qwm|jS_mbH!cU+i@VZYA>9}yqRz8JF$1<$kAb>EPl!-j$Gb@t{G)Vn8-cFE3=T)Xt{$?}Lq zZdr(@W^_-I$0m|w_MMvCJ;^V#B-wJO;@y*;a7kvMeR%hzKe;5cyxz5Y(oabm_KfyF z6VRk-Efrm{M?APs$U%MqgyO@U>?(^#K5h-;HBP|))#6!Lz8A)aJK5h_JTmU7VSJ;5 zzu)4KVn>GY;Z8Ph@yMwMhVhde{29dWxRbq$Saxw<{-@~fwKbGP=$HJ}Dc#afF#{A^ z1rGnc$3j)y_kdmc@NtO2OOB+ggF9a&FOz33dE;4U7i3S4r^U~RSU`e#R=OgLc*r7X z)VIS3ZG~Dl)0&gRh_x0$Git*K$%n0*k*JRhBi0iU9KeS*l zs7W>G4>|BZh2V~{-yMM$82jQ7yxoDfhTvlC&C?BY$ke^`4I$`Sflfask_?(pF|d%K zW04brtuwIU0-GajhZn8D{NQ`9@LOQ6&X~mL~5bTYg$Dbq~&f=aI zeTeBFJ{+12cctF_$?8U%VLvA=PPBAAP+hWmqRH8<`b5VyNojLk8dI`o>JsA}E~2h_ zin#Y##yz5_CUNcK6{Xbzly%k9be-mCMYX#qh>3tyJNqhDLuV8(9Z&1liWDZR*v#=E zwN;RWm><$nL+}c_num0V5d4jh)1!BCJW*J`KH_6B$D!8*Zy_wpAH)h%{2%V3qUAgQj~RrC7@sk6BgJn>ID0B zdtNtqK66zx-k%{3hTExA3&UHo^iQ^M9ifHm?Y|lQ4?}Qu;^uF*y57|qZXzd>jwdue zo58C!k#LB}XdOJ0BBM?<$*?Nw>bmUty63V2=OA_2zawKI5M~49E8XFgeARNY=YTnV+iJI4%Us1~j8B2T-k3K<+TH-*i52B=~GuTUPrQI>->sQ)BqSGkq8DF*; zR>w6P9ts1w<8{wBzu)nzVIN2a&mCt@)Vnyc9vrbg{%7->2;9M3 zDO9>P82%3#?BI`B9z^Ab<>r=z<;%DsS{(XOVdIP)e=}Cu@wnrdV_*r6gN#s!dY1&) z^@m)vS|Q_+dnsgmvr-}PoQ|v|b^OT1PgA_*N16|L(fNgt-h`;9_p80w$bU?P-!w3 zV>8u0gKBo{G)LpaJ)hJ!;v?&xmcQANql3Tl^lxT2jV;dUlKJ1vr594Tpng4e&Wc#) z$wOVpokO#**5*#)s`434$=vbNlDQjNfR1O6#miZRj`wv1McxO;e~zp>GkocYy)*OdSZ&n4#W~akWZ{6Pn#Zl0Hu6R~; z8jQyYTHkhlae`LH&AlI~YKiP8t|uk;B%O=ShMKjm)wkTw1BxP#JT_=na|Ls4h60il0@9Z$|5aX@q9Zr3y51k{UmX z-pQypebj*XO(X`IByR1FF#@b6F zi|v@kpcjG2o-3Js%-I>_ZY&Xju*peJV@<>YT7GEDuYXj;c&lPYjy_2r=?nQFTSR|d z`5KDyoo1jT6_bnOVDDrU0>iIqlqE#@T7+_p5b%OKn>S0DiVH5{eo7Uyt?iy~n25lX z+>J@&zxs1lrJf+^y6+)7`kC~)oEE2F;(|=^{JOw8zH1BTz367^a)Bj|tC;TcL=EinAfY#|LW1=|VQ_OMeOlH*mw?6^2! z{LYl@2bhAA2ZNUlq|iNG&PvJCX#KO;A)!CQ{^{~wO4LN_A32wm$66w)Cz_j$OjrM`v3?0*rdj{=axh)} zvu0*Ht#vTgRn|YRA?$bSpEcGgA(*-!a9X() zrxFspy7`mPvdDs(Pa(ss-Aq}cYo2ZpN7ethT>my!@n_;t{!FUXvB2vTn>+P-GKO#M>jj6N!AxM-S{v%j$x4(OKsCo> zub18}1fS->1*R?b2!6fH0s0d7CId$$^bb`Q>@5zwQ~+SFHSmv>C~$Q_>lQRc4}{>e z9C&!#X@@{v$DP#`2F^sB8G@@#)cx1`q%w_s;*eWk!d_|M<*Bn(k=q11{VG*rBEja% z4P=mk^ujt1khunOra&eM+hN2Tx+8Nzmm?=7AVEx}qRoR9EwD>=+g0>1jzDe%>qw}`qi zoangMKkLJ7MfRk+)HeatuP6u>e;>ZRCZ08{UGDc(&(`UcC8_&JA1lc0Q~qAxl?$Zi+d5v- zI{ZJGFSqH&ndZwi|6#r`PogOUf&WkDOMbjIeE+AW%numL(9pYyAe8qL#b8T6lwU8? zsxK(-@xrXBCni5WvZW6*ozpGTiQO|XcSN`O@sTZknCakdnfC0Si5c_~^~sNqZ0W;H z9}(GAJ)4tV)ngvrYndWj`Y_W{Wx@b|C}nt=`}Nh8sXW!3A0OG#hZ(N#mSINs482ly z`SFo0y=9nwUWC1QLJ{WPsjsxYR}q?!IY7;`XH^ZGXBnoFn`gI2^K9>bH_!GDVck5t z!p*Y}CNa;BES_gLt@HQ2v1^`v)WJNP^Ka%?`F8W`o=2kj^?TghX@2$Pm-)4)er$e? zp#bLB2^;>+{Q8g@X?`t6FVZ!?RK9uFlb>Q;%E1TLGz!Cgw0VxMmvfCvD|q%ZwR7(H zNjjYhfEw2R+4721x!kTb#j|6F>U)s;p2jz_+{WeNcd3d5yWSyeyHO%z4-QsePTlL-XI+bq_d9 zZGO|apyMS`_kc#n)8Zp4D)jSNNO(x{Abx(^)RV)%%jA$L><{1D*5!U{h5X{JSHkE+ zUSR+mE`P9tIDY$}8%gQCSa3Pzc8HC%RW0 z`bB-U$a$ygY2zV(sE5A5C2QPd7QKih7AK2$duZEUnCZorwTukAk^$F*T`zJwKZ)i! zHS*r22Yb_+&xtJVyoAr@lR2&&z8M5C_hJO&qSEMQ=7TRU4qjSIV_Z&eaTa$Tw8Ex$ zIK&(|YT2KdWOfoRM(X)kwezvaSF7J?;78Z zThu>Y-$l7tM`BA?9xTyCjxzs=QjszF?l;**Tw>F4^r!TjKXZyImIl9#;2#A(>Ag+K0X zHHz2#7~w}zb>NO;#zDN+Hway;AIb*SwzT5 zRxiW>U>_1OkyOV|B6o&-D#Y_;yT!f43hg~x<#w2Oc8g`p#pj$azQNseR+<4AiLSu# ze#49_PRO112`}68f~VSLzW8upBu}RUsv&Q@Va8GI>7nqN!@o`!@Qxy*#6dZ%3OtCb znftA3TsN{e=g>f^t*R%-G-{>=OYs10MP8G)ej4(MMlzzDVt1>c?W>WHyL(>F9YSB2 z+iz5y{$aemE+>gfe}eQ!Xm5%C&bt~v_eS7j#LAL&l^o*#)jecYO9Rch>YG$0c!EC> z{kV6r?zQ~RN5-z20lD&*{>EtMu4c43?7&@;F_w|#pZrBV@PJ@idzX5Pj<5R5HPm2U zZSz-JU*G#LorFh~rMyuUcs(pBfsOGJNBvsVOO=W2)m3fOjkylbC_mv@QPc80L;QpN zk5FeuZMaXP=-eW9`J#Y7tcE`%v!D5&eMjdmN8sDxD%ujhLDi6bJJzO}F=QG5?=aeW zBL#}CqG1Tu*h*QVx0SQ0>b}7z?%T1YJ8@zi)q!UUs6$ybx9uklf*A#mvGbb~&%WkA z#B5;zQtT5s%U{i~$d_;%CCnnNe`Oz1i376Nsp%TBxkJSfq)r-NM z)bPj3O7GH4NF#F+wI*v{4QKE<+5q7>13a-d)i!vJN`*!1Td8M~>ZMnc5Uk@5&1ro= zoN^ebSko6hMNz?PVi9YC1BqMw8!}R<*{363j-oz}c&OFhs#V){D#19zKS4L_gW!++ z6p0unZ)z!dRt~sv{EEkF9KXsy_+I{Qan&^0NE0+^pMerwaaE;5(iy z$UnB`aU`gUe&Sv+x%T~u@ERWJdkG)+-83h0;?bPcyvTbRtWC1-UB>{>3jZ2TA2c%Q zV>virFQ@-IC{k=UsIB2#t29~^Vx~1om9oIaw6uVaNZSf_-L>bu&!w9-g>=)NNSpGy zi#IKbR45zxmI|eW!80>>`^8+&ey^_{YQHyE*V-?(efE2|85Ae*R+(9?hUwAdcm4Y~ z`LQ+~}He-8RRyZ0=lsRkJx( z@_e&N0d86&f95T)#DW8a1?_y>ikch#1O%#l?c@suM|I^oLvww2?0K`ZN=7eK!dRKj ztNqTe)`6AkrZY8b)GahL^7ZefFH^JOsLnwxO!!XPY$S>}!sAXoyqR~a;MPssy!061 zuxmK86k_;mVc_w}>+pdqQ6iHCTdZ{(t9sHv*;5ohhhR*XIk)A>9pq@QTdnN9=i*xF zSgL!iZY|Vm@2FPx3`?$l@7#nzI1Jo3-e;XvZKYL>S4rj3l&YDl!HM@2RB&GAdeQ5(E5)h0 zt-|m*s5^BW?@k4^rd~3r@ZzL@@v*^*mW9J z!ou6JyW79TmdX{8OO4hkR<~X!l`<{gbROO-k7JD+*`ky2;8pAMTG_V*htZHoKIa{- z(x@GPBcI8=of@+Db`3F35H@5V8Dq8B___9c_;1>CxV7gU*Pf=|t3AsK?HLM@1Y@m3 zY4p3+9;MnFz#;zF(tlYz`rML$o6c0+%Jo}CVeES+Q%%-=|BCQCaNn_|pLXS=-=ci6 zrJK9r*L1~;u)WOh=_P+U6lBa_uNB!-fhJd!pE=*?{6x0yZiotF<3G2amP`j5qjr=7 zJJ`U~@!zLs6)6zo_-qR2+bt z8C#-G;WDO`8$AzWPXZRpzv1@w2$hmE(ZL$GufFvLNVG5SX8`46DL7Gcd`0sR;{)0g zt{pEa?#NOWE-y2lk!I(P?y3_xD;UYAHYoYwJx+kyMh_>|#I)vBK{Iq_Efv2hYUlEz zc0PWe+POgO)EkcQld!(O5pyW2?@#qzT;G`nP<|5#wyW=;LVZ_ync>~*`_)2yPZ>{r z^G6recN`*eZ0Sb&H~0m8>NmX*a*_G&By9mV>}cpdWE7)&<2gq2CnWjDM}TDx@Hz+h zNx}g>BtX%nKbugI^b1`%{hDb!If!e0e?&5OVP%m#Syw$+$8hEUSPd>o=(L)Ckb;4) zLG~pc^sGhy-SlBTVYxJI9uv=v#gK7p7 z3?+0r?6Wv`?{Ghg@fPlpX=6si&1$$S)?Q@FE(b+hZ)MU>)PI;>EgDjdXW{({+s5?M zKA5eEtFO`*zoNm)_d65%XlvZfji=r_`YHYD|M-V$E0wl#o&E}N<6*2DHX*2I<$#5IQOHj3W- zq8Cn$Lmnbow`e^)fkF|C^ofq9d1goi{oVIS0fJ2YAj~fQ}iv1JP_(iYS{}qkacCXmaYXR8aIg>u!UuM&C zpC5y~+bi}EId?5|G@w`PxplMBzZKA2yb7|)Hdf_&=HpL}UJI_`SL{Wg#@)8w0lZO+cO2eqp_OeDvL4XS6IBc>Wn~)a||che=?h?Y;Wn{MxAHAu?#e8VZ5$@Lv4{dq-FA zS=stCafkIsud?RLS2Ems+BBY@rI8UOtYwl6)+$t~j#bPuEi^+FHNv8J8r5DtwRtIj z$Y{A?=p6Glm(ji(Zh#VOOr6e>=Q}dGmR(r2P2a#qn%3Ji3jAXPS!v@%EA6wi2ucngPhZg`FETtmz06cq zJ~s{pw8;*YgsWVCn?S+1Ec~mDi@JPv9vWob)U!vpr*Nz0MPqHW{Ff7M)x1cn=Gk}& z3C;p{S9#td-#msz>!ZjcwVSJj?V+p|&=`uJ)9INRRS@VPZ^(e^U_VgK;St?ho}!Z` z>J7--de_X3Td$1MQ}9I=rSh-;lG;d7m>nArw15}n>3HtcDZ|=Zjyb8h4?jP&fy}n5 zLxbNLei7J4KI?Lqu|IvUus?k-c+ccjNjGHBq+$Cq@%y>EA##Ku_%&_byNEhZ1)kqb|)U*|K5@0knr_2eVe@X zE-jzf_I-L+@>Y)+3o2)g0FNHXuGk-Oc_?oMpHc<4e^fsM`xjuD-M`}}=H1aA_Zrsn z4nR9MIeT2qVe(1e$q7{J&M@2?^0$*&h|&cbxs#e&fn^jrp* zC-?iwajNO)-y-Ask2ghqomIWCpVq!o4Bp>Ath|Yx!BFG*_-~0~ zWvtkCx@O1-2(QrJ9gl}i{zn%<9DJvB&FhDw8O--Pw6?V5yQPkZ7}9sFHUoYA7qzK#CIqqwx^~sEC;IWn)-_7L!8`$ zd^c~DmPOW8I@`pS=&(r%nQ!R|bb!Lt7}Kq-}~?eynJ! zL7}4+s#oX`LjK!~z770lzNp1PcUTYH2ucyh>5n4+NX6kFMrcR*Fp>ScY!|Yhesa#toSB?_TsDPvHVf6!al|?g1VmRoP+$U8krGr*ZW`g z-sE6TYrkjE=jh%Qhj-?Ih_^z$^kg`Ca&jl!KjXtYc(r;@)fT4LkX`NMx+?foC~~Cr z{t0D&`WL~l1C&7aP6OL3c3rjG#J+#O&VA!}gqnH%A9&q;FLV~B{g(>NN~p5*yaT(X(!TC+ zk@tu=y#BwhbtoF`XXzwccv-Ytx}`EZL}YTeUq zkDar{Ihno3lJXCzDC^94Hlt-bo@<@OPwv!7)bfNW{29yaJ3%gXPi+K7iP|Mj@%qTA9J6B=`^bCjC5-m1%9eZI-3j_ACOhR7!TjO7CB)f(S zLmWI~vqy?MmF?9XL;3YTgBVd;d6{Q`X~_McGLb*siFw!Qm`f#BB_^LSDEsur7ZRMh z$d=Koe=L!GQeR%WC)uRr@-oY)C?+24zgL)+>l7}uG&l0huQ&5SlHxg@(|*U_t*dDn z?JwHC@eLU2ZfbkJ-!<%USP>pU@NUR{;y;K9X+hstk8O(Dz-VbtTD(;h7ut2ld4r&a zB(}ath2Ok%X_s+Y>3b7vRukD7yv6KyaznheXQ@Gk?V&5$#;WB5Xn9Zya0DmY6I{jpjV^n* z9*EddffNmUzTZT6o!$|CmA<-Z2&=>Fi>Ro41G72m9QIOx6<3H)ddL=*X?F&U6F^Fm zTrtRhY$dU}a3{kG8^A-ws~A8m3`|ILdZcZL`7D?W@;2VImwitRVIkHfg^)kk!Wv@z z=d3@pSPc8%;W1xV^*@EJ1}t>|)M}7_&L-TN-KOTzgmr^y!e6J*U%MCTZKLUBG9YTm zzWZI|XfM<1h%!&R$=4(3g^vJOVIF__&2(_b)ifNB1rjq(vlL)ë*lck}Ori z@z=P-S7?^64*pEErciU`!|}p^2fJ&eu)kKRqJTD~QLkSeOqq9lhcbQg>0IJW%I3wQ z#gnNP07JgQg4pi=ZX`5tL?jP6-P*tjI`omor)GHyJM>u-8BUH{QbVKLYcVvKeI=K2 z$bwIj)G#}EY2J{`T_<9X=YHD4Pse^;dg;_ZG#fue_dep5(vsA3!=Ax_Ja>b(0=a9> z?_8v9Z|9gnU0{Fb+26VLSDd?Zk+^T?B5~->MJ@U}bz0}trp~ETI;T$RoI0^{ zYGdcrc<0pG&Z#3hrw;9$I=FLcRp-<}ol`42r&e@+9cO@kIT8gYck9Satx|np0n#DX zGKJ9}HaIS`=WuAGM-3oM1nCcd@Kw5WJodEP=?@Wou6^GZuG~qrb-CluFH$h4tJjmD z9pV{H@$9JT1lu?+>cw*pwkQLapDXIMzExWfW0dx#NQ zFC=T$>4qM6pK85ZSH=2t)a_5)bGo5t7xiwn%X{gk{~z++1w5+i`uk5H2?2={6$CA6 z)YyVbg({W^Xhwq0;6zbT@s0&8t+t{hs8t{~Gs<)vq>5Hs`YWxpwboXx6csTf+_hc+ zZ&<71{T!o$qJWo@|L42*IWrT$w!ioHzR&YM{}&%K=j^@DzO23W+H0-7*4mNe0;o$g z8|#pt&J8jmVPor2mu_3@M+V?;&0A$;z}V_BJnXLsK!Pb{8^k!sS8rl<6;JZjyUbXM zsXRIM0k58h(d5Zl@4D(iJjq#)AZR>Y!V^)1tgfyN)uhN2b}nl A%^wZv1T4;d+ z?Z<#C(DP$W^QT)Rzi(x{vFu~>DDItmV-Td{7A<^;G%mTp*3fXMTzNG;NbV(O?v1;N zn6K-XYc?Ib30laAZIO!2y_!izp|zL0q4ClG|X?S{1x;o$Asc zz{+v(GMflF4iZKrr~#j-t_=rJ;5$@2(dJ;BHPLDX=2kcHn+Ja+skm~r+roj13rbpHIjv^T0mJ4VkAS+utv(Jh$p`{WY1 zgPpX+*@{=tqS&Oj{FT`@Rqu$I2QuNiUBrYZ)mOK!vK4<((SdZQr8QUdd==d=UR`#E z=zfe(Ob?RB4`Pl8FC12aD-J=(+%FQb%H{Kyg#+3sd zLIk0l@FHw?66HXU39eiLf>2I)5tf@wIS^!+D_4LZloMWr<*ue22(p(eSAZatYt5B& z$U;#N#50vZA%aj;Na3n<$l@=xQl%f?#QbH4ynDE&aj19gBZ&6LXbJ1goTU7D`6K#( zJzMAH$*lCOzbD220Ce=K`7GQoqi5vg|I>9El2ZaaL>D?M0o=`cnDv!V-_DAFSf=z+ zosTPkn1o}Djv;;egCd}7SMSfBDFTk6+%U?Cjf$t|nwy~&hhoPW`aIgzKX&!<+>u4n zl6J}c>#B=$bIOH)-k1JVfWprLp{P)Aa5O;8^GkMq=*$+KaV3YoLvFlVU)m9wSpDRS zG@U;Re1tbMJ`3+*KNloNm_Q&aJPSO@+&)75*On#mXhf? zyp7&p7n`8iet&eaJ0pf#Fjjz3|SZ zW_AMqK)@30!}4K>r?&@aA(Kv&J*UGW$xx~jYb1Lr9e*_7RfIBVoQ;Hs@!`WHJ$S!w zF+_|cbz>nn_>GeVJ;kc57@;<#L5N-7Awe{9<6tU{W^NE;2@3U-GWcYYkc=vcI_Hp1 zVsYRvp?hm(@ya;|pKCtjnH!q;*rpCEcftUlIgvO5YdEX8vY)?{l>GcdB%!Z3E?_1> zHOTCkKo9w^`9gpZ?}7)>B`+L6e-^(+zPEiSTcJ$;*$N*;cy0MJ_Q1gUcES3ibERKH z5u_6%osv(=!-Vmo`yVezvDZ1w%E2l9S|Wo2?6iSFb^cqPaY-})cP`0 zRamReiwbMKRqu@ND{w{g2XHSy+BG|^?Lc=Df{u6VIcBG|oS}(s1qc%5+-71u7$rp$H~wb4gqL8xR&%Kj&bVJpT(M26noqD=O`a`xqrOogT@zi zyKgOkF~qfF2F;Uq`d>6PrBB`nX6dA5XKTa?L1q`$h)sqP&ThK^wNr;c$Nf)?^{OrM z9(-8qm^Br$b&s&&dcUOA=#oi>!E1qwKQ|~JRD`BW>!hJ?evK@R-1v#@)z+^0_!)o| z@^VVKcPS_)hzeE$<>dl(rY8dBlCu)l#FV~-hs=Ht8;9!z;FAFNW!1HDE#OZD z`52ldk%9C^#K<}Y*7=w?k`^~8)*W)u^|I>ziJCVXUsdc#0MEyQtdM??H}!rty}k@( zw)N>nMj7;}pZZkKB!aAp+!0B>2lz$}CJfIcxLnQp;W#cV!}Ef`l-$)3ME0>Bd>%v9 zq8VLTt{GKmpZ6^?WIwM&Eq=>@XKrnz#UTG>CeQGANz^9iNllJ|I)r*K>SWYxoHP*69NXy-G)^Dm#jn=WySG$k zsQ-@jtPW}%1`moC)3oBGJx83h8tr+uFGiOvvG)G1_D+UH3ERuix)j~G zm{dHkdL$FV^GyGSqLtJMUJYyd#%i_(_U&ACn3TNe!UU~t+(3s;Rfm#)Q|hqN=bH7h zw_2(xok7cP{Rq91lW0f>w=*9w{gLfwm+={Q*yQv*@yys2)ZPU?YV69sPMfp5(Kn7H zGp~tJTUEd0Gj9y_WX4rxPlx*Kw-*g#Ofqb*$j#$uUFRDdQE!ZPJcmNsJ48kQwZX|> z94%#he7=*;+CUxHn+U{6;pzkXawK;wUK5jYUqi8fl^xFe?Tzn z2MXq3_S*G1m@Uve05chI1u*;QzJCL=>yA;qsSWhVJBoS(&420+4S@3~YKO5uw45Ip z```QtilbvC!z=GrYF}AfUDW=l<8RYT-ESE8=SAWJVmk&0I^+&jRI`pD2>S)7Pl)gJm6=m3w=6{h8c!C3MB_ktrqb%IOKKWsc?&|aTugqrWr$E*Ha z(8pu)ee5rUN{5{sM<-`{Cs9^#^lKR{%*8Lt0G5sly^jF6Hu!R(jYJ>O8(3=p2&2_W zp>MuF7?-S}LjUJR*!~4=Ifn-G>$PA!DIIb9=eX~~_2=#85W~O62rTV2_Dy7_RVFfx z?Ck31Pr`2IW+gTwH!FuxB`W(~V8U+E<{4EZBgx^0UG;+?3H=AJ(>V{0vuAS3By#b7 z`Ka`UQMyLGzrU85L{P@#vexQZXqD2W=eZaw?%LW-)Is1 z5+f7;SN2T+|Lh3Ag!<}&`mSMa{IhJ8G}-*vQrD^+ye@wrSbd!~xFWZ);Yr8EFYm(u40#snFfo>K>P=&^q>Dzg zUnrk4#d-Pkb(?Uu<;;*j^D&?(Ec>#R6~qJ0jM2L1^^H4lbN76Q-c@rrH)Ibgtl_1w zwYb}xU1mb6>TjevAqSb~Nn9R7k7{<3K5X>fJwjDj*hXi%c=C=$)2pZeR2~}a_RB)L zm*ZRZaLkdzFB>-l7LRib8S%^+$mMm4MX{0dGCMeEpPOIL)@WliV3VRPGl&Ebee8P> z9%=}LnV%vZa*S8U2Adu6?C$h=B_=YuIg$o~{ipED_Eq`%y+=V*W9d2d`#R{7D}R2j zrS_i{l+RFJ2)Cb=#kuFgT)A+9Q=J1f1jgNN{N72fz2IPw@4v(Mnpig~%}Gk}9t#20 zD?bilRkY;?*5>ztg7BmLhJ61_wrto(s1t3uiegsaS2=!DjElBZ%L9ZVj`>(TcX&Vi z-3|<)$@~5)qm@lUFoE2EsPntiXS@(_j97|X|Nd%<7OX0#z#}M1X#SFlXm=|#e}Nri z%ZEbU!iuPeB6C<=y8Rj{yL48ZDgBsdVRx;%0g|@Hnu{hI zY9<7c0kQ^dZtbtPWwGnqWkDhI*87^+z?d+X8po(c>5QB7OZ>e#u!(#--oE1lt~9Sh zvyA3!CMEPw*^{AMk>uBygm`mDY2?NuG#%OAw{QqHdP2z}?j=9AV*`i_YqV7r4DvdD z<8UoAEci$6;9B#;{d`x~!)kVWBxep;{}nrB_f$7N@^fyU1@W z9+Tusiv%gNMK~E!kT6?>6R<@Cx#xV(#4e6jWI$fm9VI!to4Uo*}bg(^PblO-!`bm0AJx`yo9VUh z)TF?`L#@CkAV6Z+!2R@+Jb-RO2&i^oPZDC;<6*Z)k8GrY#`$ub z<@2GMi7`B&{{jF!^w&cz4^_cD5?XLnUnLImzR8gg#Dn=SiQIUZ&?(#dp6X8XudL)V zpo}3&Qa1fOaj>#HctRWVU|$WobUr_YR*x#OHhX5xROjVKIw^+#`m%vnURdKfB zKE2yP!vqlIoR)IHdiJ7bs;1g&`skYxes?J1f*2&lJmHf*Wu(dEY)@+Sg0sD&_U60m zmuvB&JmXX?-iE*Sy=j2FhHfp+!LIz70@onqKSRKh#0lj-Egrm(2DqC6~;;W>;B7>)zvc z1!LKhx0cV;ifFz6BU+iA7&fA&Q3&{JE!j-z;k*QRi1I)!Z>gY0*}PGn^*kqPK#;@MGEv9@Bvd13|#}gs~*^iW;aFi+C)W9Dz3N77x9j z<^tBpWhOG~TRkAXFSnoS_UZV9S|bCo=Fc!m!ZTnklmN^6&scA>8HECWX2-DOvG~_v zqKJLpth+6p_C}|B5+&#S%E+wexd4J20AJ~wn1B}CgFZRg~1a!RzV*6Xmd+#4ZWRjeLCqmq7KRz<(% zMZ^`5am2vn%TyCtSX*^>6?WuIeLQ<5IP{~~-L*{gb|!WD@Rlm-$D%;GO+IriSoPo3 z0x7J%Le;D81gR8XC9}9$ON{c>^JzV78PA?jDLV|jizBzTM$4B)lJi*>s0R^x zw(TCd;db8Q>6Zt$#+%>VWb-Nt(yuJCM?WHSx5DQyYeen0KGwWpQ}de1X5Vbz9dL zx8@f|H)$>&iEafEqRn5p6|yQZ0IYnxf#q?cmd8q{o@1lf=fNGTQNyp>OfDIE+=fEL$@xZcU5{9E04*7OSiPHAZ&?Lf7$I0Eys2% zG4$!RKRKnA^H!Ksn$Ib-oF~GZvV2ZA%egbvLDsu~fG(EVZXnkFiv@Ff6q~snwS17KWvAZ_U%wcGtq_<`%{Q z+K*3VUBozkSY?60SORCy1!D6_SkcD3oOUdI$Q}dykdI&L!e{<1AlaTkg}SyU`tLUf%^!!q66QxW9$W8 zQ*$w-$N8qCS5pu0i%Y4}RZ_Z)SIjD264m34HUx9R;fnXrJ3@ePj2wfxkZDcSVP@o4 z(Zr6ks-W_UwmKO<6oH*V;kc{rK{&?%{a%GNcEr4bmh(~ykVLL#+>S+ zMgsfkBe-?O@q387hzxM27n5Z6ETxar0u1-)WM?~$Nt?v)f^9%PXDtptVN&{#`2a%G zUFr4cV?6fESK#d;$tNwlcb060@_w%K49Qy7MX z#7W+%w*d)FIS6nnodcLH-zzSvjm%lWO^n?ls*J zpftQbo<+(1REfqCMk-MIQTX%A)Wk|U90j~ORf5I0UTyXIQHOYQHl#M|$ucU@`V%j} zVGA<0v!jrrr|6B`xg}Ot<{sY3^Dj;niiQ1(e=E|Hr8vB3XHIJWk z{gLmohO~UMy`Mrfi_f91Zp*1l1} z@2Oyw6|4;irX!yID$KD0eO^5CqnN)tOC@}7mOcJL=F05xlc-vXypA~<+e&}Shq-b& z`u8Szj;N>G{D0)u(+;#Kw)G`{iOWn1fi|EWLcC}ezsy= zH|38wo_w!@lVty5>$dwop1CIG|Ii3rlj>_38-CfoTy!%}deEL)|BUeXV}f&lLN#JH zRx}qFI5MmVh{5jRf7c3I{idz4jm6&^ftU3^>Y+pv2d!t-(1=^xtF*T9plBs1(G!jB{sAU$*JZBiN1WDp z+dKQmyRY;w`5?fD>>3uliB4z|UdKlNMU)9(B(tPp-NcjLTO17(hoKhCt!22qK+e za38Yor#3H4#Ni}>Py5`CO~<&F)yODOr%Ung10mcx0v>G~2eEq}3Ze1pQO&kosVT`) zt^ZB7tX#RYj^i>Tx~SYCDtEKWNvQVAa^-3x3qSCGpND@m(!$j=;#eUX<=!i-EQfW* z#bzsR+LKCCtrG20u}?URY8eZI;P74e;B1Rho4^=<9e<)NLoEMSG~51$`TPB0qUOX* z1WM26nFTm~o58@FH5=TNerS;b`Eyu1jeLI`%RD?!q<_b$Yn9&dLDx_W(4DqOYV8*A zCE9X9u0Q_eh~vR}18%Q7c)SNnL|gW>Qgdm=>kd}=rx=RY5>NORH-E{m1M`**(xx;E zWQW_#W3L|Mr*tKHFuy;Wpi%U0EVaSJH#5O7xD~hX?&h1xJw=&DSZctK3#`%$Th>v( zzm|*D!trtTZ}bK(uvZx@waMo-s~R`@f7h}m-oj6V{*9wUEidKzcav2@HyWxZ*=daJ zAuRu6rqM9_!gxjjk=4%hvsXcSRzkU0gY-84-TeBFwj}cK>jp$~=Mj_g={ipf(!DPr zC(vO3AgiOO)`Bf!Ci!g4Y86*ub;`lWXKeqWyAT?fub~p1IOu zGtU>_0>0!^{m~?`L6m<7q`TrXHL%!Pyju+nw9NB#7BEtb(P&CVQrJ3x1q7hOOoyBi ziR*xN`c-d%&?GqGq99Y>)rqji%XF338?~hIl^n!Z7jUMnpcvCD)nj9dU!l!_7)Dz@ zv~Ju>l6rm@>kfSG?&!e2eCv(k!TN39^5O z3R>3WfP3nDyspf>9?vUy)8iu5Fr=#^Pu}L6Sel+%0FjH@=fWc-iZ^jc&b;d&BE5i$q~u|9i0{LIIj!0t_BW(r5;uh~p3I>^MnKT~?5)zSNxpai@oo%mK4 zt=SjBndp)^1{iI;o0x6?cE0qErWGAQR7P9;9H{&lSxnRw)YdqdYA2~$(7w_F(@KqH zv9zNt@8-V2gpiMnj`HP=7xHDK(IjfI}5|ucS52RMq}qux`(ark{BP=Xg8m z4TFTIH*+S{Uo*pA)IXMG6A}>{R0pLU-szl5%<hH(_I(5TGdf*2 zkT4=E$`iv5uf}>E@Quz~cUYx2C1bo4grMax%&1n! zQ*~zWbgX1y<)W--;aP6`fJN#={`=B2%0Y1Sw2$eU5%_VlWNpSFVB~VV9{7u8unz2M zdBpXb!@`nk9_Lp#Q4tT$|C?mCU0xSd&vWU{{hM@@OQbs|a2}lZH|ZD}^6GrRdBul_ zSLXuG>t)uq^8n`+iIKnff${gI>L!}tVUF|MiR>}g8YRWKhw*T4bt`3bN+X;sIHl<+ zp8fjeLg&t>G@84`KgrMCHns`rCeVJxCh4Jn)6h#mLKD$S-{4$KQyG(t%VI*s!T7yL zSyAx7M!-jcbYdrAMxOE3sb)0GS`>uCCu<2D7XE&uTOl$L3|y9r>XsSNn`0|8 zcD9#cI8gEK0uFVVp4Ii4R1;b8Oe5#LY-$_%ur9rtZ$(DN7%vol_pmLG$jN9LxHa=4 zY7peM_?eE?8cb@&#gmpZqdFXg>ru}Ww z-zisjOqtv|H%Pq>}IT8Lu#6TrEA-M-E?^B(B_;k?S-pvWJh3RqG_ z{$W-@>06wcg{#v)A5mx#tG>vuP&qURMSfS6W1U1>8aTDpYH8dn-%^ggn(D9Oa?Umu z?Ex~ul6?OI!1LQf)y=kl{?vtJyUDP0Zc_mktq zG)O0()D&{LP{|X~>?wGzYNPz4l6KDhC%J5wlAU&u`z5(u8>Z|c=L>R58qVHD&gbNm z;svyGTc43r)^NzqIcIGnryFh=I{tKyoZ9qn?gG^PvHU4m?z>*;SEV40Eb#@~?m#+qQOksN!vzNV?GE%rL8$%QBKH1Tw-Z?P0X#63RwWhpVK? z@Dkt63dwu;#|W%emtR44fx+7)vlX;a201gKl69Fg;B~H=+==12nhYESGB?|-L6zd^ zH*wRxI+j_|q|wNnACg}lZGL^#C`s%G2#ushbvLNZsh+1|H7{_|m#BFauinM8c)=U@=(_Y8T@=dAf4tSm zm3Ise-9%2*M-E5L3tJx7DA~xmh9~@edAf=xw|!&mVqVzOtCWYO*yT~4Fxuhi6rP+* zsxA+e7xpFi{jz)W^gW*Lt!|#0Y4GHnv$f%- zeh3I4S2wxR>5V+kv8ekxmRm!eB+Rv2s(F}i@%DMRw|WC}!oz|fvi?nB*~LMK{W;Ye z+{el4O6HrQHwD4==UTuT66RRceIDipVfW`-=o%8{2l4mswb(TzaFI5Z2+~!wt8n*< z9;5lGwcnfEWq^QAJF>jz6=X)9?@jg#zs0ZjKnr5eoB>d#Td2+$4k2SKGq+m5a6J72 zpYs;L0x=g3pBvtjmrYjBV@!6$jC231IQ*~b{yBH{IJC3ZZAlKmkLRl#jt$|3iQO9< z3ooQ4&?+h1$Lr8b&g6C_t$fQb0H2(1`9(ar7KJHxDXq}uhgG3(`87O+zU44^!Yuig zp9~5ma+u{d$PmNmM1WM>O2k&M17h`Bi^ZAYlbJQ7$1We^|Au0LKGcaPG2O^2gP2S= zh?gypXtVB&yqc1Zm`nL=m$I75heHL*X|JUmw0DdvSE*X6C}$7j5!iWf1Ew6Ji>~aX zKJ?h|k(9FsxXKfGaQ?oOLzF3UGz`MED0dEL!${9~X zK_#+T3gGVM)Dr-22=KroH>__wVsVnKcQRSV$9xpD;nr(A2UJ_me?0`Ok0XaT?}Dj>U|INlU6+lDA2Xd9xaVl3NvLwsk)4e@mnh(c1h zBfeX(BkF#P9JPw@0uA~9-;VfB$Rq_j;?fVbh94g~#v6{-*SiX233kK;AYjXJJDT$W z=QX#V<+iWfZsm5V$bg;_@!bx^L%2mj?0It=6%XM~1&!y;?N>a68`eaV@55~i4@vUe z=4BB`jO#F_Li|J%crSKAq(OV$Jo|OxyeNJv@7`k%vFGh8lA}AiZO?1aL&jZi%bqtp z*z+V#u;&R)-Q_@mzGR1e@14&3-s|~&?-=UMVbVZez@-2C_PsZut^dKkx0qu8*}muQ z5|hEkWzZixu_t~YcrPw=trB3dKnLQTD!``Lcy zu3Gl`8-=<#w^( zUF6CY0Ge`Itl=is#IxJ)j&?;008P=I_Pa_-dDV^oa=&ZbVZVDm7VdYiyyy12;rz1S z>DBFbSFX4H?%HdBkH`LawVNtXHlW#3}8I*a2MGKajP z6FF1~K?o1-B&S4p79HB?NS*d2>3PeXA6h+XWC8V9c`BPtWjpvt$-f|f?dywSh`KG;0!%PV4Q;c$)BB{)|F-fQQlyrJ4?Upj>^x8~QBxSaD$5N*Vz>P?nrxQ4k zm#l9JmmR_}Mv~WRY&t}vWO(a|3(|tF0J+@xQswkLb{3|~n6S}hH|ZJdCdX+|&CB~2 z+VltX)cKn$W}%%QgF4t>yNVy1HWJid%*m9r6jnaqlJ|dCTF^Ie&&`f_>19aA*uEki z?Kg_hN-Cz9<$np81U}wjysOHCZO1Em>{_cqQ{cntc6hs4{tADP%U=Q- z7I|fYgS(Yu0B`|1-sZ^y4Obs>lG9jt*`vj`tQMG(RBdSMrWhv~8p!Jq{YqXr|9k9C z%C*1Xol1?f&3kHAQln~;%zb+JOo}otM0GX-AQ-G@`{MU?X)md`o;C1cm9R_*7g=Z4gTNvhpP7Nao zz9FmqbqzI|=k)Q`I$O9HhatSM;#j`C&6Mw*m5vv$@b|TDIr^@Fd6(q}Hr76~&13DQ zEWauSYV<%1jT%`&pKSnmLe;FEx`c=`&%1jv{DbHm+pTxCNUI%@V!ny_<7(CKcA-d$ z=_@?qnZT>}dl448nNoCHTS@ps9;bQvg&;Jn^moUC=&M%H7lQR$7wL}Q$SV`Oz2QRs zc4>^uNEX9qcJ^4?8(2O+!I#%j4bkNqF6MbWwSeOqq0I&{f8O)IZ3EOa0Pn$%`^3Mu zLG0y#;xDC3qaZm{3}(gK-p0;uMSSZk{vTXlD}#RdUk~c_544BU(`Zeb+M$3^6Y@D5 znD+rMHV^)7Za*`6Q^xIm?!SPnUh(blHMpl!=nN!_TqTCEs5~a~Tj>2hoWUby;jjYlS z$?&_;=C?{3O2|ey7)j*3QK6Oh$*MVhDc(B&j3m$Cg-xwFjFD$yRuY*Z4~&!j>JP@$ z*L;XemA=SSJT^jlV0Dq$lOA9B;sgU>ucH1$l2`-DyO*`ahQvwV8t<>) z({5L>aCkA7f=45BR{GBaZQFN^9}Iz-`lFCXv@()pE5tBvWVzQ;Zs# z9$8KFqCvr36tzY5HQO7@fobaZv`xdtP0M-W((mRM_vIq@!%Ei=6J}Nnpflm-yyW3UbY0;~se`N9t>&jsk6G?oI=GFnap1gvn@X zc_ewGAd|Va+^=WNI6e~OLNb;=MQ(`qlQ~;0r;cC^3NLIeW`-1!a1TX%u3#9LNY;nIt z{~+|~5$x4elB7Z~=tfm8D(tuM&1|_--Cz9!id#6OwSMTOvxkkTyS4vE?%d*e_gTACIR4=#_pg=8OLsc zp>KcnR}X{22iuXn2XG6^=Lhz6PeM`X)j07LMS^o!ffMJjrh*E4M>~jaJX+i3vVc=> zFB5%DuTccbc+FD{-HjO@#-g#y`f#m;O@*zmMfC;`ZPp|>R(6-f#N`rP%tA2AQg`Wx z6eF;`B}z8Zl^Jpj!;>soAQtEv7s*RH+0&MM3RSyhL}s%_E>Q3Nv2n|g%1rbyHJGCSh*BHvCKGTVoW6gMmO)`TGcNFo)ySS!{|nx5s4t#2gE zVWm$U#dekK22S&G|B-q*o)_Y?Dw;||G~PVDyr|(Av^_@(#=@rGs4$ZY>{h}aMmx?# zE=wr%@k)WLad5s1?T65QEdmaoEdw`sk<%~sxV$KsT8DIo)Y4GhUrM~xY|@$H%FR{w z+jk4o>C4zRN8hB4h#9k?KEO_L3eB9rIDmcL(|-;S&)2bo_!reSJE-k_AxHW{f@7M< zFPvkFxVeTY3SGz?hVGOs!3R4=oQEqOe3pS^M||xG=)i|1+J*5Rb6br>&KC6s8CX;F zl69gODQ)dEWCA82ToWQY#mG&p+dpAE_hzZO-2f4{IoHj-!b{(JWxZ=O+E zq)q9qt4WqOXx`uAWs03{f3en1KCpngXLj2?KE=Yh(bjAvl>RnJ;3UP4$eD{g-z z;3MFNemWXN%Z&ID!X3Txe$GYh>eXQ2DPT(RCUM%=3 zUv@RDBVy@#W8TE>4tK#Hla%YVs_sNiPNxE|_qqD|Lw^gs?PQ;4`gF5-xbbS5gIWm-hp!d{g&I00)d`@a<%v5Ja4+*R*TqWD`q~UpAr30qk79Y zzjD&+vVsO@?;ww-pM{y>V$Op2cW5SwMKty#fF|$&b6ciWxe+S7LGmq2ekzeY`~}n4 zy{~uizSHeUKU3QEn^chPeb5?pX~GJqVG~#MZQO(&afQLpZA7n9CZ0W|!yj+tn0+w|L6WSH zE~!?%qcaVk_Knwk!adSLhfL{&fzm9%v7u9l)!+^>r&SWuCxB2Y2EjerL;!3Q3Ob*1 zl2e)JA$v$=%ybK{3*Ojn=@1XuX;n0G8}9igJ4KUi;x)kO)T5MANQCMtIO3DhF083b zKV#~JjV3?6i+TYyz#O%>WoZ@uT{f8Os?jaHp=dJ0tD{@mNS6goB6}wM+)A=umv-S} zs$3m4;prZ7c|v;n6Hj##pY|Sw$LDcQw}8|s-GXTqE=6Gj zjt@$btqM0bvP)8Rc9@ExGU z>-$Q3QuwkdyxqhbdebyYbg$_gp&d^cC}_`y1v{}kO|TvI2Y_3SV)7@~eADftxwYag zqSMB7Y-W>fSpaJJvYiY1b5f@6(;~l}1ovHJ;hOf}h>vFjz#|&q$I~c9KV+@E`y{i5 zptH}jZX-CFk6Ip4eX^a)j}JRkIy(imVHjOCy@jH7f#YmwiOWB|Fn@#c8?DZCucHq<62JX?dZuB6bk9db#1Ki-+v)k{g3F$CpzTAzlGCu zFSb5UPfBU4Z!>VYKz1)00=I_WvwB*$X)Sze-OcXY7ie-1&_HdUBIq{u6q# z`804SPfsTDouelQ*;7bQhVvHElR+$)|2{qWKAq0fljA_G|3!N8Gnh@$6WzxPO-&m; zsZ)Ksq9+HBQD>nnD!L1L(zP)Ee+xbN=+yrPJz1dh)c*;8G6B&Y{^ZB2jGpxVtD`5+ z!vf^!$s_Plj-He;bK_c0IMmUT14$3*$$2m~-dUUj{}1WOd>t=lMy%lA+1m!eH@6`8 zlfTlTmdj}vda?;ct=GQgze7)mv-f|Po-E_&<^NTBvV=9TGk+34xPYDv*UNuGPwqMy z9Lm#^UVP{1$-0B|6w;ITc?;>u1{TbJpPuZiuUOPc<4=wTwf-0B$%)GyJ-OzI0(vq` z_3etDJbRKl`_=U1!NUCiE%fBq^_}QRJWbSZU1uTvEh@1Bkq03Hk>?^EMnY1Y9B-Nl z-b_VkBF|^AN3k>_53WBlQYeOf70=o@A(lB>_kN1eLa)>sxmo%qZ0(LaP>UK{)S6cn z`nGflrs9#*MI}-nZS*c$k5FMV9!b`lG(-F@^g^}bF9SQS_KQL}*4f4Xi5j3eynI}NSS9|{%zvDYgm{wK z@A3Twp_fcVB8c9rjbB4N>Jx8nLp=J7xH$0c{%`GzI(nUc#^fU@;5j1bS?%pRIwVAl zi(=sIjjEB>96^fmW*so9guJCfHLu~S!-MMK#NH|!UhR!w4XP~QwjK|!=J-Og)IOoI z%^D39Zf;0er&MJxhg=C1ARB+sk5Psp%uCDXf+4aC zbqd@2@c;h)wbX%($IC$2CKlP{=Kq7 zP4NA^5p#Ny_ia!%v|Q>&;u6Z^Uldz6Jtv*!0y z03X)UmGXg^LXT3FB06KTm!5Qvk-1xQZi@IGIAeQf(GrK+6ru;Y0;;~h>>E7PGenX+u`X}j=)xXjdE^F-vPq5N9ao^?;g&|B$^9h?$1 zTpg2sd|2uA`?8xPIbS28_Z(h`*Yp%WvCJ`v8mz}Y=6mK|$NP!&2i{*8Udty3vK*ux zVriU%!iQDy`Cp(yaIuWz=J$bs1qn~Bq>R6iKOvrqV>pGbh4zw>8cJareejbmKa_j2L* zK31G#%fhvMa7bQco2 z2VrzqOZ`EeGTt^eemCuoJRI-G`5)z5vN+Q#)#8MJVNhEkHiNAD-Wh4^NcrV@^dO-J3B+byJr(jY zdN&ewBZ082tEV1GLQfKUl0Zb()l&~5p@M`85(vh+dg>mLg~#tcv+l^<^ZbP3Q4--h zmS(m%;^z2*#bAau&QC$;+gKS|u#1!8lzR_%hFVZq;#&U#b@E5XfGr=INP7j0k5KB- zKeA>xPh<*22BJ&4XjLSor&QHMqXdN;&eCCeH^aAvb6H&fd`JfJpQm4SON(`O%YCe{ zfqrg<{fJFq@CW{Bwig&((fK51@y9}e3&$G_ul<*zw|Tpy_B%Vj`|?1-{=$}p?ozQ8 z;{TT2GM?#HubcAZ`GDKzV+`QY`Haeq#fV#q`vDZ>XYdD3@0YiO_xC1e7yWUcz0Vm< zLD^S$H9jsM=+>5H>U(sr0gMwLoaK1gj zi)CXQbm4Q8+D9K=S|z3a%&}cNKuO}#UejrQIM|fIx-n7l^atWs#A8Ep(X|`R^6s83 zMt_Bc5_xo94(|T*ROAiQc2DLX=y1#9WG*V9ul{)&%>lL}t@3xrTZpAgEyJjJh~y5=*#gt2=&w9{gx7pN?Sr|D3v~X9|e8v zW;y8`G4toFgg2wcO(kF1#(Zw@k{I_|A^YS+70i@=cQ4~!uBJR}i?``GnmwE>jZpaO z;)G>Nf2MMop$4a*`>(V9!tOV~_dWWc^;B!u8>;S$0raL*Ba3y+0>J)dF`Aa2P>R~= zlTma-M|9|RcL5!b1Euf1ggoU7EW zmljXu*HFIw={$d?Blytj|2aZ}Jf)Bzy3V&i491g9i=-7v_>@7c#Q`pQ50~m}0OT^n zS+BGW;5I8{wGv?Ey;@z1Q_0ZvPv_3c*r1Y|l)wv%^|IwkD58{Y&8vE-j*=H7*2MzJm)v=@*K&X7IGk2?NJ%e$k;&_9M5Nk_ za4Gh5v*Z)=PI$j359yCc%M*CDgMF9{i@ zuLQ%Z{VpSljvBHy#S@*?NA=Xh(tOBmxFi0-v8TdF&$_gifZ5(F*3leJ|h?&(^{!EXDr; z7bkAHICQu4V#`RReQ3yL6ye?lA8aSq z3-({xeT6JIQ>zUg7FY-o9u`{+5gz7R+!HxYZ*oQMwWuQG%(nn23O`Z=!rI5e=>tZ}mL;T~K{LzY2!6jq-_%3(6A95C~4`p!_&xs$J7^=p`1sjMqFQhl08R+yS;` zMA+5|=mqo93I4YsQhf#dQ6+eQk+rfWv2>-bu{O5=8pA&-n-T;`3!--g6zyu5~?sdNeR1E|gkC&ERuv5+yY#NuEw?=^r>$GsNSMzcG{l~_>i;668q zIy1j|G8yu;Z?a!Px7qK`@E3>^c-9Mn5}Eln9|Ad2U>@XED6JyNi+ihxBQ1vTgIgV* z185<)5Z@4dtReV<>Q)l+2;PRLh4<6V0dVIz;LZ(!J3j>OoDjH+^T2H~q#}+1zXn2w z%fvIF_arb}m$M)M?wk;~a{}NpiLNN|3WLf9xday~Nb@03SY>OhL;;pN;5sZ9P#tg= z2f$@U`BF8^v)_Aj$gTeBl5HWmfC`tY8`(u(#zVmbOwpTv3C#N-$g%7$fmw%c(kR7) zU$dSs2!TnQB3fiD1(ZS{%YjO$qt21wmOT$36Db;A09C>?SV95Gm}d#J<3PnSwggs& zOZd-$NgN3S7G%hNSupndp98a2z?^KrJed6gU(?~<8#Tr-rOttPYtL;0y84H#J8K#B z3u7Cq$8bsZV6F(kXbYo58L?K0J%lSAq{8~}Zawf%&-3gFv!`VB-2CGm!J|sdE_j|9 z7OAVgT92{xdDT_z2Z_&+wu;SaWpS(+OWp*xi}$UoArK??vaw=_^Llmh4B~)Vq#{0w z)vRymjVbfPz_@5rq;2F-5NB2g3rCwR+2>XF$1IQM{+)~T0v%M%Lw0Tgm$IsPh|-pt3kW+s~U zYCf!soV>EGczrYyTOO@xo&KHJgf;POub(E0-y0>bx#Q3q@M#^QQw^6I?IE>6`q@bT zClUkxMu$pw=4{Fk)Q z_)vZEXNlqtT^f7^Y+0d&cCw2}@%WKIUz+U9FQH zUX&<)W>v|z1xKRMG#rw>vLjlvu3_IO4~b$gHeq`_d);H|Nl7GfL`nJ7u2Hy%0iSW% z!Zm;K{)weWlsjlkzfH7D6mMv#e)KJPVvs6z;64u2V}dDJ->|o4j9zxwj5W*O|1B$& zn=(i%`qQvXbf}dnVp@T_zaExbn1Dv_H56kCdeTI=}?5Nyn+Q8Y)la(geK*IW*Snuh`=2w1wDaG#hP?h|u^ zePVt{+K5SG-`*RNHiFYw0{as~q+Pmg3G7oYVR5hthx-H(a>%fdZuU!59Q$QYvR}3$ ze*G=G8gGu2@62>K9#hp z9hnYxlwh20ybC&y_XdnK-Tdxit#hG0;v*EIHlBXA9)b}Sb*O_})K7T%6eAa;lt3?5 zPi^J<9(h_Z`pdc+Hr6#rqL_fTLU1I}wLdR={IXCClI-JmCw#W(ge7M7yOlTffQaw`Pp&|yK2DFqL0 z!W^3hp|L%q3X{-!XAJuEj=rXiS43q9n)4dMuP>V~D zj!lZ}Q9EvDFBIw4_i*4X@M8T6Hz<1Z&;Zw)CYscx!vUk=Md+p1gKnumVr+>PEnXLz zbQ!;h>SBWF^9^h1`bO_^>hZrTnx6BIf}pT%vc?MNRBi*$$#)Avp>1xUcyPkMx1D2N_G>l~J$5>jEil%rEr?-D}!Zl`^Fr+sX0NT-NRZ`sPk7nFM6GEYB4-pzthvO5{Xdw`hPil6+7OgmkEktrY7G8Md&-N{%A z8T|*$r9T6``>!$5e=EdrHtQMU$5KV>8q&R3x;>Hpr%}lIv{a$++b3tPYwv4r`Fqkq zmcdEtQAh<(49()tXSAY%XYlK&;G5_gqfIlaWFIfJqdDB41r=PxRLkw;UsA!_C=^n` z6CD*?xf2zf;;7)`A{ZG_!B(i?ZmipQ_Nqbg=2e)5Y!DUPN=?Kbkl)}hp^-eHryPkm zSC{E#M(|4;2}U5x5Hx(8JUAoxb3oc0CEQ4V3?8`jW6tq*B!v$Ogk`ftwGCwIpZD#< z^7I3Lx&rzkLV;fW%ixBb$^S)Wc1WL_)N=?&#Y(nj=J_7dp&t>*Vf5^lGetno@&5o% zK05)~G(Y@nAzk$~Tb&c}4~@EQ&(YBrzM&4d6X6TVgN}}*O{1eDitR}TZQZGWcm)t9 z2CIV_QO~mi>e*31J$F|f=~oV_-+hDI|&jEo!ScksB zewD}DgB;%8%9lIiZDWA9Kgi+jUf@rFw=r!2IlMiOBL5a|B@g~Pyp5z35#HhMkTNw9 z;_k-X{uSi?5iEbC~W74>Ec$%I#%K`mNBw4G69VPyo z57lZ(9bh^JGGMf za@{(?b*mPnWE_PE1c|@7We~4znT|U6@OA5l8XV9AQhEC2q z@DRQ%B>LF=1Vq15c=#j8`!&af=V#Cb3Ap;_oyABDRWAVZp~f$MYAi6v`z^nC=ATR-n1)cTKF*}VKI!P=OwF``GI_-JgOW5<%Fu951a2#QWd z?#Lum85analU*fw-EqL%!HngI+W`*A+ryL-ED+*xAoJhTz?}mHvb*oB$Yb?nSbYUi&^E6AkD-D znu$hA1@B|^esTVNwBFCKTBw)%bz=StOi?)BA{v-rLhoW(7yVi1TAP?s2z`&+!Ghws zZW`ln=GwSebrw@+j$Ydg4zgLWdCjR3+>rp;sCWWES6MNXUz#=X>cIpr4s{A4i@uX8 z;oqMc>@?9ksn+rnJsu3uN#tbv{i=BlRBU?%^9o*1?&knf!L1U$#~h$AA>_E!t4ka^gEUx zs#>_&gLi+NgG(e8hjECbl9lyS&1>3B*i+)^GSnyCpBEKLd7!*(m?Va{P^{uF{k0^| zW~bBlGA&HKWaV%HwQ{o6vT{pF&fyy=*P(Bl`5O;df0I9<-Xe2V%>UAqb4HgUsm&#- zSGRs2>8pK=VA-s!1E;}a^62kNM({nYTY2@PpOrr=EH9er%6Ba+uiLrIJ0zC*b}V}) zJGpJhePlY2+D6Y}u-a;}JovuceU>-MR}!>x$lr9`R-5p?n&!vQXMpU5DUJ) zTi@^NzK;t(`*JU3fN%7#8~^X^Ut%=5D3W?b<9dqNiaIzM!=X{kU8#xblCB5ubfqRo zN#3`t%eD&Zpl2xsN%OM7_x=C<_a75%(q9pNpL0E4!%d{nwOs#xY-@`5hv+Y^$qP-< z2Os^KH=Y^7C&U&tyhF$>B`L8B0ITbQ4^ais+=BInrxN1WqXHGuXm}R zTw$q=LF$iP>Z>mGLZx0Q6TqiPSd<|X=`5a0eMqS{xzrCmP_rX z)XBw*PG`VWKA9}){phDIb)ri>$EE82UiJ5Cms;miR|Kh3UFtVo>U}}#?_6qMmwIQA zI^U&sajDIudf#L&rJN}Due0f^MdL}lU5kGiPk$O-M~eShB6C%3f$<$PC@(5p#fFvM z`JO2)hn3E2*Sfh5A=^xw2@(+sPq0*Y196tBptgq_DGcOO^!lJ|#l?JT@hDT5mI0HR zl@avjB$?L#@J%}Jc404x1GBHif$8Pqz_7JBp-pZp)KqF=<)vp!wUts+=6qrjjpSo= zS2rG^x~ZWmHer+nrHyf`o~}_NC@tsWdW$5#!)J;uI#FBg+aOXrli+Y$K}3#|p25*L zg7+m`dF9^w^fR%opT!2h7;D>joHm==mc|ZzF*aaZY}G0x0vP|7BQu{9Vshe?{f9ag zx$h;^Y{l{7SJ53uX0CzO#=9OHPh(8~6weM&sAVF_R}f~j5i&A1E~)6(xPj_o%N3E- z`{aAum_--^9TE3_&gc8gw*HT$0P`>ogFe2emM5XZZF<7c|?yF@2XF~BjO)V>yoDR82WXIZS{GI zwQV~tR{Zx^+vjDm0ZU`ql3Vz{Np=LW0n5^_Q6T+nTgL%|w++~q?Zt(B>mm>J+WV4d zdT+Yd_}Aub-6Q|iDm6y&%K8DH$ZTrn(~K82ykZL$#Ut@A&9pMvRr8qsyne!$^%LHb zcT;6zz#ARV2B;vhwWJjCdjYN{t z#&JScQdT#!q%46EW_``_$Skf5uuv-a7G-O@)Xf|_$fZlKs}L(?Tu)xxRq0*oYc@o( zdxz;=F(+o>GbTnFui;Jiyq`myTr!PBcHmPQpZ^8Zu!)n)IR+fOYKR`6{^|NzHVvu zj=RU?-4iwMOxqJRNnP3QvEr>WOZvEVgkKxyq46q*KAF-li)02XyV>Sd92pvx_xFxA zx~o*(LA#P=k1ixcraO6#6OJaHJ=u_{jtl$7>cF9+{kYk9=YVBgwETLlt2Q!f>+s@+ zD-k{Ah5D*&?8oipoEXa!#cvv&;abW_^2G9@qLVUXKkM7{qbl@7&AcWu-yw+fTMd7Y zJCCS>3y>CZmCMI=JZhl$Pcy7tDy2!kg)c6d?I_?oWCRDI$#2-u zN^jjRO+bzUHvE)&mV^{Ak$&Cb27bPfHLR*)TN(Girhw7(dLx0+wrvO0aRbew$}IL(0x5AcF_y$RKbsdKw8RpsOe#eoH}+9Pvv`5Lv8gi)EubQou*q#N!yv zISTkE-s;nH_`nfz^-HY`!Rij2DAo@^3* z@LsEk*E~1pC$NCF69NRIxo&5HD09?-pa&6UhMcXts# zF-yhE^2F~?d&yOCfqaXmMNu4c zm+fRm)QEy`i${8vI6B-0BdI?#j?i^5y5z_sMQCqhc|+_%xj6j>*K~8j)USz5qs2%Z zQ?Cw5vUk!0s!f(41*Qtz!pv^t6#;q&ffU(6WXxi_d7vt7z!KF=QWk0G>UPsHn{zK+r%y2JwvJ_Zp0w{wV5Jm=@K z&K2JN{fy8_TEaI}(BW@%$yS5lEe+;DwKk&~Q81mCp~<*}`OFW^zd66IUC-<+*6_gM9lVR~N1mGW zLwnH7UfQKF58KeV$zR6YN0;==En)w7Dr5Oggri;bQ|7Sc&9A{)Ye|lHv4ORC%b&nA zT_LL)6>q#(Sx{lTW_jaA|4MKnx@1ER@cu_|V@Mia{AN=#rCvu1hyA8~(?} zvAs=8(Zx!@;aB&+dZpchdxD~8nTJH2z{c)oC9YnRb6#JNsX#xFtS%=(&UsF&$~4O# zC{y~}-#PRfDi@aDNM_3Pe)JQe$qbydKW{iXmbrPH&{e|rx9kw^ib@4unRN;;n1k*< zTL2T!mK>q%VPo6ycS{T#k)qm2s$&o8%HB9nSVE9%3|6Pxi*UYwJoBr&$&jl-mE8RP z7C7?0$ESGwwaMsN2MiYZX2nZZpSmcwf5k&am(iE+nSu`_p!c=Vuv$E!l7rt~DxemI zMp9>LAWpk+BTd9~+eYdsdd>7ivTxbwNA*29Gkk;g1q;f(OS3V~Y(d2_<4pjsSEbF1 z%K0fmAECElrLET4Jxw`rA+lqr?vP$Vl6rC@5Ag{nc2aqu?ud+n)s)KP_edNuF6yBj zizZUimdM;M9U3NYW1t<(0rLJzRad+$l737NnbI1Xl~ha|jH#QIGSvI#Gl3UOZ>)r< ztCESFd6$Y$7|UsDVx^Zm$dscq?f?~XDAtou7eWk1@MbyvKk z)(f>J`~RMqd3K*{7Nqul-_QU3{9Jf4&&)G(=FFLM&YU?j&pfh8Fgx&$Xb@2x8)Q=7 zam3Eu5@>(Oadc1MUrC6~B|OyQ2fR~67LK%0jZ)wLqCrg`Nk3{xc~D2HdPv@rY+X!@ zml|c$2S;f9?RlD#6J!N>39m%RsaL6OkHh)Jvqyixqtw=I647U^cmuD3oO(q91UD=K z5Mi4fEnmb}vDsH$)PAJuuQ*iL)E9NfXMKu*2r7;PrXL)Fk<1sPahMMTaHv%{WJ|=x z;e00!n;^X4a2z=V2jv;()tjPrHg&BeQMleKOl^?y4M*m@A;`>#fs7Z@g3N1w7J__D zA{v?8z*BUF5F}R!@|rbDJa|320qRl5DtBqL8&4Zi}MG0Fx}~qes;X ziO&<0LC9%9nX>l`FB>#vb^kuB$}+z3xk5QY8{|OO3^BO^#iY?AS!XN0*GxkbT1Oz& zp+40j#e}a26Uv*?#~{I~AcMzaqK|fLTs=GKw|}A#FJ*U*dA_*g zCK1EJjz#Q&UFzltTKYs$WCj$$^T>OANYy~`?5uT^N^M(1vOI5Z6)$Y(c_{d&a5w$~ z@-J5zK9eb0`wK;%aLP+x;f+O~3>2sSJg_9^Pn=pK{f&AJuI9$JxAC7z!_H@_6+Vm&bMwEkSz`wvA#hnu#K~S)l)=sF$2~^x!J)tacY#hqBlLbefNFw&&C`rQa z;*s=zogVnaqW^hGFhhSS10Cbx3A-(1LGjoYxi@_GA^iZ|UwPK1d%ftFjw&}VA)v0r zsechNCmXIkHp%7Na>l98m&Wv$=57s>d#iMH_;CE-U8G7;hzJI%gH41Z&v+F*F7jCDNHSVY*D-B z2$Y8GIoj|pki>XDsk!E^x487c|>C^6{l*H~m5kw6OMhqfeUq0uPmXdXP>NHAMe>@@()@)d?-qNFnmJ#hDO!`@f`Z z`amS?CwrYDYU)wY{$@e@+hU(}j?TH10-ba3X<(T5-v-|yYaWZ$9-6?PA^ZLg;yVJ` zhIPzolR%o+>crG_e62IDRDCZ}+TIEwigW%bt!{r>_jOU~X)lNZ4l*l*w{`oyY5`I?wEp~0-AM_*i2<9kSXuc>_`4nI9Zaz&W-xDU^j~w}$RK7uh z_k^AAc9rkZ;J+OCu2uO$lJ9mq-xUU4s@_L{$8|#4P&KS(OToXG^?X+RGo-7HHz7~# z4t4ll%N}}M^6D=IoFsPBV>@LqGG$wMj*YCoXoP<$wN<`egGv7Qo8%NrF6VdtIfWe? z!ZW^Aq9!}cjPFV!QRk7Ud7n=*>3N@)@6^_Z6kG<8ypHQ{piVhEs-sIr%EFGGW`fXt z>b3v>V*zggy+LaNllc4|Y6k_1%G8ciF_p0tuYW?+@6l?E%)0n*q;)nY2kyE`&+n5+ z=M}EJ?J3YFZ`*4yL-1y0T`(>&oe0|p_lZmx`=DBZM0th`G386a5cK~T?F_m$3E$-V zuu&vT&?GGWy^!!(G#_K(MCh$ZxB~eW9eclML?NMDk?_!OK*Dn&YeXL_`MzGsnMI!9 zY&Dc2w`rmZ(d4nS7kAE0uaFV& zJtQ}9_Yc&o?s?nZLdOI){$n5%{By)ls153mKhc$OcpO-_h>Xg_O$p=o#0MRIA58S& zF6xvOtI+$>>adnAhd0#V{4)@fxdWqfa2v>nr)%H%)U=6e)UxFwk+Js21c}_hrGS-L zmufZMM-V|5MI5i18sav?i5-8 z)Js~^_=eQ|qd*NpomPd;{R32oRNEn1pzS7R^)m#FY*YA-?e*CnMqLr&i&W`!l%j zn58xUEWsjlBUr@IIT3nK{a9Ihe*<1>YdbnMcsW=WComP*ia=Y%sfB9nt>uv>cL6CCC%9C&k}?O26F-cf7?Ifg?k6)K1P zPF%>|;C~4&aevenvzVWSuZsOu#Icxd@_N5ad)cuwX?O5?MtO3oZXnz4;Hl78$@9yK zHO00LUcxZR6oTr-z~PSSU*v9nN0lOh`2cb77UV?a;3E$jH0}B((NS6D;Dj4 zDsKNHlh_Y}KXS_Ki{PT!N!TK|7N;-t8cMpp!cTT9t_fbq)fcT>CrQi;)gB@4Z1~dX<#m z(bN~#$9dZFBJ!?I zy_=o&!`A_7JIDvlNNwdif@sQ5I+`j2!I8o$dLWneXtqo~`Y?gK!X#D?t|B*Y!@y{_ z5W@w_yW#a7b6P0h8&e0!vMPX2ZORWRs9s;0a=yBgces*@a$auYyi;*pwBfJ-pnU6G z&I}H*0V#xF9;3Rw*DF8B_V4SekEZJTf51cez9EyvxmR33^`}yO z@Oa9F@rOtM`H*0lb@x)s+Ws>s4Wp*NCu5r&)%r_&y_Kf#y|e4;lega@dD@0iLvmr}rZ_mWI@swIQ7EWXX4( zEaTdn+{@WxyDCyV<&hH!9hg+|E2Lqi!@tYVt9Sh3}IY7Fo{X^l6 zvIJ5ttE3x?+Mf?BO%mqUYliE2f_?c7Fk{q`NSG(}5V}n9q#XLMK7prL@)tBguS>VG zy^kVO9_tk_NADxx!`6HbY%jc8klcsUTQbZ(`YE2Iwr-XP`=5J}D)gkVPCH3?+nbIS zM!B07&Y$`?O{U-BqNU~Ru8?JIwsy#*nf0*q=*w%_R4a;(omO9G8IVq8b9yypgJe&r@U)OvhBt-=}sH#3B zpd6U;f<+-NK-GN@tDaE}jX~8Z$YtT|DJSfp6Wdyd2rn2Ce`=E$SrE1pn|LSReNcTi z-wJLPd1O{`7)wRC4sLo$^j$TFnx70?-!EHGVCFVfo8jOimWiqGre@o~Z&;yKpP1l# zi6xSG3z_#mWAw$j+oed>p{I(7tmLsMsMa7Rhf<`@L!&!KrvqOVM_go|ZRgy(&k>;# z@d%tI_3$Y}hrN3B$$8tC2}~5)&y7O+RN*+f>OzvWLVI+ZLLn7U+ARL=yA0%_@6l&> z@lfeAklcQ@AgKT<^SMUyok>1h9`m;Up4#%Z{el(-kNqsH_w%-2t%%j=9TzQu3-^Ip?$Q1bfqkvr?ysLWjm)jUsn&6Gv%sdWUA9DWP+JlGUpV2 z$?cf$Bt0NVEmHfG(WqHJo+t5h#^r7A5p-1F{erImDo)pYIGr5P|uQLn;98lm|`VOzTd8H9@VL{jGf&vWi=+Bk~X^WJlMkd z(CvKqmck_Ix!($gS&yGcC0>g+U(d* z!Fhq|q~i-^4Rw+%&~z4#lU)q#ZR~Z2S83Jp#bU{qND?~5-r68*jIxk=1RbV62&6va zl8VnR_4O&IvB+NaUM2Y`IVh)J=4* z3U5@ZmdF_y6GuxnwJ5-n>)sPoJEZ&yQ(lh6E9_v=_9}exOq)_Cohd5_3zI)?`3cm* zm)V^vD6C{1s$ha%h+2OawB>~Yri!;`G6gOu;a1%ItZvI4>D9ZbHY&R=ocdBj9S6)knjeEn6w zb{V3#A^;?g{_EKUN&$P}qh&j4P|b2o(PGl?haTjaJ9rvwcFlEq-Qgop58JPL!-D!w z!v@m3WX`tK8=R$@2ObgkT#)ZJioKF6pYsZSPi4qOI77nXUcU1?z@8ht{pw@Ca(bIt zXHL45HpKX%o}7;&M^hY1Xn*l{5F+W1T**?IV#oz16C9h!|@Qc4q)%u8- zd#Ou(9af+6Ci1iYkNl?7r}~t)OSp@i^5zkJ=+72QQodz%)oW^It512m7i_wC7l-}h z@ADlOVr)lJbP^J&^W9KegTVrZ?r?t;cZ~iES(oHIsm`zHEzWsL9qaZRI!4Kmm@DqU z{8vRW2>bglL_B^?5hfRW@7J&H)CA)hgkHuN-tu{x?|l%HSDxL0HLp_^&mT?%{Sjbw zLXn$pH><|23&j9yFXb=i*U-73ZUye8ZNji^&!EW-d%i~-VYM=bHrTTp&byd5fkp?3 z+x&UNC1>$a@n_dx2SVpwwBuZ|1!cpC=;a56Lj$W{is-o_m*h|C_=5yz@yZ3C8EB7Z zFV&?_lXDKpqxO~Ll!(gf$SQhL#)#fRj%9CW*YziXtzfF02GHBNYgsgds7QIsp>@0{ zjo~^%$wSAK(bOKQXoTLs?VAT;t?QkqW1E(?}BoHyUWBSBCduM$7GdWI1h)! z{fs9}e({XYJ+zq2o$F+oTUOWF;>2W$c=Kf^C*xW{$I7GF8dLPp8^;tKvNL!s3mQsp zho%>O@>1|Z9?AXy-swclGtB41J%H51HpCC+$sPh#9=_+i8af4yApH#AKZ0ubB(?R# zc)($Uo7ts#Wl(p0< z+ZNFf`h@^d6X(1vrX@QU5htxH;w6jtFNzp1d4uNdr82hl*TtGOLv?G2XS`d%hH#sKJ-l$aF%dP zP9n!fwTQk+=7a2QjYvNd5YajM^@%565J}a%d?8s-J~@cE1IvbZKr8&vkdFqR#@id&_oEah>gKg2G!bv?k=e3y zK&gbb-=Ng>G}jg3b>Y9jKSafd`WlD&vKOM|$UaR6u~iDyaEZh&;pAvYpDU!7El!1j zUrnN^Oes!RtK#&N=#ji_qVe)%yDQm-n;V^@A7c*A_7gUtAdqVc>B!HnW=g#pF|qxZ zN>1JoIl)|3a>6ztk(1Y93FKrtq$-9I`PF{z^T2A(fX&jc5zY2Ck z96mB^;*_Cpc`-dO??uWoY~nw344ZP;h>_&hH8Aa(Ov6v`kB72W;Bt`|n$kK6X4^3z zjtO4GooNsJ{bum}2!F$U`hCVmzNVyJNTg_cfC9lw;Tr4-&O?Z3r{F2({RfdH^spd$ zBNd7`xfQm-4e0%d{|s$e7|e+H9iVsc>)^fP96{_65ZSRr?jBGm<qf1QuVydq9W`iKw`X7dwROC`{wPEo&L=n839if_@9S zsSSG;Ev880hcw5SMli=DO(=VtvK?EQEjz$jLZjU=jiQ=7@Qg1xu08){=iWh=)Xez0NN%A7VCD0%gf1AGCu2rF~$Zr zX?S9k@VaVp;0zlzX+@$qAKEdgx=ep12c|opzek4$aFKij z?j`_0=d+585wzoB%0cV|=pR^rIa>EaFf_-JxPomIXD(BwBva1XVPQ}RqT+7i#?C`- zFB-VB?<^ zn;V<#5LufQ=RTfzW?i4khKtUux<}jH^?oJ@X zcn&v%j7HEkp+KnhSYURhSa-rXO?(^m$xtwb=Ye$5Zqga42sNGIyMx@FSExxzPxJKN*eSUyVk1kG1*03v`@7zYQ?QXfPcH%xQqx`%Pek zKt{t5-2{xE3JkBnxEmPccv*7DK(#~0DROj34wvNEK#siajASsCD5c;`k>$?OcT15( zDe@y-WSJCsv56vQX`mazKwr=~W=f9VN{;E|P<(36;?W-}RuhA{x!Z*b@>ZCB^JI2X zE&S9p};uOMMmUMGIj+|<^` z2_z>EcBluf6U-B485I1!-VOS!e=*Auym$8aRa5XZA0F1ndePz`|5u7XM{^X;~>bQ;K_QVN+MyfCFNSr{&i`HqqLIKN94(AXG6k#gLD$}X(o*id#gGB&w zatFTQguy$ex6nB8bgR!ibFe!vi5`|qd2vA3W)$ivA>R)po8H9Yc!gdTxre^|uEu5P z35NPpOlqW%9hYipIuQ4J&AA;(Bf9~}R0N^RD9Rb|A1|L6$chXgh}i{DSccKH$_V$5 z({do*sFOHsHZmUwyeN_^ymgNv;oS3?Y)NAwbpKW%>Lswq!g11>ZK*T_l5hQuki3CD z!t;GQ5hd@3E0T}YBo8D4R*P9`>uz!i8$Afg!(D_ysA zu02@qf^-bU8MElWb+xkk@o}(K&2`}1^wUumvc!NGz8OeV+NT$${Pb5+SJI332~m*d z_N3k13T@l&7Ub_n3=x>7V?>y)#4_aTq!D>i`PP#!@4-oSp9b$yxV1nRK+gTkR?sQX z1@}H}`e(JLXJSk~7%!T<}s-9GW1wT5*xIQjRpjdqSM~yVI`w-i>IYQD!I(cJE|K zSlNTd7Lcip|0vsR^B*2QhU|(y~lR-DRm}Mf8ofAs_RX7tStz6dSUza~@WVUj1%A3wH+lHq_U6vBa~TYv0UOV28q? zM!&4@nD>4j^4}*~?)}2qqnp3aO8lLHYaS8?VaI`*RqRbR_DWxIM>DS@hWw-1Ykf3X zQ`+p(B~Fm#H-Dmio&`zst+M9;Vf=10bJ61-?gmS?$qm_QrTaT&&NL<;&{G?1Bn!2mp12C>zq5u*}AXGnm z_-dha0agzH9jlBOPBFepRoIcnAuz!^P=R9aI4qgFNP=II;%JKWL$DE{i1c=98>a+? zf@w-pcsYC;ZR?zX6b1JEZXon%?gT41R>^1!?X@0AKL#ja>7c>v4uYptt4G?cj&zL> zWY}~1_e|Emi#o1a7A8wk&OcLIWiF~LiBX~)MXxd7-8q9X?AIjmiM-Ca z=b#7zFZdX2ZLhi)Z;32TWdv?#`U>-JP;ZrX9DUz+r0%uC*nCw~deTWGkC0RzXAFB} zSlebOyHrufdJ#b}vUkd#r^5u4X${t4F&jTp55xYbXMgJ|QAK?4R_aZa&XFmW+T*LN zP~j~OwSc$eC4k3xpmq%jeZz~sQo3y&sZ0oC86L#206`VYD%tpPo~n; z*R)rr<)h!GGiB9O+Yw@x-KSWrRoZMlmN-Gk8Qq-cW#XV(Q5fBduc%hwO4KKJh;*r) zc`>&t$DS^zei+7$n*K49WAJXrm5jiplaU70VcJxweTesY4=u=m^Cy5h`tE) zZ(~q?RL|e&x2^Qs13oGYo~$~wMf$V2{i(oK^4WT%sDm>#@M>%ly@GtPXsYtrexFg8 zdYt*xAH0P&V&Zl9pV0=GoV_KM9hzUZ#E330Y{wou-%MTV6n*5mY?%?O%S@;(mx(0(nI%RbLHxMAyBa#2T{ASAhS z{S#&VwDn>^T^v{M2X3M7M8K|7_{<+_`?a1fsWN&`eO6gnZw0QFzLr4=JJLBE$&|cx zo)}OaOOnItQ_AC_km<TACtwI8vED7Ayfy+^A_@&gFOvZ=l2U8pGERk%*gk2%ah=EwI+Zsx})WN9NZ z2oD9%=2^IYL%A$L!6Sv*-&5`~c5Iw3)MQCQ2p7(;z9G-sypmD6=(DX9e2cg(2OUZ0 zb_!iNcQ@;@F$!5=9RZd>-hmArm|w@jsPOAs5ORO~IveQw;nzJIDa~H$G*xThFxn*i z`nxGMzpl!X40Cr)f?xl^djnGQvclMFfHrKb*p zUw;qT4$QB~)E>pJKI+o^S_8F(U!O!Nz^`5g5zVjh;}yTA(B}Q}YrN!!Usq529DZ&4 zH7G>!>#bVQ4$QB`QgA50-t|qJUmrV6Aq&6y&~*pFuPb0w_;nVmll$Y>4xsOcU%fnn zUysza2FgKA`1SCw+x+?uk)O`FB@^M-{0sj3`Slc3*uTTC$CCdG@#~-OI|zO~u3eGi zn{J_Lc3|nR=z@db*RR5j2jpJzuI8)>-G~hzaB*hzqUYp&96)G0Kp08BM$rJ z*QJshetq;CpTn9{z`<~)~{*|VL|O- zM%6EWUsB*p3Vca{FDdXP1-_)fmlXKFPJzkW-{7k#_xma*Q>@ZcQ@+Nt+y|hVy4BQMRZHm=O<>{ktoAiD zR@K!?;gU7}RduzQR%vN^=8VQ@L?vw~rgnd5#4{#&{NblyMo)vWsv{biCk*jtkC5meOz6J=yUr)uV^4gU?2etf{MP zs`hy*pm|*_I6}PYy7EdzJ9CSRbrF2`}@{6fb8nB|NwnFkwq~mzPU3tSA)n`DFf|b5%@T*jfIpiy$`rCwHETx>^`YH52+6 zgiA{=xvbK+qMY727;;#;PZ|}xHFhI2qo7rUAFo(gR`TZ>om_9Aw!qUJfY#5mrsL%j=p%T7Af2rPc>$z}U4u zUuC0+zbz$(u2r=(v#Qdw+F!mLR9C3N!tzx$^>q!x&7xNV;?kz7 z#wuZC7@|q5r1VNpMs*c(lU|7nOZ~$7z=$u3@qQpT1OJHI!F1`cCphYS+VrO=PNfj2uItXiV~z8Vk#`?k6=|;RT5&YFYJ6A{N<-<_YT^d$J;rz~i&uE+!>3K~khkk?HVhIgF*TK;fCkd&r z3Zx@eRQV%XlhKZmT`aUpU-J~<5HYj-zLoUG*;T&FGM8X`HLOv$HR^UXsihT{HI&z5 zJ?Q?{oxG~N(Q{dYm@lMx_k2j2ix`l}&X`iYvmnfsm8`mEjp~Ds1G_ z!k_ zP8seheYX0t4P?0jXK3M21f>y+0owyO`Wpt*n&^bQ{0#j6RX)nP)o4JuDyH#$32m zj|l|ERNb$9I^f!*clLj2BNKyiOojco4{R{oY{rewXZNd3(mdPgVo&#&XUL#cQOAs0 zCeq@Sa+n*+KV?h~?W@v^KOBylVhC^Gyb$5h`Sd(W%ozpQAy!f^<7~ALKaORE4IDKH zO;!*@{PYahvW#8DV7r=WrueQJw8N$jOUHA$uc1!Y7sEe+sU@~uxM)oND`oywC*HGC ztuZt->bs@9fnEl}}0i&Ns>d4f5%cPzmW*D5P ze3pZ-hU7+HVcBQ_)=CSiiyp|BbP}@>OdKX5m}p{**;7P4&$rtjjbCYL{hH>|rrP?d zic6|}rSmaYOH1M0Ql)&YlJMs+~+M@Ff;Sc4X zD^+l@E;MGQgQLqC17)>sbHar&OMh-T#TAMvN-LC)IkrBx+XD*?&kT;y^*GuUvxeyW z!k}o#{eeFad_4kdvZ>+2Nx0~GhSBYSrFlP~y!sOSJuAv9e3?!Ds_Mqf)m5;UzOAW4 zkJi;zRiKqH0_cMVUuF$Dr3PtZ?y;)0Vt?{kzs9hIvN{e(KN*x2Pt@Z}$Er~vquZqi zBdEUG<_KN0D9dVGt_@Yn52>b;4L)2$K9(x*ZTL{RxKoB2F%%WgaZP#c8rxfo)S*nu zD=u*kI+ustg_ih1QS`v_*r~} z1uR8|y&_B_b3RY%atrk_F$8urhdXajVIwD$(&bTks;*R#aej)uAw!Wm^f4fUF zMKZrgIYnt}UO9eFY(&qB>hhJ1N?`NXEHI04)|`s)nw2O0Eb;TE*PqN zvI1W%@w$epl~uLGMfH`hlq6OKWU?noDELwf!%fQ-gI9S&#VUYdpCaImkxBXRRU$OG zrCgHA4Jo>y!N8cn!!xE7h>J)Qodc{NNL< zi85D3ti=;dtO@tLGtP=egWs8MCxERpSx3dg?o2gt<#>A90Fa9&=nSnFC)G2Br*KwXgj*G zuBoBIce15NWxZ}@9)TA^Um z`&fdiZ>(CeW*B5Ms+nmyj8Ie82%q_xy_ItlnXxP1nx(lV;_FYh7hcp1k}(Be7kSjg zMj`+hZlI~PSm(UP3=oXa+5w|z&TPbrvW%izW{el3w4J65y({t-J)yCk{d$nqv!nDg zEHz7#>5DzW>NTTEKtyZd zrImFRr12M+qUqI2J}G)ZpPR@|08>CV3D^@KowTyLZh1MYf0(W%0n^rayOdnZfU%!n7sqXtnag=^r%Bk$)$Pbv5_KhgaHP5f*vde68+}mjf6W&C*GT_~5%J&k!z*R`vMJ7$)T7v^~>t@1(_2(l2s6yV!C6CUpCNYtTWzLmkhZa6a#TEak4{y57LLldzZT z1+MibO<aBF0+S~9kJ8^+^sijbdpk|S^SLf@H+C@ej=@Pnxg=dK z8CIVPc)sQ^4ay+u$*x_Ef$`3K6&=pxJVz_^>;_tOTM#6JM87b zQ1f5N|Keb17FQ-$I#(j;e$sE`+QHTN(qL#OZ~WfFbw_R}w3%xo*M7_=%j@+{^-l9n z_s;NUd1rcOd9%GaQ@vBCPMtP&`qUXyv!>3RI%{h7)SPMFX;Y_7n>KygjA>cZW=@+m zEqhwdbno=3)2B_JK7GdYtm!kS&zhb+J!gh@#?%?pW=x+kV@B4DnKNe1$exjt<;|L! zH7#p;){LyIteIJ}va+*sW_o8%ojGmh^qDheX3d;AbJoo4nK`q(v!>3PHf#E<8MCrx z&73uBR`#r%Y;X3|>}lE4vu9*yWzWo>m7SfPlLLx5RG$Or9E#Q>h5dH+0ulT3 z*gv4QOd1Q--s2Gq#=q^Shyub2nX#ok;b}&xr&8^~W%;aj3P$p3HiGcfUg8@9K{nx4 zR>__{amkp;AwEbF&C;Z2NdD+Z#BXU90z6`V%VLS`p^GjtG=3VJ++=5x>{DgwKD?{V z?3U3BWkZV$i4~dsu1tCG?}b+hCswd7&o(wQi=3!eD2J5Pks`B$DbilOj2~XWj#0*$ zRK&_?c)L%@^zLJtn&kk2W6Enszp%yrGCC`D+*4lf zwy)3_l-rxwaQCZy{dyycz3)s{?hv?ndjFiD6WQvfcXdT?;d0a(xy{3+7Z!y^HuU>g zz7SCfC$fwiUK>@5D)_l%o15AOA%4y9Ud0I1$enTn$vXs6#OxHKgY8~9Ig(S~#n3m3 z3p}znh<4kPU(cMm9dv`Ztr^F!y0wf!4pGjsXkVI@r}nc@+*B4Ggp6m)UZ=Lv5I+&hKs+$Qs3NEbC16vN*s|f7s)xNYvn4 zS=DGS!U9jj7v2}_B66=|@*E256?0WS>isUYlb49B(iRD6SK?Z5&XaT#hd0kXWo zZ)tZi`&(A}SpV>^YGl0*{bZ>{7R#sjTfI#}y_&B|t-Lexi;9S|S5@|i`AgR{@~0U; zp}(%4KR&f}68iE+0?(DFP*z#A^H7FjON@yyo;Br2v(2W!)f-BT3liAkB$js9vUR)E z@??lbWhr%Ti9nrVRaIImE38S@MC(K=)2gsevrh6D=#hZ4d(EUj|4+(F&dmxm{@h0EhH4yS-T2?*hdTx<=3AYh; z5%x*_gl`b`67D1HBOJw1n%$gvSx?wY*eXYBa;oUfgl@tf!hXU4VGG9)dq!H;9>N)f zUe3cUCd?%)BP=2G6P6KfAnYQ%S)Oyu_H%@NgjO=|>_k?NQ?WQ)KAz?SV&m*=|HH3(DN_o zPT2h!{U`AO@Fpx7gpP*;pD>%S4_|UIVeZJm(0vk)!bg(^+|h%f$%JJbSlCSHaSw)W zChW$);2uN!nR8x1=sj{Uw1v=fJn5W5RmMr$WrX!p@S72~OcOs1&u0vVDhcbe21EA{ z_7Xlx=$?t+hA@{8R?XoIG|x%YN7y|ZdiH4vBJ3etOW1b{?IYaNO+G?5XJX}Y%2oeegP}VJd+r_#?IG;_1@t=wfM^ib#}!oCwjq3nr-(?g+F!ulDMBkVsv6w1v2PBjNy5_;E# zLR%*RzbzC>J`sF7L!mPXTW$}9c1!qU;G>u7e+qm;>*t}+XOjtk1D;bT_gml)mTe6;k|k+3b8U@E>mltv z(qJ$3lYBe51fJZ>uZ(Lqm%w|R(3>LPjpq2Vbn@dQWLE2nNsdl+b zT*)f$D$*|?-EQ9u9B8EG#`-uW)~`uIH8xOE8&U7q-Lhq}h)yWDxM@R0lj=T)S=L)smJd;A50G>u)K zkmvHOON{@CjdsDqk3P9TlGZ0|jECi|Zpu|YHV|s(-dbRatxG6ydCsDJ1*)x!XrHL3 zC&{~uyd{#i(B-Z=)RnxDXVT69&pzW>t~|TI<*A@wRQnU)b;fViU!<3jE_jb4y_obL zOMXbYK0ZEIfm_Aj!jx*VS-CvQCEs)8lkW%Xd<%6SdRKzqLe+(fQYtmBbmzj9_@zX2 z-_A?1=1{B^7+!3EySSJB+!R0GHLg>5bz@?ID`S09fy=vYMEs?Px-w{Ym^G8@~wk=Nb^aGq8oUv7rNDi=~j?(s^eb6awl5W8=Rpl1%4}O-J~g%q~t() z$Fj1yx_LICj`5Xy2W{Z>jfqI>dXZyjQ#q70T6euf*=FFXvI_2HbY5}FWkB};?lYe6 z=6OhPSI-x^ya{)Kv|0;-w7pg(cP_d%#)PeiftO< z`2xf9sF?Y%BH{=u7NpQmT1#r(l!%SoPr2dxbPa`c&V?yM^{Md29Lg2)ak;WEuE^#v zxlLFAwlGInZk0?mQ?~lg9J>b`(N*z9T3H=M^ah^o;aR77R>z~F6#1K%BG2#Rc?q_5 z{m|!1X5_ip{N4L`?&0}|Jn!fE%R|b?7f^xHDWX5dA%OQ_$A44Wrt}{yFDg)r#<}`t zK}!7D`i`MV*$X9|Nn%ULH#KjQ=St@2Bc;#dMWIuZ8uL`% zo5{QNAo3OhY8QFuFyFWmy(fHQczk|%yjMJKWUV_+DvQB``6&}9KIRbScGZTy$je5N z`Sl6;5a1%4A0*!#^1V(z#cwK~;y3y_{yaOM;8sb#W8vxPVfla;HYF(Blpcu4Ujg!Q zSX?YY1CHq19$<~A9SHqH5K#SMY=+IAVpq?^guhI%2Nyl=?IHgiFAs#iM|R8aaxbSJ zMCa}!eKPZ~*CbuRS?KD4cEZ=;}Q0ct*tD;mMoKsBp63XtR zY?t(d(lv}_rmYdXOZ7t`$}VBID1+gaSH6sG01(&7*@YU zDHo7Je}z+u1)kUi{lL2qcymPOFP6TI=mQV1b8p3;>2jC5k|q5m(wj-YN~L3SkuLh-L(*lg{3l6A z_h1nuFHTvjwT2-?i~nyU0}txi*Y8(={&88@=`KL-c6o4 z%=_E9*RYkGkZ-8nD7Ym;%x?1b3s3N?qf30u`#JLaZ|$e@d*{nj8&o|J8=+8a1hF(G z#2z~fRGXg!RyIC~rvMc-pAZ97+nkG2RK5Gi`x1HQ2@RpW;aPOodaj9i8Tf~a z@!MP))@u&};`CmEm8G-*HeY!W@*DdUc@o%5CL9D;syGtacHS(GB91k*XFoFS9jb}!aVY_H`TH>0)Gp8DpEw| zqVSE(gBHrLu`}Ma0RUY9*Z_c*I5<-bN~fJAQ$N*r;=?ODYB2Nz!|TR2h|n7xBfbC( zni!UW5VZh!Ui^9Y9gQC-EH{z)K)gtqrr~^LF535EH<z zVB$UDcEJxDWqKag2f6W|M8TV%qU?nN%68+6TpgqA0A6sz3U}&)b1D|2Mq{=HjP~_@MOjtNNCOa)iNw_A(wVNsA zp2SkZd6M^emq{tHQyv@1T^@O^R!_)tU6OjHQ}U$LGjS$Qe6G6bOUwYZ-Qf97`C#Z! z=0t+$#`yRPA#GlYo@XTFLoobX%GZ&IvCy}Y{j|bMjJfOL7rFWp63&jdjeL?P%SFCr z7vrPlUXL#rE6kG_wU>(LM8@lUQpDdhfh^*y-a`IYhQi$x4Y!qiWiRXMkpL>TL1phJo86&75rHOlnaAip1 zm!R$2D3^WNU}z~eZS?pS!NJzYBNI{*T$`~Xy1BM+^>A(F>gC$S)yK7)YY$g|tDkEh zS4;9j*9NXGuFYKCTwAz$xVCcja_!>kgL+Q)x))w ztCwpRS0C4Iu0318BWDjIf~6*Lzs!@V5+x z9*LowjNMTd{~gz=b6oYMu2r}vAoCDw0vS09SQ)H`e8#$mt*`M0$edj1Ymv7?o=?7( z^^9;m=oOSo1JE-5Jls$2kV5q4zyewL`76gm1+$ z44-3$;{`H6ziy|L@S{xq7*FarJTS=Gwy*h@0o?k2}rf5xqNKGmPlc zW*ne%ZeXve&|1xXuxQug`)`R)cnS&|*S6wg83(tJf7A~KLmzV=O}FqoxHGC}iiC>N z)o5s&k0_qYwGVjPfH&IkU}PQ~FWOE!)(eL?h~pQAALOS9PIFkp+rS#$w@e$%Shyd1 zaAblnwmqnH>Q3No1m5o321Cz=bt>~tvt|>e&sej;*veky^5zd+vRRyxuo&{iu;2<) z;&JE2D6%Lep@1PN#*@=h;=kouw#Zdh;97-Gw!qaq4<;yLz35luFB;~;WFbO${7e>v z`nMpLX09;I?iMdku@R%NiLo#RGu7&%>>EEB42g*?KS{fTv^|cr7Sgto_7Z8|gl57I z!)PC|X%$Z`N^ot6M?&KtHKDgDy+w!IVi@! zBZHxY@O)rVxWAMXdv>f_qYwTCOf)z7t$t0j^0TwPq7xw;d}U0blDdJ-47wsQ4y?c(a= z+Re3xE5OyywU4VM2|?%T;@ZsB&9#NAhifZWFV`-vKCazdd$*7&-U658T`iq|e_F<~CHBuo^^Cl@|YBwzGIH{~ZhcW}1R z9P;;(-%tK(BSXeEQU=|6EX9OksI{07+c6>G5K|vU1rA)P&&~Sz9WNYQeKIf3CI5%y zKP{0+EPFV@hr;!7!UDsmgbPyy)<$3*ebqqd0~yaEu#`TD((enI7x%@-;wFlU4DJTj z!z}}$%MC2&{K$;^B?%SrLkB|2<#LT-uR#4PgCY55yx?KvH)_s7bK-x74~EW2)@^a>nkYFhU{FlxjV`ff_(q~=5*Ztf|EVi3{yr>}bLfmx!UfO< z|40nED^PNmcs%1yLMZe>jQ&-yBYY%s_p8`*nLOnSECE&lAIrNLG^KAZR(%_<&1I5q z;PR8Fmpp4H5>aiz&UEh0P~(O@ZyAv=H6m-kzB6&bV?3qzt!_Hz4&UhJgKcB`4*`vT~_;{x5)d}d1 z3xL<09||3Tov!s+)cC0AYTC(6e(#|%;o&d4BY|;>agHm%)z7t$tA*9)4P0GZo4LBV zws7@uZRP6a+Qrq!wVP`XSAeUZYadq&G~1x)MtQ<+#;v}@_-pd(!b2 zRD?oDF^`PNtIj^`iAyMqJ?UWEM=NuLvza555-woQkWd-V-8m)&<0LL&L4wIsMo2fp zLozPj0S?{GEXN6bBIBachf(rb;L5!`CKJh+q4XcH&g848@5i7`)EFzY`AKYB8qvET z-nHyhSJ_I}vOE`)V!^Zc1nj|ULZJ@uww8x&(pY*MJY~z(aN!X@4c%vL2G*7A$32&O zX|tK1Fw(}KYWqZ_&R+8UjC^YCCPJH7HiNY1nf=)eTY)tSeY6z&<6qcN(R>p{8)Paz z;a2P^cAo5EO)!92+|M>FQkRY(^>k9_nN(~__Byp-ac$u0;@ZsBop36-v8oR~b3*@^ zSV~;ceiyiZ2JQcGzTiX1R*nbnQ3s6Ly)f+k`zP>@{JZ3HO+=--Oobx*oR)Jtp*;FxP}7CM+{yy$M@P z*k!_Q6ZV*}*Mxm0++)Ii6Ix46{U-F7&}+h66PB2;%!KtOY%yV%3A;_$W5Qk&_L*>x z3HwcGonh)Xp~r+?6Xu$*#DrxgtT$nc3A;?#ZNeTC_L{KIgnLZbZ$h;(2o&6BYCJq9 z^qMf&ge4{{Ghw|6TTIwx!fq4xn6TG`eJ0#v!hRE4XPNe!&|^Zc33E+YV!|>L)|;@! zgk2`=HertmdrjD9!aXMJH=%X5so#Vi6M9XUYr+x}mYJ~Lge@lQGGVs~dra7C!afu3 zF=4+6t#eHMCiIxlYr2r!WI+i(viQpGxT`G_@I7~C;HAFFQU`yv&-3lfJs?R#8DySEKVR{QCPrkL1FO@~|)cAGFdZ*CO4?C1>t z%kjczbw9ZG=!*B(U;9Jr3{&2=XFU7M_yyB1GVr^f)&TnNiw$VyLFTJ7`N~W`^gbCI z-kO8Vcdf~n`zsBnWIyn(H~H$f>U_OV#IElJ{Lw+?i~pnM`?5DRoPNV!(NGUF`Mjpzy!+|5 z<4iu!N6`@ev-rWv<2OwG(Y1LBwO;a^q{HavpBK05?<&_hHPtw~;oF~AQa`uLN9W#b z^#6va4D}yJ=loxa8~wk>;MMbnuD9gFgRFnf7o+cfq2CronEht_&mO$-j2VY-)#0^K z;7%~lyVRnIWko-a%04W*zgCRJHBT|V~`-5kAKlEb^_F_6VE>?IntVN98;XB)iTC?7{@&vcoNu;)SK>KvzI>C< zbIgJBooe#+9ev<@XPA5~pOfzblh1q9f#IEF@^yXn!1$K@@ z`085cL+-CJ&-*UX_(eZI&gd8G&DhV!nCI?SV?Vd`m-`mo@6qsW{pCF*_VXxoheh{C z)n!J1jf*PLeUS5#E+cnQ#lLtoN`Lj-t3mad@bduo&Ks(~J}-at^X}H6l-gtLwCH^Q z-Eo^g-9}GG^QX-pU7fM}-{y~&(XpR@9==0c9m(Bg_@h3Or0#nD6_s$X(fPW6_7ohr zpL*91#i-BDpEz`Wd$85o`Fc(LcDyVqZl@n?xF>4-KG<@foA2*K+uvg3tV<4U;kW0y z*w3Tk_B{}t^2OrSMt{~v^~)E7HoTPIz_)JK?JA7QV)K9f9kKb_=Knp3v7bkQ8y2lJ z`nlz(*yV3E&+D6FKX0+|H<14`E**-V?Rp)WIy6@Ql*Y?W{qL;5$OcNdFhBn!PsUlx z`RrJeCns}8rgzHJCKa1{)iiIWcSh#4NjlwnhwK_Dy+~uTaQ8>Li{0fKZi@~qdupbR z`XKGo<@$lGdM>Weai7Wmw27-@6iACV57bcz#6N1+89y+Td26GNt1ZCXmS3;qYD*Ef z_nWxA)MZZ%)%G8r|F}ozck5u--wMu4&}2{cU-mV&554zI%Q}@tda`tb?GmRXCQknb zuLoT>kG*8id}R*lrzDTO^(wrDazFVuO_r6EFK=zAjlTYxNbZ zbd4Kf-Oc^EbC|^HTkG6^z%BYd@!Zj!a{p_xB%gb1_}*=uk~s2CsZ9!BmVBOMI3+Im zGi1)YUGC#Y{vc11MhucP`Bv5pN1pH%{Uqs}GLp7TAt~c1@hwh1aV7VY#>CUc=ENlV zE|ypBCm)K(e&mT`rH;v?y11WwMK8r-OcR>j*VGePa=3Iti@V||BB!SI z5xLfV#6lvcB~Jy~I`?IQ_35d3L^ime5di0oUIc(H_k-|X^7&sW=E-LFPeu{B;K*}` zbi3b26p}Ag=xlMHjQk{DbjYs(-Q&JOs8@QZm&jK4X@WtS!mZc+_rr-SPreWUJFUqB zU9829JhF}KYaSNDf8BL{(^S55p6nq*da^t?Q94iXGCZB0EUU=pZv(CLjKOB1i{!Gprnldsw9nlN%9?|@{P@w z^ka3p9Jx4Zic9!w>~=r*nd&}kHu9U87dK7-!~Gy=O`eR;CE(7Zpt2 zM_KpyG1KI}{aDL7Y{`*lQ~l&)W^jMzk?qjL`@STM$R^>!F>-%Oa^i**kUN`)hbJYd z%1#t?y|iC-cbql0;9HiJc8kkH(%3Z+B&}N`m~$NWw;m?aKX!rSxl`x4Lh}4f=b0^e zey;MI{6I4IhsUW0`M;|G+c6ire+pFh69v4zQSBCtEcdm?6RA0}j@-#sb$2Bq5I5$$ zIJYFET@53QIX^Dx$3(2O-%`_<3*rtF&Kj5YL>jRR;}jTA+C7k%*f9b$Bkcw9k13CH z2RK{8oA!1dvE^~8BT{+mByG&sh*iWLHjP+rTCRs!W!zyah!v*Q!Q^9naYt-&vvnhF z#2R8N<6O7!Y+2e;^x>FG;>O;b zJ(O!s+k6?ZhPcDz{i~L=lfFZ&QN!Gjc48|rf862clCvwVWh}9#xWm6qY;)QU#+Wh9 zabxZTW_Q~2u<@8H;?hJZZ%O;cDq>e^O7x^XUQg_rxWiAPZ?~qsa5b^kxY3!^*PE7^ zPi#ZnVNU^bSK3m+vqRIYFYT}LY*XA}pYm*XTD3g8KJM_5)VC*X?FM4sjyv)_Vu7^3 z3a!5rcVzxy>^VtWvYglraYxGO2m8inqG85-H%|4S6*sVAf-00avv*X4mA5HX!ajxIf$GLIi&pDmwk94yO!1_E4Tn5`{=D%C*-UW#Al z7t~vJM$&7uQXTK%Zx0fm2Bj0DWZpju29HHv1W0v!hrhyrx|%SMR+BM5MC^(TgE-aU z#$RDY9psvoH2sN&i?I0`4=aqk0$s#>o2h;zCzAH>WG)=$uo05Ar?Y}Mp z<2GWCzA_N+!pDzJDiO~I?LnNBVtS8tL^Jow;;Gfsm599@d;RiSxPL)_Xnh||I4?P= zEQ$K?UI6<9NYNX{0K6PTvt_!z9m6nUe>i31)t{hYbU=Vyy>}VFD*_bgd$3SO926xe zqV_?cGFM@4k9bw1;%8Q34T^X@Y&+bb-{7wZ!XYr+E`p=7K)nXi%o8-Y4(TUFf=}_c z>f3)9E1AvI@h*k^CM*<82*PCq7CK61#ARoB2>Nw3jisM;>Z4emxe={3<}A{w+-rzlrHGU9VXJ@O#)x@aENR*o#K|AwaHPN3Q=Apg`ZZ65uZ}Mn2Qq?tsyQatLE|*m&qciZ@oER6S_4bTZ4BgV{QwvsuQ#sX$)UpgBoba!%8t=KM)JgaTFnS!jPJEp2#sX3W`? z1??a;%z!A>5re;CVxUbB4|&>(r;E8JXFp|Hq`LEk?Le}nX@fQ?Y)g}%l2hIVX2q(T z7M~n?V_(EzHEgy>b0ei8XS9{MmPVFkCiR6OY8cJvIp6jK7^=Eyjmw$b17Miy-YdN9 zCoc*bg*GoT?Oqy}!&Udk!s0AhP}yh;!}*BSfa`Jl3fPX2u2&+nh!P2ssWC^YZdws@ z3ey2b$>Ibq1{f{Du4;fWs=Ek-EY&d_e??}rA4#YE>9rh{oSQAM9jm(M2-}-XTiQvo ztyuR`9n@=59W+&@I%u5WOeOwOU+8Z`WD?!E4%&6;%k7Hd?%|@{uA+Z87NBQ1z0AR( zI|=j(r&{Xzw3Pt8g;_MbJ&vUPH{g(w9_i9)zoxGrhaI~icFl@@TQWd|SkoN(2c&V! zb+9-ZAW~?ei|JQ&Bcnu`L^%D4oQ|x7)2JYwwtd2BR4_X&#*c9*Q6a%kV@`1t;g3-656w!ahECjFUKlTOqTL6cVHU~ga#W6}(77iVchKl|pj4UVBR$?!! z2DAlV`UKX0oGHU^B^Nj`;$OaQU5cqO=Mp&&zzf$P>l2a&;8cx=0njP%x3?bC)AlYH zJ?VNyiRoof&sX%Hk^u4qaF9*D?K{{MPw^@-1+Ej=QGm}1B}cqAMBuAZiP_IP!&2nj%}FKTWYrQ$7n02Fo;yqGP%_?}W{?xs^&xt|8c( z>GPDB-T^yNpz6GJu7tK!OX{FRf-K^-o74uDD(Ps@L|kMXF`t1|GS*-|)(1X<`RV}hZsrFr0Uycy>OSD3nEw`2dTccFnHZ;@WYHfZ z=}YsTwt^RzNLFD@o2WzvXF{CoY6R+?9@oZs7>qa-#3k|(S3l;#3*(Z)sOh8iXJ-N= z2hs(jL?tu5J5YOV6VgO(#hWpwi#2)avw=21p(>jFWZ6sWPv=mzx0_ySW9ql_*> ze~%w%3NVHA_Qt>Nq~Es?hxhm})h5n6#Wqv;9!s!aj~}TThagsrt(3kTwU6pJTYi*UH)LKV1Rp7~Jv;hERa@F*t~SMzwznFR{&7 zM?Qe)gKfsiK6pPmb(`@)TcLzTZw!FGi*YkX9z@*D>3X6 zjz!b*8ySEYBperfW)peqD7vI~F$^;uUI;pccR;IVkl=CCArk(z2!#sde!Xu6cvm77 zHuCE2#AgY8i8{L~5)I#2bivswa#T(Mkr@YywzOdDLS%JM06j@C38Dmv`g0(lIt}%7_{pktAa*s zCx?A6RI42i`^dXSgYP74GKX|llr&f3E_90C-n1y^AdC=Et+Z$!iTdw-Vd0Uh{)u4# zZ9-`wiPrCG07#0WB#AmUy-HfTC?$=;?@*Y`A&HQ+*M6shy*(6sHW%#6Oz>TppNLVD z)|L4)C`DQh^B+;R-K0I*Hmy7J4?3k2|k?pOZ~yic7A<1 zc-hX@af;Gjw(S`duze8Q_bxz38^|3q4CT)l#_}zg$})yCKdu)12V?Pxt_{?%N zgxe){xT%ikscD*)K@uT0j+u*d!AH7luqR7(OvPWZJEV6#@y4)-IGXPSR5EFI=gyC# z9a?X%yT*AIdeJoQTG=!=qI~W;mr&@>qybEJQICk$2UG*p3y`R9YXdMv0BRb_F*Bhz zWK*?`;3MfJkGe;8|PdWR1BFsw2n;|`e`UyV9~ZqT7)*eFuywEOPR zDU?bct)IvE?a(=dN|C6{pns_jN}oy2I(W4p@cp~mk*-6YekY~Bvl5ElVk4>O?VSL9 z#GcQgWRhKne65Po6k#r`>o8dNU@Fr;MCa%*Bw_*-ioT!@U}zX^eAD&oI|2+7z^f-v z$%c!Pj07ks8cdGW6sQMuXRMJBVR2CFDHv0lw=b3Y3%%z%u>PkPVX4(93C&L z*fB&_(Tn1C3>7|g{lDmW9m52O)|=4TI_d%>Dw&T?1Pa%5IEZ{6BdenveRC#&&*0oH zp#3_<#8Uf3P8$y1!+arv)hV8LODnzL6PbSxYgDK9oOUZ_?#?{BXTH`0SAA?^EzUgB zK~b_|-5(&|RL4pD6=UsdFzMotIPs-Aet=-{NBGmAW{2xv!!w1=hGjK21pS@rB3gQUYngE0B(+~1n3|@ zgFX~pAv;qzn4@y@a9EEbP%OX^{geVQRJcBg-c9D2 z%N>vn)2IjcF3Ivaha*RB)pB8|aK$S`A9ZjUDh1HF3{?U|a~Y}yNaQlq2$0TYs1?A= zQK%CjmxDD~fCAl16|WbdNXdL77HEog5aDjXuaqi|z^s|N8@)h(46|R>>~P{0ovw0Z z%?Y=p(iH*xL}b>yknUJcbbS>1b=G_VqV*YMwIKQh1U*rI4U#mK5^3u6$EyJD6re%>BMRUy0T$?gVVcicExa}AuiOQ&Mu25{bR)nzV^1P(-S>?r zaCZVVPo3Jge;=Ur!me5Edu9;OCgJaZ+PCu@pv?juR{I{OjLb0=&M7opCzQ+atZ4;=)*|(ZH*h2zcaP}?81o}@fT>!l7 z?E59+o%N{DU3K>Tp%Q3^*yrKf;Hi%5QQ(HMIkR!)BI~G5?WF(G7bYh}o5|KZ$qlHl z!K9ycDu#X~PuD-Dl7Awn(DM|`)1tzOdRH?0R7_JT`jQaD_08g$<-VT90oLm6$ibh&Y_t9|rTJSFr^#rcX+q`u zfIE!%7$6JZf!%FPrP;}<3d?3Ae;g3*5774LfH83iP=Xpv*J%$MyL>=x_?q<*LnB=h zr#oqUj!j8cTTa(v(67K`rLgXT(Lz1A9qTR|^nhJf8l$V8tyJdrjBvev2vs{n6|L(~ z8&w)`9U1C$OVWcenL&G=Xw+DoU;a`uyNyPoof>t7%*m_3KON?UI@Qq)f5pYyF<^Kn z>tAAdC)@uEOs$DohxCoG(66gP;&(;e6+M;e@NO&x!lB1eG~aDUK-X7LTvHvmrr%Pioas3L)TNeG4`PPI82}qM>)ej7giU^inc(OG}DTL z&UXef>B4PPxJK7oQyp|!HS$6jBttms7f{Wpq0HxFoJPs>QC=W;c|Ix*1~1P?j``qA z*nSPF5H*VVpC^Ey%>3Cbj9|GB4M6pC<)PI%6TCdMuELzxBa$DAnLA!lddl0gn<_|Q2e~|ef?*_k( z`L4Hue~9^R{lGuWyh=8YFrOL+{y)s$gz)A)%KUaTao%?3GZup1$^0hDYZvp$W#AuY zzE3UqCz#)gI_5pe{2ds8c~3EaXEpfU%#X$@koPq6Zc6(M^Y?ZJ{~Yrz7zBBHn4fw( z_~)4qZx6ni`6WZZ?`8fgbmP1im>(Sp{zc~Xx!_-7{?Bai`a@ zo%a^=!_k-W-e$fR8awYD<};Rqf0y}JC_e8oKY`luedgz4j>|j3d;!`2kNHN5{|C&s zT?zg}=I^8!9%a5b0{kiFhnIl=h7g3e zM{%uTfu4RdKqsMT)FaV;`Po9VLdhJs8mNnA?SPr^4fN{#3K6{-;`Wd)9G4UBH+msj zsg4Z%?NNbw^?ESr;ufj+BksvXp231r@PNBUnD)ir$fFoj1x<06Xc=mT`@VJJgxf!+ z0kQA5!0|YY#I3V_H}b7B{fBhCIPs=%y71z_vv-(B`YmkJEIckFkIOJx`ZbF3^?wh& zD!Sha$KQT0E2WoB2wlHBVyzu%)x8@5>bFX?ijH3_6~10m;HwThn11V0B4L#(oJ97= zxbGjpeWzaqc)9e|W8C!Tr7z=YBrQP_dC}Kf06y|fOtb?+5=kyDInQimP)-KfDKLml zB6;MLVcE>N{~1m;5nO{3S?c>8DNhsfJ9x7^6uB-7Z#-v!zcN zT#F`)R!`b=%EO?$%<3tdaS%Wj<|8hQ!=Rha>c=vB^Z_bw1~vF|U_`Y7l$Lfcj`TMarrpfSl0;MdPayU zjqDAK(v7QbppEuOx)|U!9>X4A-DHpX8D4UYuTVjCvps~Kfh*vicduRa(Y3}#*sEI@ ztv4djU)1~TqT_8w9I4hBbRpY?TA7_|+2`7L zI?QcL-!C&iTX063sa~tQYD}z@Bppn!=b_ewUqhBPvy$@yr*NmI|;tV=ZNu}Z4%*u(OmOE>6CRqDI;up5B9 z#_K6S@7co|fO1h@Dq+6WmVziwZI_5^G^+Zj-7yw98r^Aj+iq_|y+ScM+z7P89!Wi* z$@398-O07UL%%C&Zhp)jR)utU==Z&OfV=F@TL2qXUb9G*PMZT{O76u0j0}X3m#FWS>6_D=1vTpPrugJPCWL(KHG2Lj=X;`a~D5mQ64 zyrwY|er2jDxU6pN*9occE8;6OvR>(?hGNYLNn`r$XR0aqLXB#bgLietg-i8_J(D_t zQ#&B5HP}Ey7N{TF9go3?+v5{^J8Ckdp<9gVr}peupmS=?GEJ)EE^@ep#=)6@a7=zs z?v~2l!P!C1F!We`DVChQ}MB&khv;x1fG-1BGdy!e^?3_QV;K zoUR9m>A_Gk>BaZioi)0Z5P3W1sBFHOnMn^-MMi7%EL6b(^--s@zB}r0Li7x0)On0B z#kgfMO1aw^yBZq;uR%9=)aRUH6Pjz#eIIoXqXL6&;;7FvDl+H>k=o3t#GqSD>Rv_@ z47&TIzQD+5(0wKKMMibTTFQMNqXuJMF3^4_?|_Z|sG@qnDJtG*TwMb6ic?$!UBPqc zLDsD`#$%39Uu7?wjnnIaUSrf`tQ!pUx-*=f&)Z?peJJ%1>vkJQ3xVEX)U4#Zgk?cJ z?9|30m{_6za5^8L2)$eh@t;m{pG7gIpg*gBan5+aF^0B1e>=7LupImdnhh7M0v%sa zx=964se#<2#vj<`;de>6O^wd;fwaIRGNg5$GIB+SLud<3-38#(nq(Kr>3==M%L2t_ z%5|p?;L$+26rg%0Ar0y`qjiz{i62v=A@d8sEO5(>%af2zgk$9IW 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 uV1>r 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 LAdCA3bM^lLvRWEh literal 0 HcmV?d00001 diff --git a/talkingface/utils/vits_utils/monotonic_align/build/temp.linux-x86_64-cpython-37/core.o b/talkingface/utils/vits_utils/monotonic_align/build/temp.linux-x86_64-cpython-37/core.o new file mode 100644 index 0000000000000000000000000000000000000000..04f1badba7ea63c09ff9b4b4a8b7a178ac8ed68a GIT binary patch literal 3192968 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

v{0= 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%0DPldNv{H(y| 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%0Dw)`Imu@vH7V4pI~0w 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 jg{GJ-u816hw;V)J{Gx*EpbNDOe3%KLY;AiQ) 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 literal 0 HcmV?d00001 diff --git a/talkingface/utils/vits_utils/monotonic_align/core.c b/talkingface/utils/vits_utils/monotonic_align/core.c index 5631d20a..97189a93 100644 --- a/talkingface/utils/vits_utils/monotonic_align/core.c +++ b/talkingface/utils/vits_utils/monotonic_align/core.c @@ -1,32 +1,51 @@ -/* Generated by Cython 0.29.21 */ +/* Generated by Cython 3.0.8 */ /* BEGIN: Cython Metadata { "distutils": { - "name": "monotonic_align.core", + "name": "talkingface.utils.vits_utils.monotonic_align.core", "sources": [ "core.pyx" ] }, - "module_name": "monotonic_align.core" + "module_name": "talkingface.utils.vits_utils.monotonic_align.core" } END: Cython Metadata */ +#ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else -#define CYTHON_ABI "0_29_21" -#define CYTHON_HEX_VERSION 0x001D15F0 -#define CYTHON_FUTURE_DIVISION 0 +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_8" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x030008F0 +#define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -45,9 +64,7 @@ END: Cython Metadata */ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -55,12 +72,19 @@ END: Cython Metadata */ #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 __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -85,27 +109,164 @@ END: Cython Metadata */ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 -#elif defined(PYSTON_VERSION) + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 1 #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 + #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 @@ -128,25 +289,29 @@ END: Cython Metadata */ #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 + #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_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -155,10 +320,7 @@ END: Cython Metadata */ #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) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -167,7 +329,7 @@ END: Cython Metadata */ #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif - #if PY_VERSION_HEX < 0x030300F0 + #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) @@ -185,27 +347,60 @@ END: Cython Metadata */ #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) + #endif + #if PY_VERSION_HEX < 0x030700A3 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif #undef SHIFT #undef BASE #undef MASK @@ -230,6 +425,17 @@ END: Cython Metadata */ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -243,13 +449,16 @@ END: Cython Metadata */ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -257,28 +466,59 @@ END: Cython Metadata */ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #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; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #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]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -288,13 +528,26 @@ END: Cython Metadata */ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -310,26 +563,145 @@ END: Cython Metadata */ #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 + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" -#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -343,6 +715,12 @@ END: Cython Metadata */ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -357,31 +735,81 @@ END: Cython Metadata */ #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))))) +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -389,6 +817,22 @@ END: Cython Metadata */ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -419,7 +863,29 @@ 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) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -431,26 +897,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -460,11 +991,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -475,14 +1006,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -511,8 +1048,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -522,15 +1065,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -542,6 +1112,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -554,15 +1127,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t PyInt_AsLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t PyInt_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) + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 @@ -582,8 +1150,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { } __Pyx_PyAsyncMethodsStruct; #endif -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif #endif #include #ifdef NAN @@ -606,7 +1176,16 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -614,14 +1193,12 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #endif -#define __PYX_HAVE__monotonic_align__core -#define __PYX_HAVE_API__monotonic_align__core +#define __PYX_HAVE__talkingface__utils__vits_utils__monotonic_align__core +#define __PYX_HAVE_API__talkingface__utils__vits_utils__monotonic_align__core /* Early includes */ #include "pythread.h" #include #include -#include -#include "pystate.h" #ifdef _OPENMP #include #endif /* _OPENMP */ @@ -670,9 +1247,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); 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)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -690,9 +1268,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -700,12 +1278,23 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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; +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) +{ + const wchar_t *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#else +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#endif +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) @@ -718,6 +1307,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); (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 @@ -729,8 +1319,54 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #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 CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -751,7 +1387,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -781,6 +1417,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #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 +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -816,23 +1453,26 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE 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; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "core.pyx", - "stringsource", + "", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -840,73 +1480,7 @@ static const char *__pyx_f[] = { #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_atomic_int_type int -#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\ - (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\ - !defined(__i386__) - #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1) - #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1) - #ifdef __PYX_DEBUG_ATOMICS - #warning "Using GNU atomics" - #endif -#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0 - #include - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type LONG - #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value) - #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value) - #ifdef __PYX_DEBUG_ATOMICS - #pragma message ("Using MSVC atomics") - #endif -#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0 - #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value) - #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value) - #ifdef __PYX_DEBUG_ATOMICS - #warning "Using Intel 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), memview->lock) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) -#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 { @@ -941,28 +1515,125 @@ typedef struct { char is_valid_array; } __Pyx_BufFmt_Context; +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_incr_aligned(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_decr_aligned(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_incr_aligned(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_decr_aligned(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd) + #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* MemviewSliceStruct.proto */ +struct __pyx_memoryview_obj; +typedef struct { + struct __pyx_memoryview_obj *memview; + char *data; + Py_ssize_t shape[8]; + Py_ssize_t strides[8]; + Py_ssize_t suboffsets[8]; +} __Pyx_memviewslice; +#define __Pyx_MemoryView_Len(m) (m.shape[0]) + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_array_obj; struct __pyx_MemviewEnum_obj; struct __pyx_memoryview_obj; struct __pyx_memoryviewslice_obj; -struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each; +struct __pyx_opt_args_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_each; -/* "monotonic_align/core.pyx":7 +/* "talkingface/utils/vits_utils/monotonic_align/core.pyx":7 * @cython.boundscheck(False) * @cython.wraparound(False) * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< * cdef int x * cdef int y */ -struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each { +struct __pyx_opt_args_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_each { int __pyx_n; float max_neg_val; }; -/* "View.MemoryView":105 - * +/* "View.MemoryView":114 + * @cython.collection_type("sequence") * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< * @@ -986,7 +1657,7 @@ struct __pyx_array_obj { }; -/* "View.MemoryView":279 +/* "View.MemoryView":302 * * @cname('__pyx_MemviewEnum') * cdef class Enum(object): # <<<<<<<<<<<<<< @@ -999,10 +1670,10 @@ struct __pyx_MemviewEnum_obj { }; -/* "View.MemoryView":330 +/* "View.MemoryView":337 * * @cname('__pyx_memoryview') - * cdef class memoryview(object): # <<<<<<<<<<<<<< + * cdef class memoryview: # <<<<<<<<<<<<<< * * cdef object obj */ @@ -1013,8 +1684,7 @@ struct __pyx_memoryview_obj { PyObject *_size; PyObject *_array_interface; PyThread_type_lock lock; - __pyx_atomic_int acquisition_count[2]; - __pyx_atomic_int *acquisition_count_aligned_p; + __pyx_atomic_int_type acquisition_count; Py_buffer view; int flags; int dtype_is_object; @@ -1022,8 +1692,8 @@ struct __pyx_memoryview_obj { }; -/* "View.MemoryView":965 - * +/* "View.MemoryView":952 + * @cython.collection_type("sequence") * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< * "Internal class for passing memoryview slices to Python" @@ -1039,8 +1709,8 @@ struct __pyx_memoryviewslice_obj { -/* "View.MemoryView":105 - * +/* "View.MemoryView":114 + * @cython.collection_type("sequence") * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< * @@ -1053,10 +1723,10 @@ struct __pyx_vtabstruct_array { static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; -/* "View.MemoryView":330 +/* "View.MemoryView":337 * * @cname('__pyx_memoryview') - * cdef class memoryview(object): # <<<<<<<<<<<<<< + * cdef class memoryview: # <<<<<<<<<<<<<< * * cdef object obj */ @@ -1069,12 +1739,13 @@ struct __pyx_vtabstruct_memoryview { PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); + PyObject *(*_get_base)(struct __pyx_memoryview_obj *); }; static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; -/* "View.MemoryView":965 - * +/* "View.MemoryView":952 + * @cython.collection_type("sequence") * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< * "Internal class for passing memoryview slices to Python" @@ -1085,6 +1756,7 @@ struct __pyx_vtabstruct__memoryviewslice { struct __pyx_vtabstruct_memoryview __pyx_base; }; static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1093,11 +1765,11 @@ static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; #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 (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1107,28 +1779,40 @@ static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__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) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1139,6 +1823,10 @@ static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ @@ -1150,79 +1838,30 @@ static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; #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); +/* 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_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1234,7 +1873,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #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 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1250,30 +1889,129 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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); +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) #else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#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_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ @@ -1282,26 +2020,46 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #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 #endif -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +/* 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 -/* IncludeStringH.proto */ -#include +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* BuildPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, + int prepend_sign, char padding_char); + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 @@ -1310,14 +2068,29 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif -/* None.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))) +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif PY_MAJOR_VERSION < 3 + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif -static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); @@ -1344,40 +2117,25 @@ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +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); -} +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); -/* 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)); +/* DivInt[Py_ssize_t].proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); -/* 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 +/* UnaryNegOverflows.proto */ +#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); @@ -1410,18 +2168,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) @@ -1429,6 +2187,37 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif +/* AssertionsEnabled.proto */ +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (1) +#elif CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) + static int __pyx_assertions_enabled_flag; + #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) + static int __Pyx_init_assertions_enabled(void) { + PyObject *builtins, *debug, *debug_str; + int flag; + builtins = PyEval_GetBuiltins(); + if (!builtins) goto bad; + debug_str = PyUnicode_FromStringAndSize("__debug__", 9); + if (!debug_str) goto bad; + debug = PyObject_GetItem(builtins, debug_str); + Py_DECREF(debug_str); + if (!debug) goto bad; + flag = PyObject_IsTrue(debug); + Py_DECREF(debug); + if (flag == -1) goto bad; + __pyx_assertions_enabled_flag = flag; + return 0; + bad: + __pyx_assertions_enabled_flag = 1; + return -1; + } +#else + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (!Py_OptimizeFlag) +#endif + /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); @@ -1442,7 +2231,7 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif @@ -1476,20 +2265,30 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); +/* ImportDottedModule.proto */ +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); +#endif + /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) -static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { @@ -1497,7 +2296,11 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else PyList_SET_ITEM(list, len, x); + #endif __Pyx_SET_SIZE(list, len + 1); return 0; } @@ -1507,52 +2310,44 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { #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 -} +/* PySequenceMultiply.proto */ +#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); -/* 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 +/* SetItemInt.proto */ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +/* RaiseUnboundLocalError.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); -/* None.proto */ +/* 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 */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* ErrOccurredWithGIL.proto */ +static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 @@ -1568,14 +2363,186 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + /* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK @@ -1585,6 +2552,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1598,6 +2566,7 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, @@ -1634,9 +2603,6 @@ 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); @@ -1669,12 +2635,6 @@ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag); -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - /* MemviewSliceCopyTemplate.proto */ static __Pyx_memviewslice __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, @@ -1682,21 +2642,67 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, size_t sizeof_dtype, int contig_flag, int dtype_is_object); +/* MemviewSliceInit.proto */ +#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d +#define __Pyx_MEMVIEW_DIRECT 1 +#define __Pyx_MEMVIEW_PTR 2 +#define __Pyx_MEMVIEW_FULL 4 +#define __Pyx_MEMVIEW_CONTIG 8 +#define __Pyx_MEMVIEW_STRIDED 16 +#define __Pyx_MEMVIEW_FOLLOW 32 +#define __Pyx_IS_C_CONTIG 1 +#define __Pyx_IS_F_CONTIG 2 +static int __Pyx_init_memviewslice( + struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference); +static CYTHON_INLINE int __pyx_add_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); +static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); +#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) +#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) +#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) +static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); +static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ @@ -1705,18 +2711,19 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/ -/* Module declarations from 'cython.view' */ +/* Module declarations from "cython.view" */ -/* Module declarations from 'cython' */ +/* Module declarations from "cython.dataclasses" */ -/* Module declarations from '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; +/* Module declarations from "cython" */ + +/* Module declarations from "talkingface.utils.vits_utils.monotonic_align.core" */ +static PyObject *__pyx_collections_abc_Sequence = 0; static PyObject *generic = 0; static PyObject *strided = 0; static PyObject *indirect = 0; @@ -1724,14 +2731,14 @@ static PyObject *contiguous = 0; static PyObject *indirect_contiguous = 0; static int __pyx_memoryview_thread_locks_used; static PyThread_type_lock __pyx_memoryview_thread_locks[8]; -static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/ -static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/ +static void __pyx_f_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/ +static void __pyx_f_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/ +static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/ static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ -static 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 int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ @@ -1749,8 +2756,9 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /* 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_err_dim(PyObject *, PyObject *, int); /*proto*/ +static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/ +static int __pyx_memoryview_err_no_memory(void); /*proto*/ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ @@ -1759,26 +2767,43 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ 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 }; +/* #### Code section: typeinfo ### */ +static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, __PYX_IS_UNSIGNED(int) ? 'U' : 'I', __PYX_IS_UNSIGNED(int), 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; -#define __Pyx_MODULE_NAME "monotonic_align.core" -extern int __pyx_module_is_main_monotonic_align__core; -int __pyx_module_is_main_monotonic_align__core = 0; +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "talkingface.utils.vits_utils.monotonic_align.core" +extern int __pyx_module_is_main_talkingface__utils__vits_utils__monotonic_align__core; +int __pyx_module_is_main_talkingface__utils__vits_utils__monotonic_align__core = 0; -/* Implementation of 'monotonic_align.core' */ +/* Implementation of "talkingface.utils.vits_utils.monotonic_align.core" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin___import__; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_AssertionError; static PyObject *__pyx_builtin_Ellipsis; static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_IndexError; +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = ": "; static const char __pyx_k_O[] = "O"; static const char __pyx_k_c[] = "c"; +static const char __pyx_k__2[] = "."; +static const char __pyx_k__3[] = "*"; +static const char __pyx_k__6[] = "'"; +static const char __pyx_k__7[] = ")"; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_id[] = "id"; +static const char __pyx_k__23[] = "?"; +static const char __pyx_k_abc[] = "abc"; +static const char __pyx_k_and[] = " and "; +static const char __pyx_k_got[] = " (got "; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_obj[] = "obj"; +static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_base[] = "base"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_main[] = "__main__"; @@ -1787,6 +2812,7 @@ static const char __pyx_k_name[] = "name"; static const char __pyx_k_ndim[] = "ndim"; static const char __pyx_k_pack[] = "pack"; static const char __pyx_k_size[] = "size"; +static const char __pyx_k_spec[] = "__spec__"; static const char __pyx_k_step[] = "step"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_t_xs[] = "t_xs"; @@ -1794,12 +2820,15 @@ static const char __pyx_k_t_ys[] = "t_ys"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_ASCII[] = "ASCII"; static const char __pyx_k_class[] = "__class__"; +static const char __pyx_k_count[] = "count"; static const char __pyx_k_error[] = "error"; static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_index[] = "index"; static const char __pyx_k_paths[] = "paths"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_shape[] = "shape"; static const char __pyx_k_start[] = "start"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_format[] = "format"; static const char __pyx_k_import[] = "__import__"; @@ -1810,15 +2839,20 @@ static const char __pyx_k_struct[] = "struct"; static const char __pyx_k_unpack[] = "unpack"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_values[] = "values"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_fortran[] = "fortran"; static const char __pyx_k_memview[] = "memview"; static const char __pyx_k_Ellipsis[] = "Ellipsis"; +static const char __pyx_k_Sequence[] = "Sequence"; +static const char __pyx_k_core_pyx[] = "core.pyx"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_itemsize[] = "itemsize"; static const char __pyx_k_pyx_type[] = "__pyx_type"; +static const char __pyx_k_register[] = "register"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_IndexError[] = "IndexError"; @@ -1827,132 +2861,56 @@ static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_collections[] = "collections"; +static const char __pyx_k_initializing[] = "_initializing"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = "stringsource"; -static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_version_info[] = "version_info"; +static const char __pyx_k_class_getitem[] = "__class_getitem__"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_AssertionError[] = "AssertionError"; +static const char __pyx_k_maximum_path_c[] = "maximum_path_c"; static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; +static const char __pyx_k_collections_abc[] = "collections.abc"; static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_strided_and_direct[] = ""; static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_Invalid_shape_in_axis[] = "Invalid shape in axis "; static const char __pyx_k_contiguous_and_direct[] = ""; +static const char __pyx_k_Cannot_index_with_type[] = "Cannot index with type '"; static const char __pyx_k_MemoryView_of_r_object[] = ""; static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; static const char __pyx_k_contiguous_and_indirect[] = ""; -static const char __pyx_k_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_Dimension_d_is_not_direct[] = "Dimension %d is not direct"; +static const char __pyx_k_Index_out_of_bounds_axis_d[] = "Index out of bounds (axis %d)"; +static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero (axis %d)"; static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; static const char __pyx_k_strided_and_direct_or_indirect[] = ""; +static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced"; static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; +static const char __pyx_k_Cannot_transpose_memoryview_with[] = "Cannot transpose memoryview with indirect dimensions"; static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; -static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))"; static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; -static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %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_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got "; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis "; static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; -static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension "; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_talkingface_utils_vits_utils_mon[] = "talkingface.utils.vits_utils.monotonic_align.core"; 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_s_vs_0xb0; -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_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 */ +/* #### Code section: decls ### */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ @@ -1991,2447 +2949,2857 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 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_pf_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs); /* proto */ static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_int_0; -static PyObject *__pyx_int_1; -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_codeobj__26; -/* Late includes */ - -/* "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 - */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type___pyx_array; + PyObject *__pyx_type___pyx_MemviewEnum; + PyObject *__pyx_type___pyx_memoryview; + PyObject *__pyx_type___pyx_memoryviewslice; + #endif + PyTypeObject *__pyx_array_type; + PyTypeObject *__pyx_MemviewEnum_type; + PyTypeObject *__pyx_memoryview_type; + PyTypeObject *__pyx_memoryviewslice_type; + PyObject *__pyx_kp_u_; + PyObject *__pyx_n_s_ASCII; + PyObject *__pyx_kp_s_All_dimensions_preceding_dimensi; + PyObject *__pyx_n_s_AssertionError; + PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; + PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; + PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; + PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; + PyObject *__pyx_kp_u_Cannot_index_with_type; + PyObject *__pyx_kp_s_Cannot_transpose_memoryview_with; + PyObject *__pyx_kp_s_Dimension_d_is_not_direct; + PyObject *__pyx_n_s_Ellipsis; + PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; + PyObject *__pyx_n_s_IndexError; + PyObject *__pyx_kp_s_Index_out_of_bounds_axis_d; + PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; + PyObject *__pyx_kp_u_Invalid_mode_expected_c_or_fortr; + PyObject *__pyx_kp_u_Invalid_shape_in_axis; + PyObject *__pyx_n_s_MemoryError; + PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; + PyObject *__pyx_kp_s_MemoryView_of_r_object; + PyObject *__pyx_n_b_O; + PyObject *__pyx_kp_u_Out_of_bounds_on_buffer_access_a; + PyObject *__pyx_n_s_PickleError; + PyObject *__pyx_n_s_Sequence; + PyObject *__pyx_kp_s_Step_may_not_be_zero_axis_d; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; + PyObject *__pyx_n_s_ValueError; + PyObject *__pyx_n_s_View_MemoryView; + PyObject *__pyx_kp_u__2; + PyObject *__pyx_n_s__23; + PyObject *__pyx_n_s__3; + PyObject *__pyx_kp_u__6; + PyObject *__pyx_kp_u__7; + PyObject *__pyx_n_s_abc; + PyObject *__pyx_n_s_allocate_buffer; + PyObject *__pyx_kp_u_and; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_base; + PyObject *__pyx_n_s_c; + PyObject *__pyx_n_u_c; + PyObject *__pyx_n_s_class; + PyObject *__pyx_n_s_class_getitem; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_collections; + PyObject *__pyx_kp_s_collections_abc; + PyObject *__pyx_kp_s_contiguous_and_direct; + PyObject *__pyx_kp_s_contiguous_and_indirect; + PyObject *__pyx_kp_s_core_pyx; + PyObject *__pyx_n_s_count; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_n_s_dtype_is_object; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_encode; + PyObject *__pyx_n_s_enumerate; + PyObject *__pyx_n_s_error; + PyObject *__pyx_n_s_flags; + PyObject *__pyx_n_s_format; + PyObject *__pyx_n_s_fortran; + PyObject *__pyx_n_u_fortran; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_kp_u_got; + PyObject *__pyx_kp_u_got_differing_extents_in_dimensi; + PyObject *__pyx_n_s_id; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_index; + PyObject *__pyx_n_s_initializing; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_itemsize; + PyObject *__pyx_kp_s_itemsize_0_for_cython_array; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_maximum_path_c; + PyObject *__pyx_n_s_memview; + PyObject *__pyx_n_s_mode; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_name_2; + PyObject *__pyx_n_s_ndim; + PyObject *__pyx_n_s_new; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_obj; + PyObject *__pyx_n_s_pack; + PyObject *__pyx_n_s_paths; + PyObject *__pyx_n_s_pickle; + PyObject *__pyx_n_s_pyx_PickleError; + PyObject *__pyx_n_s_pyx_checksum; + PyObject *__pyx_n_s_pyx_result; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_type; + PyObject *__pyx_n_s_pyx_unpickle_Enum; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_range; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_register; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_shape; + PyObject *__pyx_n_s_size; + PyObject *__pyx_n_s_spec; + PyObject *__pyx_n_s_start; + PyObject *__pyx_n_s_step; + PyObject *__pyx_n_s_stop; + PyObject *__pyx_kp_s_strided_and_direct; + PyObject *__pyx_kp_s_strided_and_direct_or_indirect; + PyObject *__pyx_kp_s_strided_and_indirect; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_struct; + PyObject *__pyx_n_s_sys; + PyObject *__pyx_n_s_t_xs; + PyObject *__pyx_n_s_t_ys; + PyObject *__pyx_n_s_talkingface_utils_vits_utils_mon; + PyObject *__pyx_n_s_test; + PyObject *__pyx_kp_s_unable_to_allocate_array_data; + PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; + PyObject *__pyx_n_s_unpack; + PyObject *__pyx_n_s_update; + PyObject *__pyx_n_s_values; + PyObject *__pyx_n_s_version_info; + PyObject *__pyx_int_0; + PyObject *__pyx_int_1; + PyObject *__pyx_int_3; + PyObject *__pyx_int_112105877; + PyObject *__pyx_int_136983863; + PyObject *__pyx_int_184977713; + PyObject *__pyx_int_neg_1; + float __pyx_k__9; + PyObject *__pyx_slice__5; + PyObject *__pyx_tuple__4; + PyObject *__pyx_tuple__8; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__11; + PyObject *__pyx_tuple__12; + PyObject *__pyx_tuple__13; + PyObject *__pyx_tuple__14; + PyObject *__pyx_tuple__15; + PyObject *__pyx_tuple__16; + PyObject *__pyx_tuple__17; + PyObject *__pyx_tuple__18; + PyObject *__pyx_tuple__19; + PyObject *__pyx_tuple__21; + PyObject *__pyx_codeobj__20; + PyObject *__pyx_codeobj__22; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif -static void __pyx_f_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_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; - } - } +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - /* "monotonic_align/core.pyx":13 - * cdef float v_cur - * cdef float tmp - * cdef int index = t_x - 1 # <<<<<<<<<<<<<< +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_array_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_array); + Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum); + Py_CLEAR(clear_module_state->__pyx_memoryview_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview); + Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice); + Py_CLEAR(clear_module_state->__pyx_kp_u_); + Py_CLEAR(clear_module_state->__pyx_n_s_ASCII); + Py_CLEAR(clear_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); + Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); + Py_CLEAR(clear_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); + Py_CLEAR(clear_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); + Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); + Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); + Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_index_with_type); + Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); + Py_CLEAR(clear_module_state->__pyx_kp_s_Dimension_d_is_not_direct); + Py_CLEAR(clear_module_state->__pyx_n_s_Ellipsis); + Py_CLEAR(clear_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_CLEAR(clear_module_state->__pyx_n_s_IndexError); + Py_CLEAR(clear_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); + Py_CLEAR(clear_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); + Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); + Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_shape_in_axis); + Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); + Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); + Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_object); + Py_CLEAR(clear_module_state->__pyx_n_b_O); + Py_CLEAR(clear_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); + Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_Sequence); + Py_CLEAR(clear_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); + Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); + Py_CLEAR(clear_module_state->__pyx_n_s_View_MemoryView); + Py_CLEAR(clear_module_state->__pyx_kp_u__2); + Py_CLEAR(clear_module_state->__pyx_n_s__23); + Py_CLEAR(clear_module_state->__pyx_n_s__3); + Py_CLEAR(clear_module_state->__pyx_kp_u__6); + Py_CLEAR(clear_module_state->__pyx_kp_u__7); + Py_CLEAR(clear_module_state->__pyx_n_s_abc); + Py_CLEAR(clear_module_state->__pyx_n_s_allocate_buffer); + Py_CLEAR(clear_module_state->__pyx_kp_u_and); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_base); + Py_CLEAR(clear_module_state->__pyx_n_s_c); + Py_CLEAR(clear_module_state->__pyx_n_u_c); + Py_CLEAR(clear_module_state->__pyx_n_s_class); + Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_collections); + Py_CLEAR(clear_module_state->__pyx_kp_s_collections_abc); + Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_direct); + Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_indirect); + Py_CLEAR(clear_module_state->__pyx_kp_s_core_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_count); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_n_s_dtype_is_object); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_encode); + Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); + Py_CLEAR(clear_module_state->__pyx_n_s_error); + Py_CLEAR(clear_module_state->__pyx_n_s_flags); + Py_CLEAR(clear_module_state->__pyx_n_s_format); + Py_CLEAR(clear_module_state->__pyx_n_s_fortran); + Py_CLEAR(clear_module_state->__pyx_n_u_fortran); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_kp_u_got); + Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); + Py_CLEAR(clear_module_state->__pyx_n_s_id); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_index); + Py_CLEAR(clear_module_state->__pyx_n_s_initializing); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_itemsize); + Py_CLEAR(clear_module_state->__pyx_kp_s_itemsize_0_for_cython_array); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_maximum_path_c); + Py_CLEAR(clear_module_state->__pyx_n_s_memview); + Py_CLEAR(clear_module_state->__pyx_n_s_mode); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_name_2); + Py_CLEAR(clear_module_state->__pyx_n_s_ndim); + Py_CLEAR(clear_module_state->__pyx_n_s_new); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_obj); + Py_CLEAR(clear_module_state->__pyx_n_s_pack); + Py_CLEAR(clear_module_state->__pyx_n_s_paths); + Py_CLEAR(clear_module_state->__pyx_n_s_pickle); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Enum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_range); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_register); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_shape); + Py_CLEAR(clear_module_state->__pyx_n_s_size); + Py_CLEAR(clear_module_state->__pyx_n_s_spec); + Py_CLEAR(clear_module_state->__pyx_n_s_start); + Py_CLEAR(clear_module_state->__pyx_n_s_step); + Py_CLEAR(clear_module_state->__pyx_n_s_stop); + Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct); + Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct_or_indirect); + Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_indirect); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_struct); + Py_CLEAR(clear_module_state->__pyx_n_s_sys); + Py_CLEAR(clear_module_state->__pyx_n_s_t_xs); + Py_CLEAR(clear_module_state->__pyx_n_s_t_ys); + Py_CLEAR(clear_module_state->__pyx_n_s_talkingface_utils_vits_utils_mon); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_array_data); + Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); + Py_CLEAR(clear_module_state->__pyx_n_s_unpack); + Py_CLEAR(clear_module_state->__pyx_n_s_update); + Py_CLEAR(clear_module_state->__pyx_n_s_values); + Py_CLEAR(clear_module_state->__pyx_n_s_version_info); + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_1); + Py_CLEAR(clear_module_state->__pyx_int_3); + Py_CLEAR(clear_module_state->__pyx_int_112105877); + Py_CLEAR(clear_module_state->__pyx_int_136983863); + Py_CLEAR(clear_module_state->__pyx_int_184977713); + Py_CLEAR(clear_module_state->__pyx_int_neg_1); + Py_CLEAR(clear_module_state->__pyx_slice__5); + Py_CLEAR(clear_module_state->__pyx_tuple__4); + Py_CLEAR(clear_module_state->__pyx_tuple__8); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__11); + Py_CLEAR(clear_module_state->__pyx_tuple__12); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_tuple__14); + Py_CLEAR(clear_module_state->__pyx_tuple__15); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_tuple__17); + Py_CLEAR(clear_module_state->__pyx_tuple__18); + Py_CLEAR(clear_module_state->__pyx_tuple__19); + Py_CLEAR(clear_module_state->__pyx_tuple__21); + Py_CLEAR(clear_module_state->__pyx_codeobj__20); + Py_CLEAR(clear_module_state->__pyx_codeobj__22); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_array_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_array); + Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum); + Py_VISIT(traverse_module_state->__pyx_memoryview_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview); + Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice); + Py_VISIT(traverse_module_state->__pyx_kp_u_); + Py_VISIT(traverse_module_state->__pyx_n_s_ASCII); + Py_VISIT(traverse_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); + Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); + Py_VISIT(traverse_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); + Py_VISIT(traverse_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); + Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); + Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); + Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_index_with_type); + Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); + Py_VISIT(traverse_module_state->__pyx_kp_s_Dimension_d_is_not_direct); + Py_VISIT(traverse_module_state->__pyx_n_s_Ellipsis); + Py_VISIT(traverse_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_VISIT(traverse_module_state->__pyx_n_s_IndexError); + Py_VISIT(traverse_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); + Py_VISIT(traverse_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); + Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); + Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_shape_in_axis); + Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); + Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); + Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_object); + Py_VISIT(traverse_module_state->__pyx_n_b_O); + Py_VISIT(traverse_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); + Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_Sequence); + Py_VISIT(traverse_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); + Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); + Py_VISIT(traverse_module_state->__pyx_n_s_View_MemoryView); + Py_VISIT(traverse_module_state->__pyx_kp_u__2); + Py_VISIT(traverse_module_state->__pyx_n_s__23); + Py_VISIT(traverse_module_state->__pyx_n_s__3); + Py_VISIT(traverse_module_state->__pyx_kp_u__6); + Py_VISIT(traverse_module_state->__pyx_kp_u__7); + Py_VISIT(traverse_module_state->__pyx_n_s_abc); + Py_VISIT(traverse_module_state->__pyx_n_s_allocate_buffer); + Py_VISIT(traverse_module_state->__pyx_kp_u_and); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_base); + Py_VISIT(traverse_module_state->__pyx_n_s_c); + Py_VISIT(traverse_module_state->__pyx_n_u_c); + Py_VISIT(traverse_module_state->__pyx_n_s_class); + Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_collections); + Py_VISIT(traverse_module_state->__pyx_kp_s_collections_abc); + Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_direct); + Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_indirect); + Py_VISIT(traverse_module_state->__pyx_kp_s_core_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_count); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_n_s_dtype_is_object); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_encode); + Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); + Py_VISIT(traverse_module_state->__pyx_n_s_error); + Py_VISIT(traverse_module_state->__pyx_n_s_flags); + Py_VISIT(traverse_module_state->__pyx_n_s_format); + Py_VISIT(traverse_module_state->__pyx_n_s_fortran); + Py_VISIT(traverse_module_state->__pyx_n_u_fortran); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_kp_u_got); + Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); + Py_VISIT(traverse_module_state->__pyx_n_s_id); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_index); + Py_VISIT(traverse_module_state->__pyx_n_s_initializing); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_itemsize); + Py_VISIT(traverse_module_state->__pyx_kp_s_itemsize_0_for_cython_array); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_maximum_path_c); + Py_VISIT(traverse_module_state->__pyx_n_s_memview); + Py_VISIT(traverse_module_state->__pyx_n_s_mode); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_name_2); + Py_VISIT(traverse_module_state->__pyx_n_s_ndim); + Py_VISIT(traverse_module_state->__pyx_n_s_new); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_obj); + Py_VISIT(traverse_module_state->__pyx_n_s_pack); + Py_VISIT(traverse_module_state->__pyx_n_s_paths); + Py_VISIT(traverse_module_state->__pyx_n_s_pickle); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Enum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_range); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_register); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_shape); + Py_VISIT(traverse_module_state->__pyx_n_s_size); + Py_VISIT(traverse_module_state->__pyx_n_s_spec); + Py_VISIT(traverse_module_state->__pyx_n_s_start); + Py_VISIT(traverse_module_state->__pyx_n_s_step); + Py_VISIT(traverse_module_state->__pyx_n_s_stop); + Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct); + Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct_or_indirect); + Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_indirect); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_struct); + Py_VISIT(traverse_module_state->__pyx_n_s_sys); + Py_VISIT(traverse_module_state->__pyx_n_s_t_xs); + Py_VISIT(traverse_module_state->__pyx_n_s_t_ys); + Py_VISIT(traverse_module_state->__pyx_n_s_talkingface_utils_vits_utils_mon); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_array_data); + Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); + Py_VISIT(traverse_module_state->__pyx_n_s_unpack); + Py_VISIT(traverse_module_state->__pyx_n_s_update); + Py_VISIT(traverse_module_state->__pyx_n_s_values); + Py_VISIT(traverse_module_state->__pyx_n_s_version_info); + Py_VISIT(traverse_module_state->__pyx_int_0); + Py_VISIT(traverse_module_state->__pyx_int_1); + Py_VISIT(traverse_module_state->__pyx_int_3); + Py_VISIT(traverse_module_state->__pyx_int_112105877); + Py_VISIT(traverse_module_state->__pyx_int_136983863); + Py_VISIT(traverse_module_state->__pyx_int_184977713); + Py_VISIT(traverse_module_state->__pyx_int_neg_1); + Py_VISIT(traverse_module_state->__pyx_slice__5); + Py_VISIT(traverse_module_state->__pyx_tuple__4); + Py_VISIT(traverse_module_state->__pyx_tuple__8); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__11); + Py_VISIT(traverse_module_state->__pyx_tuple__12); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_tuple__14); + Py_VISIT(traverse_module_state->__pyx_tuple__15); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_tuple__17); + Py_VISIT(traverse_module_state->__pyx_tuple__18); + Py_VISIT(traverse_module_state->__pyx_tuple__19); + Py_VISIT(traverse_module_state->__pyx_tuple__21); + Py_VISIT(traverse_module_state->__pyx_codeobj__20); + Py_VISIT(traverse_module_state->__pyx_codeobj__22); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type___pyx_array __pyx_mstate_global->__pyx_type___pyx_array +#define __pyx_type___pyx_MemviewEnum __pyx_mstate_global->__pyx_type___pyx_MemviewEnum +#define __pyx_type___pyx_memoryview __pyx_mstate_global->__pyx_type___pyx_memoryview +#define __pyx_type___pyx_memoryviewslice __pyx_mstate_global->__pyx_type___pyx_memoryviewslice +#endif +#define __pyx_array_type __pyx_mstate_global->__pyx_array_type +#define __pyx_MemviewEnum_type __pyx_mstate_global->__pyx_MemviewEnum_type +#define __pyx_memoryview_type __pyx_mstate_global->__pyx_memoryview_type +#define __pyx_memoryviewslice_type __pyx_mstate_global->__pyx_memoryviewslice_type +#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_ +#define __pyx_n_s_ASCII __pyx_mstate_global->__pyx_n_s_ASCII +#define __pyx_kp_s_All_dimensions_preceding_dimensi __pyx_mstate_global->__pyx_kp_s_All_dimensions_preceding_dimensi +#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError +#define __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_mstate_global->__pyx_kp_s_Buffer_view_does_not_expose_stri +#define __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_mstate_global->__pyx_kp_s_Can_only_create_a_buffer_that_is +#define __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_mstate_global->__pyx_kp_s_Cannot_assign_to_read_only_memor +#define __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_mstate_global->__pyx_kp_s_Cannot_create_writable_memory_vi +#define __pyx_kp_u_Cannot_index_with_type __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type +#define __pyx_kp_s_Cannot_transpose_memoryview_with __pyx_mstate_global->__pyx_kp_s_Cannot_transpose_memoryview_with +#define __pyx_kp_s_Dimension_d_is_not_direct __pyx_mstate_global->__pyx_kp_s_Dimension_d_is_not_direct +#define __pyx_n_s_Ellipsis __pyx_mstate_global->__pyx_n_s_Ellipsis +#define __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_mstate_global->__pyx_kp_s_Empty_shape_tuple_for_cython_arr +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 +#define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError +#define __pyx_kp_s_Index_out_of_bounds_axis_d __pyx_mstate_global->__pyx_kp_s_Index_out_of_bounds_axis_d +#define __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_mstate_global->__pyx_kp_s_Indirect_dimensions_not_supporte +#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr +#define __pyx_kp_u_Invalid_shape_in_axis __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis +#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError +#define __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_at_0x_x +#define __pyx_kp_s_MemoryView_of_r_object __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_object +#define __pyx_n_b_O __pyx_mstate_global->__pyx_n_b_O +#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a +#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError +#define __pyx_n_s_Sequence __pyx_mstate_global->__pyx_n_s_Sequence +#define __pyx_kp_s_Step_may_not_be_zero_axis_d __pyx_mstate_global->__pyx_kp_s_Step_may_not_be_zero_axis_d +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_kp_s_Unable_to_convert_item_to_object __pyx_mstate_global->__pyx_kp_s_Unable_to_convert_item_to_object +#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError +#define __pyx_n_s_View_MemoryView __pyx_mstate_global->__pyx_n_s_View_MemoryView +#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 +#define __pyx_n_s__23 __pyx_mstate_global->__pyx_n_s__23 +#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3 +#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6 +#define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7 +#define __pyx_n_s_abc __pyx_mstate_global->__pyx_n_s_abc +#define __pyx_n_s_allocate_buffer __pyx_mstate_global->__pyx_n_s_allocate_buffer +#define __pyx_kp_u_and __pyx_mstate_global->__pyx_kp_u_and +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_base __pyx_mstate_global->__pyx_n_s_base +#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c +#define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c +#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class +#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections +#define __pyx_kp_s_collections_abc __pyx_mstate_global->__pyx_kp_s_collections_abc +#define __pyx_kp_s_contiguous_and_direct __pyx_mstate_global->__pyx_kp_s_contiguous_and_direct +#define __pyx_kp_s_contiguous_and_indirect __pyx_mstate_global->__pyx_kp_s_contiguous_and_indirect +#define __pyx_kp_s_core_pyx __pyx_mstate_global->__pyx_kp_s_core_pyx +#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_n_s_dtype_is_object __pyx_mstate_global->__pyx_n_s_dtype_is_object +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode +#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate +#define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error +#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags +#define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format +#define __pyx_n_s_fortran __pyx_mstate_global->__pyx_n_s_fortran +#define __pyx_n_u_fortran __pyx_mstate_global->__pyx_n_u_fortran +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got +#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi +#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index +#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_itemsize __pyx_mstate_global->__pyx_n_s_itemsize +#define __pyx_kp_s_itemsize_0_for_cython_array __pyx_mstate_global->__pyx_kp_s_itemsize_0_for_cython_array +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_maximum_path_c __pyx_mstate_global->__pyx_n_s_maximum_path_c +#define __pyx_n_s_memview __pyx_mstate_global->__pyx_n_s_memview +#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 +#define __pyx_n_s_ndim __pyx_mstate_global->__pyx_n_s_ndim +#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj +#define __pyx_n_s_pack __pyx_mstate_global->__pyx_n_s_pack +#define __pyx_n_s_paths __pyx_mstate_global->__pyx_n_s_paths +#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle +#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError +#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum +#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type +#define __pyx_n_s_pyx_unpickle_Enum __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Enum +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_register __pyx_mstate_global->__pyx_n_s_register +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_shape __pyx_mstate_global->__pyx_n_s_shape +#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size +#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec +#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start +#define __pyx_n_s_step __pyx_mstate_global->__pyx_n_s_step +#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop +#define __pyx_kp_s_strided_and_direct __pyx_mstate_global->__pyx_kp_s_strided_and_direct +#define __pyx_kp_s_strided_and_direct_or_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_direct_or_indirect +#define __pyx_kp_s_strided_and_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_indirect +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_struct __pyx_mstate_global->__pyx_n_s_struct +#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys +#define __pyx_n_s_t_xs __pyx_mstate_global->__pyx_n_s_t_xs +#define __pyx_n_s_t_ys __pyx_mstate_global->__pyx_n_s_t_ys +#define __pyx_n_s_talkingface_utils_vits_utils_mon __pyx_mstate_global->__pyx_n_s_talkingface_utils_vits_utils_mon +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_kp_s_unable_to_allocate_array_data __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_array_data +#define __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_shape_and_str +#define __pyx_n_s_unpack __pyx_mstate_global->__pyx_n_s_unpack +#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update +#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values +#define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info +#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 +#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 +#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 +#define __pyx_int_112105877 __pyx_mstate_global->__pyx_int_112105877 +#define __pyx_int_136983863 __pyx_mstate_global->__pyx_int_136983863 +#define __pyx_int_184977713 __pyx_mstate_global->__pyx_int_184977713 +#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 +#define __pyx_k__9 __pyx_mstate_global->__pyx_k__9 +#define __pyx_slice__5 __pyx_mstate_global->__pyx_slice__5 +#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 +#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 +#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 +#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 +#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 +#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 +#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 +#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20 +#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 +/* #### Code section: module_code ### */ + +/* "View.MemoryView":131 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): * - * for y in range(t_y): */ - __pyx_v_index = (__pyx_v_t_x - 1); - /* "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; +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + 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}; + values[3] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_n_s_c)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shape)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itemsize)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 131, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_format)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 131, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode); + if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allocate_buffer); + if (value) { values[4] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 131, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) + __pyx_v_format = values[2]; + __pyx_v_mode = values[3]; + if (values[4]) { + __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 132, __pyx_L3_error) + } else { - /* "monotonic_align/core.pyx":16 + /* "View.MemoryView":132 * - * 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 + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< + * + * cdef int idx */ - __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_v_allocate_buffer = ((int)1); } - __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; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 131, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } - __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; + } + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 131, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { + PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 131, __pyx_L1_error) + } + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); - /* "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: + /* "View.MemoryView":131 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * */ - __pyx_t_8 = ((__pyx_v_x == __pyx_v_y) != 0); - if (__pyx_t_8) { - /* "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; + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "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; - } +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_dim; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + char *__pyx_t_8; + Py_ssize_t __pyx_t_9; + Py_UCS4 __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); - /* "monotonic_align/core.pyx":20 - * v_cur = max_neg_val - * else: - * v_cur = value[y-1, x] # <<<<<<<<<<<<<< - * if x == 0: - * if y == 0: + /* "View.MemoryView":137 + * cdef Py_ssize_t dim + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize + * */ - /*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:; + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 137, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 137, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); - /* "monotonic_align/core.pyx":21 - * else: - * v_cur = value[y-1, x] - * if x == 0: # <<<<<<<<<<<<<< - * if y == 0: - * v_prev = 0. + /* "View.MemoryView":138 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: */ - __pyx_t_8 = ((__pyx_v_x == 0) != 0); - if (__pyx_t_8) { + __pyx_v_self->itemsize = __pyx_v_itemsize; - /* "monotonic_align/core.pyx":22 - * v_cur = value[y-1, x] - * if x == 0: - * if y == 0: # <<<<<<<<<<<<<< - * v_prev = 0. - * else: + /* "View.MemoryView":140 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError, "Empty shape tuple for cython.array" + * */ - __pyx_t_8 = ((__pyx_v_y == 0) != 0); - if (__pyx_t_8) { + __pyx_t_2 = (!(__pyx_v_self->ndim != 0)); + if (unlikely(__pyx_t_2)) { - /* "monotonic_align/core.pyx":23 - * if x == 0: - * if y == 0: - * v_prev = 0. # <<<<<<<<<<<<<< - * else: - * v_prev = max_neg_val + /* "View.MemoryView":141 + * + * if not self.ndim: + * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<< + * + * if itemsize <= 0: */ - __pyx_v_v_prev = 0.; + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Empty_shape_tuple_for_cython_arr, 0, 0); + __PYX_ERR(1, 141, __pyx_L1_error) - /* "monotonic_align/core.pyx":22 - * v_cur = value[y-1, x] - * if x == 0: - * if y == 0: # <<<<<<<<<<<<<< - * v_prev = 0. - * else: + /* "View.MemoryView":140 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError, "Empty shape tuple for cython.array" + * */ - goto __pyx_L9; - } + } - /* "monotonic_align/core.pyx":25 - * v_prev = 0. - * else: - * v_prev = max_neg_val # <<<<<<<<<<<<<< - * else: - * v_prev = value[y-1, x-1] + /* "View.MemoryView":143 + * raise ValueError, "Empty shape tuple for cython.array" + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError, "itemsize <= 0 for cython.array" + * */ - /*else*/ { - __pyx_v_v_prev = __pyx_v_max_neg_val; - } - __pyx_L9:; + __pyx_t_2 = (__pyx_v_itemsize <= 0); + if (unlikely(__pyx_t_2)) { - /* "monotonic_align/core.pyx":21 - * else: - * v_cur = value[y-1, x] - * if x == 0: # <<<<<<<<<<<<<< - * if y == 0: - * v_prev = 0. + /* "View.MemoryView":144 + * + * if itemsize <= 0: + * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): */ - goto __pyx_L8; - } + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_itemsize_0_for_cython_array, 0, 0); + __PYX_ERR(1, 144, __pyx_L1_error) - /* "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) + /* "View.MemoryView":143 + * raise ValueError, "Empty shape tuple for cython.array" + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError, "itemsize <= 0 for cython.array" * */ - /*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:; + } - /* "monotonic_align/core.pyx":28 - * else: - * v_prev = value[y-1, x-1] - * value[y, x] += max(v_prev, v_cur) # <<<<<<<<<<<<<< + /* "View.MemoryView":146 + * raise ValueError, "itemsize <= 0 for cython.array" * - * for y in range(t_y - 1, -1, -1): + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string */ - __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_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_3 = (!__pyx_t_2); + if (__pyx_t_3) { + + /* "View.MemoryView":147 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; } - __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; } - } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_n_s_ASCII}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4); + __pyx_t_4 = 0; - /* "monotonic_align/core.pyx":30 - * value[y, x] += max(v_prev, v_cur) + /* "View.MemoryView":146 + * raise ValueError, "itemsize <= 0 for cython.array" * - * 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]): + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string */ - for (__pyx_t_1 = (__pyx_v_t_y - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_y = __pyx_t_1; + } - /* "monotonic_align/core.pyx":31 + /* "View.MemoryView":148 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format * - * 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; + if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_format))) __PYX_ERR(1, 148, __pyx_L1_error) + __pyx_t_4 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; - /* "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 + /* "View.MemoryView":149 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * * */ - __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) { + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(1, 149, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_8; - /* "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 # <<<<<<<<<<<<<< + /* "View.MemoryView":152 * * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * */ - __pyx_v_index = (__pyx_v_index - 1); + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); - /* "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 + /* "View.MemoryView":153 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< * + * if not self._shape: */ - } - } + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); - /* "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 + /* "View.MemoryView":155 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate shape and strides." + * */ + __pyx_t_3 = (!(__pyx_v_self->_shape != 0)); + if (unlikely(__pyx_t_3)) { - /* function exit code */ -} - -/* "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 + /* "View.MemoryView":156 + * + * if not self._shape: + * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<< + * + * */ + __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_shape_and_str, 0, 0); + __PYX_ERR(1, 156, __pyx_L1_error) -static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static void __pyx_f_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; - - /* "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): + /* "View.MemoryView":155 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate shape and strides." + * */ - __pyx_v_b = (__pyx_v_paths.shape[0]); + } - /* "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]) + /* "View.MemoryView":159 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); + __pyx_t_7 = 0; + __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 159, __pyx_L1_error) #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); + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(1, 159, __pyx_L1_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_7; + __pyx_t_7 = (__pyx_t_7 + 1); - /* "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]) # <<<<<<<<<<<<<< + /* "View.MemoryView":160 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim */ - __pyx_t_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_3 = (__pyx_v_dim <= 0); + if (unlikely(__pyx_t_3)) { -__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; + /* "View.MemoryView":161 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_Invalid_shape_in_axis); + __pyx_t_9 += 22; + __Pyx_GIVEREF(__pyx_kp_u_Invalid_shape_in_axis); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Invalid_shape_in_axis); + __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_); + __pyx_t_9 += 2; + __Pyx_GIVEREF(__pyx_kp_u_); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_); + __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__2); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__2); + PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u__2); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 161, __pyx_L1_error) -__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; + /* "View.MemoryView":160 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim + */ + } -__pyx_t_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; -} + /* "View.MemoryView":162 + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; -__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; + /* "View.MemoryView":159 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; -__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; + /* "View.MemoryView":165 + * + * cdef char order + * if mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 165, __pyx_L1_error) + if (__pyx_t_3) { -__pyx_t_6 = __pyx_v_i; - __pyx_t_7 = __pyx_v_i; - __pyx_f_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 - } + /* "View.MemoryView":166 + * cdef char order + * if mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * elif mode == 'fortran': + */ + __pyx_v_order = 'C'; - /* "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]) + /* "View.MemoryView":167 + * if mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * elif mode == 'fortran': + * order = b'F' */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; + + /* "View.MemoryView":165 + * + * cdef char order + * if mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L11; } - /* "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 + /* "View.MemoryView":168 + * order = b'C' + * self.mode = u'c' + * elif mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' */ + __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 168, __pyx_L1_error) + if (likely(__pyx_t_3)) { - /* function exit code */ -} + /* "View.MemoryView":169 + * self.mode = u'c' + * elif mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * else: + */ + __pyx_v_order = 'F'; -/* Python wrapper */ -static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_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) + /* "View.MemoryView":170 + * elif mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * else: + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" + */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; + + /* "View.MemoryView":168 + * order = b'C' + * self.mode = u'c' + * elif mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L11; } - 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("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_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; -} + /* "View.MemoryView":172 + * self.mode = u'fortran' + * else: + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 172, __pyx_L1_error) + } + __pyx_L11:; -static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs) { - 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_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; + /* "View.MemoryView":174 + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" + * + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<< + * + * self.free_data = allocate_buffer + */ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + + /* "View.MemoryView":176 + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":177 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * + * if allocate_buffer: + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 177, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_3; + + /* "View.MemoryView":179 + * self.dtype_is_object = format == b'O' + * + * if allocate_buffer: # <<<<<<<<<<<<<< + * _allocate_buffer(self) + * + */ + if (__pyx_v_allocate_buffer) { + + /* "View.MemoryView":180 + * + * if allocate_buffer: + * _allocate_buffer(self) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_t_7 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 180, __pyx_L1_error) + + /* "View.MemoryView":179 + * self.dtype_is_object = format == b'O' + * + * if allocate_buffer: # <<<<<<<<<<<<<< + * _allocate_buffer(self) + * + */ + } + + /* "View.MemoryView":131 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __PYX_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_XDECREF(__pyx_v_format); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): +/* "View.MemoryView":182 + * _allocate_buffer(self) * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 */ /* 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; +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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, 122, __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, 122, __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, 122, __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, 122, __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, 123, __pyx_L3_error) - } else { - - /* "View.MemoryView":123 - * - * 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, 122, __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, 122, __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, 122, __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":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __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 */ - 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; +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 - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + int __pyx_t_1; + char *__pyx_t_2; + Py_ssize_t __pyx_t_3; 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; + Py_ssize_t *__pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_INCREF(__pyx_v_format); + if (unlikely(__pyx_v_info == NULL)) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); - /* "View.MemoryView":129 - * cdef PyObject **p - * - * self.ndim = len(shape) # <<<<<<<<<<<<<< - * self.itemsize = itemsize - * + /* "View.MemoryView":184 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": */ - if (unlikely(__pyx_v_shape == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 129, __pyx_L1_error) - } - __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 129, __pyx_L1_error) - __pyx_v_self->ndim = ((int)__pyx_t_1); + __pyx_v_bufmode = -1; - /* "View.MemoryView":130 - * - * self.ndim = len(shape) - * self.itemsize = itemsize # <<<<<<<<<<<<<< - * - * if not self.ndim: + /* "View.MemoryView":185 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ - __pyx_v_self->itemsize = __pyx_v_itemsize; + __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":132 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError("Empty shape tuple for cython.array") - * + /* "View.MemoryView":186 + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": */ - __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 186, __pyx_L1_error) + if (__pyx_t_1) { - /* "View.MemoryView":133 - * - * if not self.ndim: - * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< - * - * if itemsize <= 0: + /* "View.MemoryView":187 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 133, __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, 133, __pyx_L1_error) + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - /* "View.MemoryView":132 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError("Empty shape tuple for cython.array") - * + /* "View.MemoryView":186 + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": */ - } + goto __pyx_L4; + } - /* "View.MemoryView":135 - * raise ValueError("Empty shape tuple for cython.array") - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError("itemsize <= 0 for cython.array") - * + /* "View.MemoryView":188 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): */ - __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 188, __pyx_L1_error) + if (__pyx_t_1) { - /* "View.MemoryView":136 - * - * if itemsize <= 0: - * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< - * - * if not isinstance(format, bytes): + /* "View.MemoryView":189 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __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, 136, __pyx_L1_error) + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - /* "View.MemoryView":135 - * raise ValueError("Empty shape tuple for cython.array") - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError("itemsize <= 0 for cython.array") - * + /* "View.MemoryView":188 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): */ - } + } + __pyx_L4:; - /* "View.MemoryView":138 - * 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":190 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data */ - __pyx_t_2 = PyBytes_Check(__pyx_v_format); - __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); - if (__pyx_t_4) { + __pyx_t_1 = (!((__pyx_v_flags & __pyx_v_bufmode) != 0)); + if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":139 - * - * if not isinstance(format, bytes): - * format = format.encode('ASCII') # <<<<<<<<<<<<<< - * self._format = format # keep a reference to the byte string - * self.format = self._format + /* "View.MemoryView":191 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Can_only_create_a_buffer_that_is, 0, 0); + __PYX_ERR(1, 191, __pyx_L1_error) + + /* "View.MemoryView":190 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __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, 139, __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":138 - * 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":185 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ } - /* "View.MemoryView":140 - * if not isinstance(format, bytes): - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< - * self.format = self._format + /* "View.MemoryView":192 + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len * */ - 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, 140, __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; + __pyx_t_2 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_2; - /* "View.MemoryView":141 - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - * self.format = self._format # <<<<<<<<<<<<<< - * + /* "View.MemoryView":193 + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< * + * if flags & PyBUF_STRIDES: */ - if (unlikely(__pyx_v_self->_format == Py_None)) { - PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); - __PYX_ERR(1, 141, __pyx_L1_error) - } - __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 141, __pyx_L1_error) - __pyx_v_self->format = __pyx_t_7; + __pyx_t_3 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_3; - /* "View.MemoryView":144 - * - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< - * self._strides = self._shape + self.ndim + /* "View.MemoryView":195 + * info.len = self.len * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape */ - __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":145 - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) - * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + /* "View.MemoryView":196 * - * if not self._shape: + * if flags & PyBUF_STRIDES: + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides */ - __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + __pyx_t_4 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_4; - /* "View.MemoryView":147 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate shape and strides.") - * + /* "View.MemoryView":197 + * if flags & PyBUF_STRIDES: + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * else: */ - __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_5; - /* "View.MemoryView":148 - * - * if not self._shape: - * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< - * - * + /* "View.MemoryView":198 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * else: + * info.ndim = 1 */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 148, __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, 148, __pyx_L1_error) + __pyx_t_5 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_5; - /* "View.MemoryView":147 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate shape and strides.") + /* "View.MemoryView":195 + * info.len = self.len * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape */ + goto __pyx_L6; } - /* "View.MemoryView":151 - * - * - * 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, 151, __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, 151, __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, 151, __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":152 - * - * 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":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":200 + * info.strides = self._strides + * else: + * info.ndim = 1 # <<<<<<<<<<<<<< + * info.shape = &self.len if flags & PyBUF_ND else NULL + * info.strides = NULL */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 153, __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, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __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, 153, __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, 153, __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, 153, __pyx_L1_error) + /*else*/ { + __pyx_v_info->ndim = 1; - /* "View.MemoryView":152 + /* "View.MemoryView":201 + * else: + * info.ndim = 1 + * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<< + * info.strides = NULL * - * 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_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + __pyx_t_5 = (&__pyx_v_self->len); + } else { + __pyx_t_5 = NULL; } + __pyx_v_info->shape = __pyx_t_5; - /* "View.MemoryView":154 - * 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":151 - * + /* "View.MemoryView":202 + * info.ndim = 1 + * info.shape = &self.len if flags & PyBUF_ND else NULL + * info.strides = NULL # <<<<<<<<<<<<<< * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * info.suboffsets = NULL */ + __pyx_v_info->strides = NULL; } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L6:; - /* "View.MemoryView":157 + /* "View.MemoryView":204 + * info.strides = NULL * - * cdef char order - * if mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 */ - __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 157, __pyx_L1_error) - if (__pyx_t_4) { + __pyx_v_info->suboffsets = NULL; - /* "View.MemoryView":158 - * cdef char order - * if mode == 'fortran': - * order = b'F' # <<<<<<<<<<<<<< - * self.mode = u'fortran' - * elif mode == 'c': + /* "View.MemoryView":205 + * + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL */ - __pyx_v_order = 'F'; + __pyx_t_3 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_3; - /* "View.MemoryView":159 - * if mode == 'fortran': - * order = b'F' - * self.mode = u'fortran' # <<<<<<<<<<<<<< - * elif mode == 'c': - * order = b'C' + /* "View.MemoryView":206 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * info.format = self.format if flags & PyBUF_FORMAT else NULL + * info.obj = self */ - __Pyx_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; + __pyx_v_info->readonly = 0; - /* "View.MemoryView":157 + /* "View.MemoryView":207 + * info.itemsize = self.itemsize + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<< + * info.obj = self * - * cdef char order - * if mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' */ - goto __pyx_L10; + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + __pyx_t_2 = __pyx_v_self->format; + } else { + __pyx_t_2 = NULL; } + __pyx_v_info->format = __pyx_t_2; - /* "View.MemoryView":160 - * 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, 160, __pyx_L1_error) - if (likely(__pyx_t_4)) { - - /* "View.MemoryView":161 - * self.mode = u'fortran' - * elif mode == 'c': - * order = b'C' # <<<<<<<<<<<<<< - * self.mode = u'c' - * else: + /* "View.MemoryView":208 + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL + * info.obj = self # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): */ - __pyx_v_order = 'C'; + __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":162 - * elif mode == 'c': - * order = b'C' - * self.mode = u'c' # <<<<<<<<<<<<<< - * else: - * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + /* "View.MemoryView":182 + * _allocate_buffer(self) + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 */ - __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":160 - * order = b'F' - * self.mode = u'fortran' - * elif mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - goto __pyx_L10; + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } - - /* "View.MemoryView":164 - * 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, 164, __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, 164, __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, 164, __pyx_L1_error) + 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_L10:; + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":166 - * 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) +/* "View.MemoryView":210 + * info.obj = self * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) */ - __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":169 - * 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; +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); - /* "View.MemoryView":170 - * - * 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, 170, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 170, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_self->dtype_is_object = __pyx_t_4; + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} - /* "View.MemoryView":171 - * 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) { +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_t_1; + int __pyx_t_2; - /* "View.MemoryView":174 - * + /* "View.MemoryView":211 * - * self.data = malloc(self.len) # <<<<<<<<<<<<<< - * if not self.data: - * raise MemoryError("unable to allocate array data.") + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: */ - __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL); + if (__pyx_t_1) { - /* "View.MemoryView":175 - * - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate array data.") - * + /* "View.MemoryView":212 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: */ - __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_v_self->callback_free_data(__pyx_v_self->data); - /* "View.MemoryView":176 - * self.data = malloc(self.len) - * if not self.data: - * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + /* "View.MemoryView":211 * - * if self.dtype_is_object: + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __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, 176, __pyx_L1_error) + goto __pyx_L3; + } - /* "View.MemoryView":175 - * - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate array data.") - * + /* "View.MemoryView":213 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) */ - } + if (__pyx_v_self->free_data) { + } else { + __pyx_t_1 = __pyx_v_self->free_data; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->data != NULL); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { - /* "View.MemoryView":178 - * raise MemoryError("unable to allocate array data.") - * + /* "View.MemoryView":214 + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len / itemsize): + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) */ - __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_4) { + if (__pyx_v_self->dtype_is_object) { - /* "View.MemoryView":179 - * + /* "View.MemoryView":215 + * elif self.free_data and self.data is not NULL: * if self.dtype_is_object: - * p = self.data # <<<<<<<<<<<<<< - * for i in range(self.len / itemsize): - * p[i] = Py_None + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<< + * free(self.data) + * PyObject_Free(self._shape) */ - __pyx_v_p = ((PyObject **)__pyx_v_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":180 - * 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, 180, __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, 180, __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":181 - * p = self.data - * for i in range(self.len / itemsize): - * p[i] = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * + /* "View.MemoryView":214 + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) */ - (__pyx_v_p[__pyx_v_i]) = Py_None; + } - /* "View.MemoryView":182 - * for i in range(self.len / itemsize): - * p[i] = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + /* "View.MemoryView":216 + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) * - * @cname('getbuffer') */ - Py_INCREF(Py_None); - } + free(__pyx_v_self->data); - /* "View.MemoryView":178 - * raise MemoryError("unable to allocate array data.") - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len / itemsize): + /* "View.MemoryView":213 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) */ - } + } + __pyx_L3:; - /* "View.MemoryView":171 - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' - * if allocate_buffer: # <<<<<<<<<<<<<< - * + /* "View.MemoryView":217 + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< * + * @property */ - } + PyObject_Free(__pyx_v_self->_shape); - /* "View.MemoryView":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): + /* "View.MemoryView":210 + * info.obj = self * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) */ /* function exit code */ - __pyx_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":185 +/* "View.MemoryView":219 + * PyObject_Free(self._shape) * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< - * cdef int bufmode = -1 - * if self.mode == u"c": + * @property # <<<<<<<<<<<<<< + * def memview(self): + * return self.get_memview() */ /* 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; +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __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)); + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __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 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; +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; __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; + PyObject *__pyx_t_1 = NULL; 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); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":186 - * @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 + /* "View.MemoryView":221 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< + * + * @cname('get_memview') */ - __pyx_v_bufmode = -1; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "View.MemoryView":187 - * 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": + /* "View.MemoryView":219 + * PyObject_Free(self._shape) + * + * @property # <<<<<<<<<<<<<< + * def memview(self): + * return self.get_memview() */ - __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, 187, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - /* "View.MemoryView":188 - * 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); + /* 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":187 - * 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": +/* "View.MemoryView":224 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) */ - goto __pyx_L3; - } - /* "View.MemoryView":189 - * 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, 189, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { +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", 1); - /* "View.MemoryView":190 - * 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.") + /* "View.MemoryView":225 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) + * */ - __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); - /* "View.MemoryView":189 - * 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): + /* "View.MemoryView":226 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * def __len__(self): */ - } - __pyx_L3:; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(1, 226, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; - /* "View.MemoryView":191 - * 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":224 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) */ - __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); - if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":192 - * 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, 192, __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, 192, __pyx_L1_error) + /* 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":191 - * 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":228 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * */ - } - /* "View.MemoryView":193 - * 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; +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); - /* "View.MemoryView":194 - * 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; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":195 - * 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; +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; - /* "View.MemoryView":196 - * info.len = self.len - * info.ndim = self.ndim - * info.shape = self._shape # <<<<<<<<<<<<<< - * info.strides = self._strides - * info.suboffsets = NULL + /* "View.MemoryView":229 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): */ - __pyx_t_7 = __pyx_v_self->_shape; - __pyx_v_info->shape = __pyx_t_7; + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; - /* "View.MemoryView":197 - * info.ndim = self.ndim - * info.shape = self._shape - * info.strides = self._strides # <<<<<<<<<<<<<< - * info.suboffsets = NULL - * info.itemsize = self.itemsize + /* "View.MemoryView":228 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * */ - __pyx_t_7 = __pyx_v_self->_strides; - __pyx_v_info->strides = __pyx_t_7; - /* "View.MemoryView":198 - * info.shape = self._shape - * info.strides = self._strides - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = self.itemsize - * info.readonly = 0 - */ - __pyx_v_info->suboffsets = NULL; + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} - /* "View.MemoryView":199 - * info.strides = self._strides - * info.suboffsets = NULL - * info.itemsize = self.itemsize # <<<<<<<<<<<<<< - * info.readonly = 0 +/* "View.MemoryView":231 + * return self._shape[0] * - */ - __pyx_t_5 = __pyx_v_self->itemsize; - __pyx_v_info->itemsize = __pyx_t_5; - - /* "View.MemoryView":200 - * info.suboffsets = NULL - * info.itemsize = self.itemsize - * info.readonly = 0 # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - __pyx_v_info->readonly = 0; - - /* "View.MemoryView":202 - * info.readonly = 0 + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.format - * else: */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - /* "View.MemoryView":203 - * - * 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; +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); - /* "View.MemoryView":202 - * info.readonly = 0 - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.format - * else: - */ - goto __pyx_L5; - } + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":205 - * info.format = self.format - * else: - * info.format = NULL # <<<<<<<<<<<<<< - * - * info.obj = self - */ - /*else*/ { - __pyx_v_info->format = NULL; - } - __pyx_L5:; +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__", 1); - /* "View.MemoryView":207 - * info.format = NULL + /* "View.MemoryView":232 * - * info.obj = self # <<<<<<<<<<<<<< + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< * - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * def __getitem__(self, item): */ - __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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; - /* "View.MemoryView":185 + /* "View.MemoryView":231 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) * - * @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_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:; - 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_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":211 - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") +/* "View.MemoryView":234 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] * - * 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) { +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __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 void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { +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 - int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); - - /* "View.MemoryView":212 - * - * 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":213 - * 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); + 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__", 1); - /* "View.MemoryView":212 + /* "View.MemoryView":235 * - * 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":214 - * 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":215 - * 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":216 - * 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":215 - * 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":218 - * refcount_objects_in_slice(self.data, self._shape, - * self._strides, self.ndim, False) - * free(self.data) # <<<<<<<<<<<<<< - * PyObject_Free(self._shape) + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< * + * def __setitem__(self, item, value): */ - free(__pyx_v_self->data); - - /* "View.MemoryView":214 - * 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:; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; - /* "View.MemoryView":219 - * self._strides, self.ndim, False) - * free(self.data) - * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + /* "View.MemoryView":234 + * return getattr(self.memview, attr) * - * @property - */ - PyObject_Free(__pyx_v_self->_shape); - - /* "View.MemoryView":211 - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) */ /* 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":222 +/* "View.MemoryView":237 + * return self.memview[item] * - * @property - * def memview(self): # <<<<<<<<<<<<<< - * return self.get_memview() + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value * */ /* 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; +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __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 PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; +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("__get__", 0); + __Pyx_RefNannySetupContext("__setitem__", 1); - /* "View.MemoryView":223 - * @property - * def memview(self): - * return self.get_memview() # <<<<<<<<<<<<<< + /* "View.MemoryView":238 + * + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< + * * - * @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, 223, __pyx_L1_error) + __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_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0))) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":222 + /* "View.MemoryView":237 + * return self.memview[item] * - * @property - * def memview(self): # <<<<<<<<<<<<<< - * return self.get_memview() + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value * */ /* 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":226 - * - * @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":227 - * @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":228 - * 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, 228, __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, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 228, __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, 228, __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; + __pyx_r = 0; goto __pyx_L0; - - /* "View.MemoryView":226 - * - * @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_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":230 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * +/* "(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 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; +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; __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)); + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static 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; +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__", 0); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); - /* "View.MemoryView":231 - * - * def __len__(self): - * return self._shape[0] # <<<<<<<<<<<<<< - * - * def __getattr__(self, attr): + /* "(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_r = (__pyx_v_self->_shape[0]); - goto __pyx_L0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) - /* "View.MemoryView":230 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * + /* "(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_L0:; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":233 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * +/* "(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_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ -static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; 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)); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __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) { +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; - PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getattr__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); - /* "View.MemoryView":234 - * - * def __getattr__(self, attr): - * return getattr(self.memview, attr) # <<<<<<<<<<<<<< - * - * def __getitem__(self, item): + /* "(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_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, 234, __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, 234, __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; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) - /* "View.MemoryView":233 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * + /* "(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_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; - __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":236 - * return getattr(self.memview, attr) +/* "View.MemoryView":248 + * + * @cname("__pyx_array_allocate_buffer") + * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< * - * 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; +static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_i; + PyObject **__pyx_v_p; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 0); - /* "View.MemoryView":237 + /* "View.MemoryView":254 + * cdef PyObject **p * - * def __getitem__(self, item): - * return self.memview[item] # <<<<<<<<<<<<<< - * - * def __setitem__(self, item, value): + * self.free_data = True # <<<<<<<<<<<<<< + * self.data = malloc(self.len) + * if not self.data: */ - __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, 237, __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, 237, __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; + __pyx_v_self->free_data = 1; - /* "View.MemoryView":236 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] + /* "View.MemoryView":255 * + * self.free_data = True + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError, "unable to allocate array data." */ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); - /* 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":239 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value + /* "View.MemoryView":256 + * self.free_data = True + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate array data." * */ + __pyx_t_1 = (!(__pyx_v_self->data != 0)); + if (unlikely(__pyx_t_1)) { -/* 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":240 - * - * def __setitem__(self, item, value): - * self.memview[item] = value # <<<<<<<<<<<<<< - * + /* "View.MemoryView":257 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<< * + * if self.dtype_is_object: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 240, __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, 240, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_array_data, 0, 0); + __PYX_ERR(1, 257, __pyx_L1_error) - /* "View.MemoryView":239 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value + /* "View.MemoryView":256 + * self.free_data = True + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate array data." * */ + } - /* 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): + /* "View.MemoryView":259 + * raise MemoryError, "unable to allocate array data." + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len // self.itemsize): */ + if (__pyx_v_self->dtype_is_object) { -/* 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__") + /* "View.MemoryView":260 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len // self.itemsize): + * p[i] = Py_None */ - __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) + __pyx_v_p = ((PyObject **)__pyx_v_self->data); - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): + /* "View.MemoryView":261 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) */ + if (unlikely(__pyx_v_self->itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 261, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 261, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; - /* 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__") + /* "View.MemoryView":262 + * p = self.data + * for i in range(self.len // self.itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * return 0 */ + (__pyx_v_p[__pyx_v_i]) = Py_None; -/* 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; -} + /* "View.MemoryView":263 + * for i in range(self.len // self.itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * return 0 + * + */ + Py_INCREF(Py_None); + } -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); + /* "View.MemoryView":259 + * raise MemoryError, "unable to allocate array data." + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len // self.itemsize): + */ + } - /* "(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__") # <<<<<<<<<<<<<< + /* "View.MemoryView":264 + * p[i] = Py_None + * Py_INCREF(Py_None) + * return 0 # <<<<<<<<<<<<<< + * + * */ - __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) + __pyx_r = 0; + goto __pyx_L0; - /* "(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__") + /* "View.MemoryView":248 + * + * @cname("__pyx_array_allocate_buffer") + * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< + * + * */ /* 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(); + __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; return __pyx_r; } -/* "View.MemoryView":244 +/* "View.MemoryView":268 * * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< - * char *mode, char *buf): + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< * cdef array result + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. */ -static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_c_mode, char *__pyx_v_buf) { struct __pyx_array_obj *__pyx_v_result = 0; + PyObject *__pyx_v_mode = 0; struct __pyx_array_obj *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("array_cwrapper", 0); + __Pyx_RefNannySetupContext("array_cwrapper", 1); - /* "View.MemoryView":248 + /* "View.MemoryView":270 + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): * cdef array result + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<< + * + * if buf is NULL: + */ + __pyx_t_2 = ((__pyx_v_c_mode[0]) == 'f'); + if (__pyx_t_2) { + __Pyx_INCREF(__pyx_n_s_fortran); + __pyx_t_1 = __pyx_n_s_fortran; + } else { + __Pyx_INCREF(__pyx_n_s_c); + __pyx_t_1 = __pyx_n_s_c; + } + __pyx_v_mode = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":272 + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. * - * if buf == NULL: # <<<<<<<<<<<<<< - * result = array(shape, itemsize, format, mode.decode('ASCII')) + * if buf is NULL: # <<<<<<<<<<<<<< + * result = array.__new__(array, shape, itemsize, format, mode) * else: */ - __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); - if (__pyx_t_1) { + __pyx_t_2 = (__pyx_v_buf == NULL); + if (__pyx_t_2) { - /* "View.MemoryView":249 + /* "View.MemoryView":273 * - * if buf == NULL: - * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * if buf is NULL: + * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<< * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) */ - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 249, __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, 249, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 249, __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape)) __PYX_ERR(1, 273, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error); __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; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_mode); + __Pyx_GIVEREF(__pyx_v_mode); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode)) __PYX_ERR(1, 273, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); __pyx_t_3 = 0; - __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, 249, __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":248 - * cdef array result + /* "View.MemoryView":272 + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. * - * if buf == NULL: # <<<<<<<<<<<<<< - * result = array(shape, itemsize, format, mode.decode('ASCII')) + * if buf is NULL: # <<<<<<<<<<<<<< + * result = array.__new__(array, shape, itemsize, format, mode) * else: */ goto __pyx_L3; } - /* "View.MemoryView":251 - * result = array(shape, itemsize, format, mode.decode('ASCII')) + /* "View.MemoryView":275 + * result = array.__new__(array, shape, itemsize, format, mode) * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< - * allocate_buffer=False) + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<< * result.data = buf + * */ /*else*/ { - __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 251, __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, 251, __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, 251, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_shape); __Pyx_GIVEREF(__pyx_v_shape); - PyTuple_SET_ITEM(__pyx_t_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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape)) __PYX_ERR(1, 275, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_mode); + __Pyx_GIVEREF(__pyx_v_mode); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode)) __PYX_ERR(1, 275, __pyx_L1_error); + __pyx_t_3 = 0; __pyx_t_4 = 0; - __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 275, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":252 - * 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, 252, __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, 252, __pyx_L1_error) - - /* "View.MemoryView":251 - * result = array(shape, itemsize, format, mode.decode('ASCII')) + /* "View.MemoryView":276 * 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, 251, __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":253 - * result = array(shape, itemsize, format, mode.decode('ASCII'), - * allocate_buffer=False) + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) * result.data = buf # <<<<<<<<<<<<<< * * return result @@ -4440,42 +5808,42 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize } __pyx_L3:; - /* "View.MemoryView":255 + /* "View.MemoryView":278 * result.data = buf * * return result # <<<<<<<<<<<<<< * * */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_result); __pyx_r = __pyx_v_result; goto __pyx_L0; - /* "View.MemoryView":244 + /* "View.MemoryView":268 * * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< - * char *mode, char *buf): + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< * cdef array result + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __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_XDECREF(__pyx_v_mode); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":281 +/* "View.MemoryView":304 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< @@ -4487,44 +5855,64 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_name = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 281, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 304, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_name = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 281, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 304, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -4532,6 +5920,12 @@ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_ar __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4539,9 +5933,9 @@ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_ar 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); + __Pyx_RefNannySetupContext("__init__", 1); - /* "View.MemoryView":282 + /* "View.MemoryView":305 * cdef object name * def __init__(self, name): * self.name = name # <<<<<<<<<<<<<< @@ -4554,7 +5948,7 @@ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struc __Pyx_DECREF(__pyx_v_self->name); __pyx_v_self->name = __pyx_v_name; - /* "View.MemoryView":281 + /* "View.MemoryView":304 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< @@ -4568,7 +5962,7 @@ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struc return __pyx_r; } -/* "View.MemoryView":283 +/* "View.MemoryView":306 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< @@ -4579,9 +5973,11 @@ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struc /* Python wrapper */ static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ @@ -4592,9 +5988,9 @@ static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { 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); + __Pyx_RefNannySetupContext("__repr__", 1); - /* "View.MemoryView":284 + /* "View.MemoryView":307 * self.name = name * def __repr__(self): * return self.name # <<<<<<<<<<<<<< @@ -4606,7 +6002,7 @@ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr_ __pyx_r = __pyx_v_self->name; goto __pyx_L0; - /* "View.MemoryView":283 + /* "View.MemoryView":306 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< @@ -4628,11 +6024,38 @@ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr_ */ /* 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) { +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ @@ -4648,13 +6071,12 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; + 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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":5 * cdef object _dict @@ -4667,7 +6089,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name)) __PYX_ERR(1, 5, __pyx_L1_error); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -4691,8 +6113,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi * use_setstate = True */ __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -4705,12 +6126,12 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; /* "(tree fragment)":9 * if _dict is not None: @@ -4736,11 +6157,11 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi * else: * use_setstate = self.name is not None # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state */ /*else*/ { - __pyx_t_3 = (__pyx_v_self->name != Py_None); - __pyx_v_use_setstate = __pyx_t_3; + __pyx_t_2 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_2; } __pyx_L3:; @@ -4748,89 +6169,88 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state * else: */ - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + if (__pyx_v_use_setstate) { /* "(tree fragment)":13 * use_setstate = self.name is not None * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_184977713); - __Pyx_GIVEREF(__pyx_int_184977713); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_136983863); + __Pyx_GIVEREF(__pyx_int_136983863); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 13, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_184977713); - __Pyx_GIVEREF(__pyx_int_184977713); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_136983863); + __Pyx_GIVEREF(__pyx_int_136983863); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 15, __pyx_L1_error); __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error); __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; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; goto __pyx_L0; } @@ -4843,8 +6263,8 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __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:; @@ -4857,20 +6277,102 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4882,21 +6384,21 @@ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_Me int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":17 - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(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) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ @@ -4914,90 +6416,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_Me return __pyx_r; } -/* "View.MemoryView":298 - * - * @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":300 - * 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":304 - * - * with cython.cdivision(True): - * offset = aligned_p % alignment # <<<<<<<<<<<<<< - * - * if offset > 0: - */ - __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); - - /* "View.MemoryView":306 - * 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":307 - * - * 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":306 - * offset = aligned_p % alignment - * - * if offset > 0: # <<<<<<<<<<<<<< - * aligned_p += alignment - offset - * - */ - } - - /* "View.MemoryView":309 - * aligned_p += alignment - offset - * - * return aligned_p # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = ((void *)__pyx_v_aligned_p); - goto __pyx_L0; - - /* "View.MemoryView":298 - * - * @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":345 +/* "View.MemoryView":349 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< @@ -5011,71 +6430,96 @@ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_ar PyObject *__pyx_v_obj = 0; int __pyx_v_flags; int __pyx_v_dtype_is_object; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - 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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 345, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 349, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dtype_is_object); + if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 345, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 349, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_obj = values[0]; - __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 345, __pyx_L3_error) + __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) if (values[2]) { - __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 345, __pyx_L3_error) + __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) } else { __pyx_v_dtype_is_object = ((int)0); } } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 345, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 349, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -5083,6 +6527,12 @@ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_ar __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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5093,13 +6543,14 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; - int __pyx_t_4; + Py_intptr_t __pyx_t_4; + size_t __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_RefNannySetupContext("__cinit__", 1); - /* "View.MemoryView":346 + /* "View.MemoryView":350 * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj # <<<<<<<<<<<<<< @@ -5112,7 +6563,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __Pyx_DECREF(__pyx_v_self->obj); __pyx_v_self->obj = __pyx_v_obj; - /* "View.MemoryView":347 + /* "View.MemoryView":351 * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj * self.flags = flags # <<<<<<<<<<<<<< @@ -5121,7 +6572,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ __pyx_v_self->flags = __pyx_v_flags; - /* "View.MemoryView":348 + /* "View.MemoryView":352 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< @@ -5129,38 +6580,36 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ * 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) { + if (!__pyx_t_2) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = (__pyx_v_obj != Py_None); - __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_2 = (__pyx_v_obj != Py_None); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { - /* "View.MemoryView":349 + /* "View.MemoryView":353 * self.flags = flags * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None */ - __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 349, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 353, __pyx_L1_error) - /* "View.MemoryView":350 + /* "View.MemoryView":354 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) */ - __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + __pyx_t_1 = (((PyObject *)__pyx_v_self->view.obj) == NULL); if (__pyx_t_1) { - /* "View.MemoryView":351 + /* "View.MemoryView":355 * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< @@ -5169,16 +6618,16 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; - /* "View.MemoryView":352 + /* "View.MemoryView":356 * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * - * global __pyx_memoryview_thread_locks_used + * if not __PYX_CYTHON_ATOMICS_ENABLED(): */ Py_INCREF(Py_None); - /* "View.MemoryView":350 + /* "View.MemoryView":354 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< @@ -5187,7 +6636,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ } - /* "View.MemoryView":348 + /* "View.MemoryView":352 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< @@ -5196,101 +6645,120 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ } - /* "View.MemoryView":355 + /* "View.MemoryView":358 + * Py_INCREF(Py_None) * - * 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 not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < 8: */ - __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED()); if (__pyx_t_1) { - /* "View.MemoryView":356 - * 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: + /* "View.MemoryView":360 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 */ - __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_1 = (__pyx_memoryview_thread_locks_used < 8); + if (__pyx_t_1) { - /* "View.MemoryView":357 - * 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() + /* "View.MemoryView":361 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < 8: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: */ - __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - /* "View.MemoryView":355 - * - * 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":362 + * if __pyx_memoryview_thread_locks_used < 8: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() */ - } + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); - /* "View.MemoryView":358 - * 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() + /* "View.MemoryView":360 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":363 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + __pyx_t_1 = (__pyx_v_self->lock == NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":364 + * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError */ - __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); - if (__pyx_t_1) { + __pyx_v_self->lock = PyThread_allocate_lock(); - /* "View.MemoryView":359 - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + /* "View.MemoryView":365 * if self.lock is NULL: - * raise MemoryError + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * */ - __pyx_v_self->lock = PyThread_allocate_lock(); + __pyx_t_1 = (__pyx_v_self->lock == NULL); + if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":360 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError + /* "View.MemoryView":366 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< * + * if flags & PyBUF_FORMAT: */ - __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); - if (unlikely(__pyx_t_1)) { + PyErr_NoMemory(); __PYX_ERR(1, 366, __pyx_L1_error) - /* "View.MemoryView":361 - * self.lock = PyThread_allocate_lock() + /* "View.MemoryView":365 * if self.lock is NULL: - * raise MemoryError # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError * - * if flags & PyBUF_FORMAT: */ - PyErr_NoMemory(); __PYX_ERR(1, 361, __pyx_L1_error) + } - /* "View.MemoryView":360 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() + /* "View.MemoryView":363 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: */ } /* "View.MemoryView":358 - * 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: + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < 8: */ } - /* "View.MemoryView":363 - * raise MemoryError + /* "View.MemoryView":368 + * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') @@ -5299,65 +6767,81 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":364 + /* "View.MemoryView":369 * * if flags & PyBUF_FORMAT: * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< * else: * self.dtype_is_object = dtype_is_object */ - __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + __pyx_t_2 = ((__pyx_v_self->view.format[0]) == 'O'); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; - goto __pyx_L11_bool_binop_done; + goto __pyx_L12_bool_binop_done; } - __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00'); __pyx_t_1 = __pyx_t_2; - __pyx_L11_bool_binop_done:; + __pyx_L12_bool_binop_done:; __pyx_v_self->dtype_is_object = __pyx_t_1; - /* "View.MemoryView":363 - * raise MemoryError + /* "View.MemoryView":368 + * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: */ - goto __pyx_L10; + goto __pyx_L11; } - /* "View.MemoryView":366 + /* "View.MemoryView":371 * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< * - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 */ /*else*/ { __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; } - __pyx_L10:; + __pyx_L11:; - /* "View.MemoryView":368 + /* "View.MemoryView":373 * 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)) + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<< * 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)))); + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_4 = ((Py_intptr_t)((void *)(&__pyx_v_self->acquisition_count))); + __pyx_t_5 = (sizeof(__pyx_atomic_int_type)); + if (unlikely(__pyx_t_5 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 373, __pyx_L1_error) + } + __pyx_t_1 = ((__pyx_t_4 % __pyx_t_5) == 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 373, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 373, __pyx_L1_error) + #endif - /* "View.MemoryView":370 - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( - * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + /* "View.MemoryView":374 + * + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 * self.typeinfo = NULL # <<<<<<<<<<<<<< * * def __dealloc__(memoryview self): */ __pyx_v_self->typeinfo = NULL; - /* "View.MemoryView":345 + /* "View.MemoryView":349 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< @@ -5376,7 +6860,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ return __pyx_r; } -/* "View.MemoryView":372 +/* "View.MemoryView":376 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< @@ -5387,8 +6871,10 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ /* Python wrapper */ static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -5397,17 +6883,14 @@ static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { 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_5; PyThread_type_lock __pyx_t_6; - PyThread_type_lock __pyx_t_7; - __Pyx_RefNannySetupContext("__dealloc__", 0); - /* "View.MemoryView":373 + /* "View.MemoryView":377 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< @@ -5415,10 +6898,9 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal * 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) { + if (__pyx_t_1) { - /* "View.MemoryView":374 + /* "View.MemoryView":378 * def __dealloc__(memoryview self): * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< @@ -5427,7 +6909,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ __Pyx_ReleaseBuffer((&__pyx_v_self->view)); - /* "View.MemoryView":373 + /* "View.MemoryView":377 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< @@ -5437,17 +6919,17 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal goto __pyx_L3; } - /* "View.MemoryView":375 + /* "View.MemoryView":379 * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< * * (<__pyx_buffer *> &self.view).obj = NULL */ - __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); - if (__pyx_t_2) { + __pyx_t_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None); + if (__pyx_t_1) { - /* "View.MemoryView":377 + /* "View.MemoryView":381 * elif (<__pyx_buffer *> &self.view).obj == Py_None: * * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< @@ -5456,7 +6938,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; - /* "View.MemoryView":378 + /* "View.MemoryView":382 * * (<__pyx_buffer *> &self.view).obj = NULL * Py_DECREF(Py_None) # <<<<<<<<<<<<<< @@ -5465,7 +6947,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ Py_DECREF(Py_None); - /* "View.MemoryView":375 + /* "View.MemoryView":379 * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< @@ -5475,39 +6957,39 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal } __pyx_L3:; - /* "View.MemoryView":382 + /* "View.MemoryView":386 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: */ - __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_v_self->lock != NULL); + if (__pyx_t_1) { - /* "View.MemoryView":383 + /* "View.MemoryView":387 * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 */ - __pyx_t_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; + __pyx_t_2 = __pyx_memoryview_thread_locks_used; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":384 + /* "View.MemoryView":388 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: */ - __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); - if (__pyx_t_2) { + __pyx_t_1 = ((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock); + if (__pyx_t_1) { - /* "View.MemoryView":385 + /* "View.MemoryView":389 * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< @@ -5516,37 +6998,37 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); - /* "View.MemoryView":386 + /* "View.MemoryView":390 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) */ - __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used); + if (__pyx_t_1) { - /* "View.MemoryView":388 + /* "View.MemoryView":392 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< * break * else: */ - __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + __pyx_t_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - /* "View.MemoryView":387 + /* "View.MemoryView":391 * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) * break */ - (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; - (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_5; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6; - /* "View.MemoryView":386 + /* "View.MemoryView":390 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< @@ -5555,7 +7037,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ } - /* "View.MemoryView":389 + /* "View.MemoryView":393 * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) * break # <<<<<<<<<<<<<< @@ -5564,7 +7046,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ goto __pyx_L6_break; - /* "View.MemoryView":384 + /* "View.MemoryView":388 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< @@ -5575,7 +7057,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal } /*else*/ { - /* "View.MemoryView":391 + /* "View.MemoryView":395 * break * else: * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< @@ -5586,7 +7068,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal } __pyx_L6_break:; - /* "View.MemoryView":382 + /* "View.MemoryView":386 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< @@ -5595,7 +7077,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ } - /* "View.MemoryView":372 + /* "View.MemoryView":376 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< @@ -5604,10 +7086,9 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":393 +/* "View.MemoryView":397 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< @@ -5631,9 +7112,9 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_item_pointer", 0); + __Pyx_RefNannySetupContext("get_item_pointer", 1); - /* "View.MemoryView":395 + /* "View.MemoryView":399 * cdef char *get_item_pointer(memoryview self, object index) except NULL: * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< @@ -5642,7 +7123,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py */ __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); - /* "View.MemoryView":397 + /* "View.MemoryView":401 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< @@ -5651,29 +7132,42 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py */ __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_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, 397, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 397, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 401, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { - if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) 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, 397, __pyx_L1_error) + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error) #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 397, __pyx_L1_error) + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { - if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) 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, 397, __pyx_L1_error) + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error) #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 397, __pyx_L1_error) + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } @@ -5683,7 +7177,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 397, __pyx_L1_error) + else __PYX_ERR(1, 401, __pyx_L1_error) } break; } @@ -5694,18 +7188,18 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_v_dim = __pyx_t_1; __pyx_t_1 = (__pyx_t_1 + 1); - /* "View.MemoryView":398 + /* "View.MemoryView":402 * * for dim, idx in enumerate(index): * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< * * return itemp */ - __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 398, __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, 398, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 402, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 402, __pyx_L1_error) __pyx_v_itemp = __pyx_t_7; - /* "View.MemoryView":397 + /* "View.MemoryView":401 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< @@ -5715,7 +7209,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":400 + /* "View.MemoryView":404 * itemp = pybuffer_index(&self.view, itemp, idx, dim) * * return itemp # <<<<<<<<<<<<<< @@ -5725,7 +7219,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_r = __pyx_v_itemp; goto __pyx_L0; - /* "View.MemoryView":393 + /* "View.MemoryView":397 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< @@ -5745,7 +7239,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py return __pyx_r; } -/* "View.MemoryView":403 +/* "View.MemoryView":407 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< @@ -5756,9 +7250,11 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py /* Python wrapper */ static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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 */ @@ -5773,17 +7269,16 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - char *__pyx_t_6; + char *__pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 0); + __Pyx_RefNannySetupContext("__getitem__", 1); - /* "View.MemoryView":404 + /* "View.MemoryView":408 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< @@ -5791,10 +7286,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * */ __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "View.MemoryView":405 + /* "View.MemoryView":409 * def __getitem__(memoryview self, object index): * if index is Ellipsis: * return self # <<<<<<<<<<<<<< @@ -5802,11 +7296,11 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * have_slices, indices = _unellipsify(index, self.view.ndim) */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_INCREF((PyObject *)__pyx_v_self); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "View.MemoryView":404 + /* "View.MemoryView":408 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< @@ -5815,54 +7309,54 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ */ } - /* "View.MemoryView":407 + /* "View.MemoryView":411 * 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, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (likely(__pyx_t_3 != Py_None)) { - PyObject* sequence = __pyx_t_3; + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 407, __pyx_L1_error) + __PYX_ERR(1, 411, __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_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); - __Pyx_INCREF(__pyx_t_5); #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 407, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 407, __pyx_L1_error) + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 411, __pyx_L1_error) } - __pyx_v_have_slices = __pyx_t_4; + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_v_indices = __pyx_t_4; __pyx_t_4 = 0; - __pyx_v_indices = __pyx_t_5; - __pyx_t_5 = 0; - /* "View.MemoryView":410 + /* "View.MemoryView":414 * * 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, 410, __pyx_L1_error) - if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 414, __pyx_L1_error) + if (__pyx_t_1) { - /* "View.MemoryView":411 + /* "View.MemoryView":415 * cdef char *itemp * if have_slices: * return memview_slice(self, indices) # <<<<<<<<<<<<<< @@ -5870,13 +7364,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * 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, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":410 + /* "View.MemoryView":414 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< @@ -5885,7 +7379,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ */ } - /* "View.MemoryView":413 + /* "View.MemoryView":417 * return memview_slice(self, indices) * else: * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< @@ -5893,10 +7387,10 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * */ /*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, 413, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_6; + __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((char *)NULL))) __PYX_ERR(1, 417, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_5; - /* "View.MemoryView":414 + /* "View.MemoryView":418 * else: * itemp = self.get_item_pointer(indices) * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< @@ -5904,14 +7398,14 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * 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, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; goto __pyx_L0; } - /* "View.MemoryView":403 + /* "View.MemoryView":407 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< @@ -5921,9 +7415,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ /* 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.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -5934,20 +7428,22 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ return __pyx_r; } -/* "View.MemoryView":416 +/* "View.MemoryView":420 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") + * raise TypeError, "Cannot assign to read-only memoryview" */ /* Python wrapper */ static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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 */ @@ -5960,132 +7456,128 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit PyObject *__pyx_v_obj = NULL; int __pyx_r; __Pyx_RefNannyDeclarations - int __pyx_t_1; + PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); __Pyx_INCREF(__pyx_v_index); - /* "View.MemoryView":417 + /* "View.MemoryView":421 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError("Cannot assign to read-only memoryview") + * raise TypeError, "Cannot assign to read-only memoryview" * */ - __pyx_t_1 = (__pyx_v_self->view.readonly != 0); - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_v_self->view.readonly)) { - /* "View.MemoryView":418 + /* "View.MemoryView":422 * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * 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, 418, __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, 418, __pyx_L1_error) + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Cannot_assign_to_read_only_memor, 0, 0); + __PYX_ERR(1, 422, __pyx_L1_error) - /* "View.MemoryView":417 + /* "View.MemoryView":421 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError("Cannot assign to read-only memoryview") + * raise TypeError, "Cannot assign to read-only memoryview" * */ } - /* "View.MemoryView":420 - * raise TypeError("Cannot assign to read-only memoryview") + /* "View.MemoryView":424 + * raise TypeError, "Cannot assign to read-only memoryview" * * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * if have_slices: */ - __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (likely(__pyx_t_2 != Py_None)) { - PyObject* sequence = __pyx_t_2; + __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(__pyx_t_1 != Py_None)) { + PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 420, __pyx_L1_error) + __PYX_ERR(1, 424, __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_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 420, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); #endif - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 424, __pyx_L1_error) } - __pyx_v_have_slices = __pyx_t_3; + __pyx_v_have_slices = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); - __pyx_t_4 = 0; - /* "View.MemoryView":422 + /* "View.MemoryView":426 * 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, 422, __pyx_L1_error) - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 426, __pyx_L1_error) + if (__pyx_t_4) { - /* "View.MemoryView":423 + /* "View.MemoryView":427 * * 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, 423, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_v_obj = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_obj = __pyx_t_1; + __pyx_t_1 = 0; - /* "View.MemoryView":424 + /* "View.MemoryView":428 * 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, 424, __pyx_L1_error) - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 428, __pyx_L1_error) + if (__pyx_t_4) { - /* "View.MemoryView":425 + /* "View.MemoryView":429 * obj = self.is_slice(value) * if obj: * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< * else: * self.setitem_slice_assign_scalar(self[index], value) */ - __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __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, 425, __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; + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":424 + /* "View.MemoryView":428 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< @@ -6095,7 +7587,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit goto __pyx_L5; } - /* "View.MemoryView":427 + /* "View.MemoryView":431 * self.setitem_slice_assignment(self[index], obj) * else: * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< @@ -6103,17 +7595,17 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit * 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, 427, __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, 427, __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, 427, __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_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 431, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_L5:; - /* "View.MemoryView":422 + /* "View.MemoryView":426 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< @@ -6123,7 +7615,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit goto __pyx_L4; } - /* "View.MemoryView":429 + /* "View.MemoryView":433 * self.setitem_slice_assign_scalar(self[index], value) * else: * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< @@ -6131,27 +7623,27 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit * 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, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_L4:; - /* "View.MemoryView":416 + /* "View.MemoryView":420 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") + * raise TypeError, "Cannot assign to read-only memoryview" */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -6162,7 +7654,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit return __pyx_r; } -/* "View.MemoryView":431 +/* "View.MemoryView":435 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< @@ -6188,7 +7680,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_RefNannySetupContext("is_slice", 0); __Pyx_INCREF(__pyx_v_obj); - /* "View.MemoryView":432 + /* "View.MemoryView":436 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< @@ -6196,10 +7688,10 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ * 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); + __pyx_t_2 = (!__pyx_t_1); if (__pyx_t_2) { - /* "View.MemoryView":433 + /* "View.MemoryView":437 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< @@ -6215,51 +7707,51 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { - /* "View.MemoryView":434 + /* "View.MemoryView":438 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ - __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 434, __pyx_L4_error) + __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); - /* "View.MemoryView":435 + /* "View.MemoryView":439 * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) # <<<<<<<<<<<<<< * except TypeError: * return None */ - __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 435, __pyx_L4_error) + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 439, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); - /* "View.MemoryView":434 + /* "View.MemoryView":438 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 434, __pyx_L4_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 438, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_obj); __Pyx_GIVEREF(__pyx_v_obj); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj)) __PYX_ERR(1, 438, __pyx_L4_error); __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error); __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error); __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, 434, __pyx_L4_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); __pyx_t_7 = 0; - /* "View.MemoryView":433 + /* "View.MemoryView":437 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< @@ -6276,7 +7768,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "View.MemoryView":436 + /* "View.MemoryView":440 * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) * except TypeError: # <<<<<<<<<<<<<< @@ -6286,12 +7778,12 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __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, 436, __pyx_L6_except_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 440, __pyx_L6_except_error) + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); - /* "View.MemoryView":437 + /* "View.MemoryView":441 * self.dtype_is_object) * except TypeError: * return None # <<<<<<<<<<<<<< @@ -6306,15 +7798,15 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ goto __pyx_L7_except_return; } goto __pyx_L6_except_error; - __pyx_L6_except_error:; - /* "View.MemoryView":433 + /* "View.MemoryView":437 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ + __pyx_L6_except_error:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); @@ -6329,7 +7821,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_L9_try_end:; } - /* "View.MemoryView":432 + /* "View.MemoryView":436 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< @@ -6338,7 +7830,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ */ } - /* "View.MemoryView":439 + /* "View.MemoryView":443 * return None * * return obj # <<<<<<<<<<<<<< @@ -6350,7 +7842,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_r = __pyx_v_obj; goto __pyx_L0; - /* "View.MemoryView":431 + /* "View.MemoryView":435 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< @@ -6372,7 +7864,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ return __pyx_r; } -/* "View.MemoryView":441 +/* "View.MemoryView":445 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< @@ -6383,65 +7875,60 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { __Pyx_memviewslice __pyx_v_dst_slice; __Pyx_memviewslice __pyx_v_src_slice; + __Pyx_memviewslice __pyx_v_msrc; + __Pyx_memviewslice __pyx_v_mdst; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; - __Pyx_memviewslice *__pyx_t_2; - PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; 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); + __Pyx_RefNannySetupContext("setitem_slice_assignment", 1); - /* "View.MemoryView":445 + /* "View.MemoryView":448 + * cdef __Pyx_memviewslice dst_slice * cdef __Pyx_memviewslice src_slice + * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] * - * 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, 445, __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, 445, __pyx_L1_error) + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) + __pyx_v_msrc = (__pyx_t_1[0]); - /* "View.MemoryView":446 - * - * 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) + /* "View.MemoryView":449 + * cdef __Pyx_memviewslice src_slice + * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<< * + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) */ - if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 446, __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, 446, __pyx_L1_error) + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 449, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error) + __pyx_v_mdst = (__pyx_t_1[0]); - /* "View.MemoryView":447 - * 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) # <<<<<<<<<<<<<< + /* "View.MemoryView":451 + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] + * + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __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, 447, __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, 447, __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, 447, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 451, __pyx_L1_error) /* "View.MemoryView":445 - * 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, 445, __pyx_L1_error) - - /* "View.MemoryView":441 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< @@ -6453,7 +7940,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -6462,8 +7949,8 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi return __pyx_r; } -/* "View.MemoryView":449 - * src.ndim, dst.ndim, self.dtype_is_object) +/* "View.MemoryView":453 + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< * cdef int array[128] @@ -6493,9 +7980,9 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 1); - /* "View.MemoryView":451 + /* "View.MemoryView":455 * cdef setitem_slice_assign_scalar(self, memoryview dst, value): * cdef int array[128] * cdef void *tmp = NULL # <<<<<<<<<<<<<< @@ -6504,27 +7991,27 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_tmp = NULL; - /* "View.MemoryView":456 + /* "View.MemoryView":460 * cdef __Pyx_memviewslice *dst_slice * cdef __Pyx_memviewslice tmp_slice * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< * * if self.view.itemsize > sizeof(array): */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 456, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 460, __pyx_L1_error) __pyx_v_dst_slice = __pyx_t_1; - /* "View.MemoryView":458 + /* "View.MemoryView":462 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: */ - __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + __pyx_t_2 = (((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))); if (__pyx_t_2) { - /* "View.MemoryView":459 + /* "View.MemoryView":463 * * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< @@ -6533,26 +8020,26 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); - /* "View.MemoryView":460 + /* "View.MemoryView":464 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< * raise MemoryError * item = tmp */ - __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); + __pyx_t_2 = (__pyx_v_tmp == NULL); if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":461 + /* "View.MemoryView":465 * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: * raise MemoryError # <<<<<<<<<<<<<< * item = tmp * else: */ - PyErr_NoMemory(); __PYX_ERR(1, 461, __pyx_L1_error) + PyErr_NoMemory(); __PYX_ERR(1, 465, __pyx_L1_error) - /* "View.MemoryView":460 + /* "View.MemoryView":464 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< @@ -6561,7 +8048,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ } - /* "View.MemoryView":462 + /* "View.MemoryView":466 * if tmp == NULL: * raise MemoryError * item = tmp # <<<<<<<<<<<<<< @@ -6570,7 +8057,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_item = __pyx_v_tmp; - /* "View.MemoryView":458 + /* "View.MemoryView":462 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< @@ -6580,7 +8067,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor goto __pyx_L3; } - /* "View.MemoryView":464 + /* "View.MemoryView":468 * item = tmp * else: * item = array # <<<<<<<<<<<<<< @@ -6592,7 +8079,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor } __pyx_L3:; - /* "View.MemoryView":466 + /* "View.MemoryView":470 * item = array * * try: # <<<<<<<<<<<<<< @@ -6601,17 +8088,16 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ /*try:*/ { - /* "View.MemoryView":467 + /* "View.MemoryView":471 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ - __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_2) { + if (__pyx_v_self->dtype_is_object) { - /* "View.MemoryView":468 + /* "View.MemoryView":472 * try: * if self.dtype_is_object: * ( item)[0] = value # <<<<<<<<<<<<<< @@ -6620,7 +8106,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); - /* "View.MemoryView":467 + /* "View.MemoryView":471 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -6630,7 +8116,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor goto __pyx_L8; } - /* "View.MemoryView":470 + /* "View.MemoryView":474 * ( item)[0] = value * else: * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< @@ -6638,34 +8124,32 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor * */ /*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, 470, __pyx_L6_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 474, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L8:; - /* "View.MemoryView":474 + /* "View.MemoryView":478 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, */ - __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + __pyx_t_2 = (__pyx_v_self->view.suboffsets != NULL); if (__pyx_t_2) { - /* "View.MemoryView":475 + /* "View.MemoryView":479 * * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, * item, self.dtype_is_object) */ - __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 475, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 479, __pyx_L6_error) - /* "View.MemoryView":474 + /* "View.MemoryView":478 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -6674,7 +8158,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ } - /* "View.MemoryView":476 + /* "View.MemoryView":480 * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< @@ -6684,7 +8168,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __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":479 + /* "View.MemoryView":483 * item, self.dtype_is_object) * finally: * PyMem_Free(tmp) # <<<<<<<<<<<<<< @@ -6731,8 +8215,8 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_L7:; } - /* "View.MemoryView":449 - * src.ndim, dst.ndim, self.dtype_is_object) + /* "View.MemoryView":453 + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< * cdef int array[128] @@ -6752,7 +8236,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor return __pyx_r; } -/* "View.MemoryView":481 +/* "View.MemoryView":485 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< @@ -6769,30 +8253,30 @@ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_indexed", 0); + __Pyx_RefNannySetupContext("setitem_indexed", 1); - /* "View.MemoryView":482 + /* "View.MemoryView":486 * * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< * self.assign_item_from_object(itemp, value) * */ - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 482, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 486, __pyx_L1_error) __pyx_v_itemp = __pyx_t_1; - /* "View.MemoryView":483 + /* "View.MemoryView":487 * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 483, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":481 + /* "View.MemoryView":485 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< @@ -6813,7 +8297,7 @@ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *_ return __pyx_r; } -/* "View.MemoryView":485 +/* "View.MemoryView":489 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -6835,39 +8319,38 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview 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; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("convert_item_to_object", 0); + __Pyx_RefNannySetupContext("convert_item_to_object", 1); - /* "View.MemoryView":488 + /* "View.MemoryView":492 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef bytes bytesitem * */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L1_error) + __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; - /* "View.MemoryView":491 + /* "View.MemoryView":495 * cdef bytes bytesitem * * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< * try: * result = struct.unpack(self.view.format, bytesitem) */ - __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 491, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":492 + /* "View.MemoryView":496 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -6883,20 +8366,21 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { - /* "View.MemoryView":493 + /* "View.MemoryView":497 * bytesitem = itemp[:self.view.itemsize] * try: * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< * except struct.error: - * raise ValueError("Unable to convert item to object") + * 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, 493, __pyx_L3_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 497, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 493, __pyx_L3_error) + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -6906,45 +8390,20 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __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, 493, __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, 493, __pyx_L3_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_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, 493, __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, 493, __pyx_L3_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 497, __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_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_result = __pyx_t_1; __pyx_t_1 = 0; - /* "View.MemoryView":492 + /* "View.MemoryView":496 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -6953,19 +8412,19 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview */ } - /* "View.MemoryView":497 - * raise ValueError("Unable to convert item to object") + /* "View.MemoryView":501 + * raise ValueError, "Unable to convert item to object" * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] * return result */ /*else:*/ { - __pyx_t_10 = strlen(__pyx_v_self->view.format); - __pyx_t_11 = ((__pyx_t_10 == 1) != 0); - if (__pyx_t_11) { + __pyx_t_9 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 501, __pyx_L5_except_error) + __pyx_t_10 = (__pyx_t_9 == 1); + if (__pyx_t_10) { - /* "View.MemoryView":498 + /* "View.MemoryView":502 * else: * if len(self.view.format) == 1: * return result[0] # <<<<<<<<<<<<<< @@ -6973,14 +8432,14 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview * */ __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, 498, __pyx_L5_except_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 502, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6_except_return; - /* "View.MemoryView":497 - * raise ValueError("Unable to convert item to object") + /* "View.MemoryView":501 + * raise ValueError, "Unable to convert item to object" * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] @@ -6988,7 +8447,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview */ } - /* "View.MemoryView":499 + /* "View.MemoryView":503 * if len(self.view.format) == 1: * return result[0] * return result # <<<<<<<<<<<<<< @@ -7005,52 +8464,48 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __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":494 + /* "View.MemoryView":498 * try: * result = struct.unpack(self.view.format, bytesitem) * except struct.error: # <<<<<<<<<<<<<< - * raise ValueError("Unable to convert item to object") + * 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, 494, __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; + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 498, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; if (__pyx_t_8) { __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 494, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 498, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_1); - /* "View.MemoryView":495 + /* "View.MemoryView":499 * result = struct.unpack(self.view.format, bytesitem) * except struct.error: - * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * 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, 495, __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, 495, __pyx_L5_except_error) + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Unable_to_convert_item_to_object, 0, 0); + __PYX_ERR(1, 499, __pyx_L5_except_error) } goto __pyx_L5_except_error; - __pyx_L5_except_error:; - /* "View.MemoryView":492 + /* "View.MemoryView":496 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ + __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); @@ -7064,7 +8519,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview goto __pyx_L0; } - /* "View.MemoryView":485 + /* "View.MemoryView":489 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -7078,7 +8533,6 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __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:; @@ -7090,7 +8544,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview return __pyx_r; } -/* "View.MemoryView":501 +/* "View.MemoryView":505 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -7107,36 +8561,34 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; - Py_ssize_t __pyx_t_9; - PyObject *__pyx_t_10 = NULL; + char *__pyx_t_9; + char *__pyx_t_10; 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); + __Pyx_RefNannySetupContext("assign_item_from_object", 1); - /* "View.MemoryView":504 + /* "View.MemoryView":508 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef char c * cdef bytes bytesvalue */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 504, __pyx_L1_error) + __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; - /* "View.MemoryView":509 + /* "View.MemoryView":513 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< @@ -7144,40 +8596,39 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie * else: */ __pyx_t_2 = PyTuple_Check(__pyx_v_value); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { - /* "View.MemoryView":510 + /* "View.MemoryView":514 * * if isinstance(value, tuple): * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< * else: * bytesvalue = struct.pack(self.view.format, value) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 510, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 510, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 510, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_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, 510, __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, 510, __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, 510, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_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, 510, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 514, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; - /* "View.MemoryView":509 + /* "View.MemoryView":513 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< @@ -7187,7 +8638,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie goto __pyx_L3; } - /* "View.MemoryView":512 + /* "View.MemoryView":516 * bytesvalue = struct.pack(self.view.format, *value) * else: * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< @@ -7195,102 +8646,78 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie * 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, 512, __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, 512, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_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_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - __pyx_t_7 = 1; + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 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, 512, __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, 512, __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, 512, __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, 512, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_value}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __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; + if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 516, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; } __pyx_L3:; - /* "View.MemoryView":514 + /* "View.MemoryView":518 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ - __pyx_t_9 = 0; + __pyx_t_7 = 0; if (unlikely(__pyx_v_bytesvalue == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(1, 514, __pyx_L1_error) + __PYX_ERR(1, 518, __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]); + __pyx_t_8 = __pyx_v_bytesvalue; + __pyx_t_10 = PyBytes_AS_STRING(__pyx_t_8); + __pyx_t_11 = (__pyx_t_10 + PyBytes_GET_SIZE(__pyx_t_8)); + for (__pyx_t_12 = __pyx_t_10; __pyx_t_12 < __pyx_t_11; __pyx_t_12++) { + __pyx_t_9 = __pyx_t_12; + __pyx_v_c = (__pyx_t_9[0]); - /* "View.MemoryView":515 + /* "View.MemoryView":519 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< * * @cname('getbuffer') */ - __pyx_v_i = __pyx_t_9; + __pyx_v_i = __pyx_t_7; - /* "View.MemoryView":514 + /* "View.MemoryView":518 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ - __pyx_t_9 = (__pyx_t_9 + 1); + __pyx_t_7 = (__pyx_t_7 + 1); - /* "View.MemoryView":515 + /* "View.MemoryView":519 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< @@ -7299,9 +8726,9 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie */ (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; } - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "View.MemoryView":501 + /* "View.MemoryView":505 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -7314,11 +8741,10 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_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:; @@ -7329,20 +8755,22 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie return __pyx_r; } -/* "View.MemoryView":518 +/* "View.MemoryView":521 + * itemp[i] = c * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * @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) { +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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 */ @@ -7355,16 +8783,15 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __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; + Py_ssize_t *__pyx_t_3; + char *__pyx_t_4; + void *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - if (__pyx_v_info == NULL) { + if (unlikely(__pyx_v_info == NULL)) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } @@ -7372,11 +8799,11 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); - /* "View.MemoryView":519 + /* "View.MemoryView":523 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< - * raise ValueError("Cannot create writable memory view from read-only memoryview") + * raise ValueError, "Cannot create writable memory view from read-only memoryview" * */ __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); @@ -7385,35 +8812,31 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __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_t_1 = __pyx_v_self->view.readonly; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":520 + /* "View.MemoryView":524 * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: - * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * 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, 520, __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, 520, __pyx_L1_error) + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Cannot_create_writable_memory_vi, 0, 0); + __PYX_ERR(1, 524, __pyx_L1_error) - /* "View.MemoryView":519 + /* "View.MemoryView":523 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< - * raise ValueError("Cannot create writable memory view from read-only memoryview") + * raise ValueError, "Cannot create writable memory view from read-only memoryview" * */ } - /* "View.MemoryView":522 - * raise ValueError("Cannot create writable memory view from read-only memoryview") + /* "View.MemoryView":526 + * raise ValueError, "Cannot create writable memory view from read-only memoryview" * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< * info.shape = self.view.shape @@ -7422,18 +8845,18 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); if (__pyx_t_1) { - /* "View.MemoryView":523 + /* "View.MemoryView":527 * * 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; + __pyx_t_3 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_3; - /* "View.MemoryView":522 - * raise ValueError("Cannot create writable memory view from read-only memoryview") + /* "View.MemoryView":526 + * raise ValueError, "Cannot create writable memory view from read-only memoryview" * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< * info.shape = self.view.shape @@ -7442,7 +8865,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L6; } - /* "View.MemoryView":525 + /* "View.MemoryView":529 * info.shape = self.view.shape * else: * info.shape = NULL # <<<<<<<<<<<<<< @@ -7454,7 +8877,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L6:; - /* "View.MemoryView":527 + /* "View.MemoryView":531 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< @@ -7464,17 +8887,17 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); if (__pyx_t_1) { - /* "View.MemoryView":528 + /* "View.MemoryView":532 * * 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; + __pyx_t_3 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_3; - /* "View.MemoryView":527 + /* "View.MemoryView":531 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< @@ -7484,7 +8907,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L7; } - /* "View.MemoryView":530 + /* "View.MemoryView":534 * info.strides = self.view.strides * else: * info.strides = NULL # <<<<<<<<<<<<<< @@ -7496,7 +8919,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L7:; - /* "View.MemoryView":532 + /* "View.MemoryView":536 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< @@ -7506,17 +8929,17 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":533 + /* "View.MemoryView":537 * * 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; + __pyx_t_3 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_3; - /* "View.MemoryView":532 + /* "View.MemoryView":536 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< @@ -7526,7 +8949,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L8; } - /* "View.MemoryView":535 + /* "View.MemoryView":539 * info.suboffsets = self.view.suboffsets * else: * info.suboffsets = NULL # <<<<<<<<<<<<<< @@ -7538,7 +8961,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L8:; - /* "View.MemoryView":537 + /* "View.MemoryView":541 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -7548,17 +8971,17 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":538 + /* "View.MemoryView":542 * * 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; + __pyx_t_4 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_4; - /* "View.MemoryView":537 + /* "View.MemoryView":541 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -7568,7 +8991,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L9; } - /* "View.MemoryView":540 + /* "View.MemoryView":544 * info.format = self.view.format * else: * info.format = NULL # <<<<<<<<<<<<<< @@ -7580,47 +9003,47 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L9:; - /* "View.MemoryView":542 + /* "View.MemoryView":546 * 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; + __pyx_t_5 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_5; - /* "View.MemoryView":543 + /* "View.MemoryView":547 * * info.buf = self.view.buf * info.ndim = self.view.ndim # <<<<<<<<<<<<<< * info.itemsize = self.view.itemsize * info.len = self.view.len */ - __pyx_t_7 = __pyx_v_self->view.ndim; - __pyx_v_info->ndim = __pyx_t_7; + __pyx_t_6 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_6; - /* "View.MemoryView":544 + /* "View.MemoryView":548 * info.buf = self.view.buf * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< * info.len = self.view.len * info.readonly = self.view.readonly */ - __pyx_t_8 = __pyx_v_self->view.itemsize; - __pyx_v_info->itemsize = __pyx_t_8; + __pyx_t_7 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_7; - /* "View.MemoryView":545 + /* "View.MemoryView":549 * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize * info.len = self.view.len # <<<<<<<<<<<<<< * info.readonly = self.view.readonly * info.obj = self */ - __pyx_t_8 = __pyx_v_self->view.len; - __pyx_v_info->len = __pyx_t_8; + __pyx_t_7 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_7; - /* "View.MemoryView":546 + /* "View.MemoryView":550 * info.itemsize = self.view.itemsize * info.len = self.view.len * info.readonly = self.view.readonly # <<<<<<<<<<<<<< @@ -7630,32 +9053,31 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = __pyx_v_self->view.readonly; __pyx_v_info->readonly = __pyx_t_1; - /* "View.MemoryView":547 + /* "View.MemoryView":551 * 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_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":518 + /* "View.MemoryView":521 + * itemp[i] = c * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * @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) { @@ -7673,20 +9095,22 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu return __pyx_r; } -/* "View.MemoryView":553 +/* "View.MemoryView":554 * - * @property - * def T(self): # <<<<<<<<<<<<<< + * + * @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) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -7703,31 +9127,31 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":554 + /* "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, 554, __pyx_L1_error) + __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, 554, __pyx_L1_error) + 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":555 + /* "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, 555, __pyx_L1_error) + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 557, __pyx_L1_error) - /* "View.MemoryView":556 + /* "View.MemoryView":558 * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) * return result # <<<<<<<<<<<<<< @@ -7735,16 +9159,16 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ * @property */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __Pyx_INCREF((PyObject *)__pyx_v_result); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":553 + /* "View.MemoryView":554 * - * @property - * def T(self): # <<<<<<<<<<<<<< + * + * @property # <<<<<<<<<<<<<< + * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) */ /* function exit code */ @@ -7759,20 +9183,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ return __pyx_r; } -/* "View.MemoryView":559 - * - * @property - * def base(self): # <<<<<<<<<<<<<< - * return self.obj +/* "View.MemoryView":560 + * return result * + * @property # <<<<<<<<<<<<<< + * def base(self): + * return self._get_base() */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -7783,11 +9209,61 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyOb 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); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":560 + /* "View.MemoryView":562 * @property * def base(self): + * return self._get_base() # <<<<<<<<<<<<<< + * + * cdef _get_base(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":560 + * return result + * + * @property # <<<<<<<<<<<<<< + * def base(self): + * return self._get_base() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":564 + * return self._get_base() + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_get_base", 1); + + /* "View.MemoryView":565 + * + * cdef _get_base(self): * return self.obj # <<<<<<<<<<<<<< * * @property @@ -7797,10 +9273,10 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc __pyx_r = __pyx_v_self->obj; goto __pyx_L0; - /* "View.MemoryView":559 + /* "View.MemoryView":564 + * return self._get_base() * - * @property - * def base(self): # <<<<<<<<<<<<<< + * cdef _get_base(self): # <<<<<<<<<<<<<< * return self.obj * */ @@ -7812,20 +9288,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc return __pyx_r; } -/* "View.MemoryView":563 +/* "View.MemoryView":567 + * return self.obj * - * @property - * def shape(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -7834,7 +9312,7 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyO } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_length; + Py_ssize_t __pyx_7genexpr__pyx_v_length; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; @@ -7845,9 +9323,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":564 + /* "View.MemoryView":569 * @property * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -7855,30 +9333,32 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 564, __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, 564, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 564, __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, 564, __pyx_L1_error) + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_7genexpr__pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyInt_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 569, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "View.MemoryView":563 + /* "View.MemoryView":567 + * return self.obj * - * @property - * def shape(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * */ /* function exit code */ @@ -7893,20 +9373,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru return __pyx_r; } -/* "View.MemoryView":567 +/* "View.MemoryView":571 + * return tuple([length for length in self.view.shape[:self.view.ndim]]) * - * @property - * def strides(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def strides(self): * if self.view.strides == NULL: - * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -7915,7 +9397,7 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(P } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_8genexpr1__pyx_v_stride; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; @@ -7927,72 +9409,71 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":568 + /* "View.MemoryView":573 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< * - * raise ValueError("Buffer view does not expose strides") + * raise ValueError, "Buffer view does not expose strides" */ - __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); + __pyx_t_1 = (__pyx_v_self->view.strides == NULL); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":570 + /* "View.MemoryView":575 * if self.view.strides == NULL: * - * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * 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, 570, __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, 570, __pyx_L1_error) + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Buffer_view_does_not_expose_stri, 0, 0); + __PYX_ERR(1, 575, __pyx_L1_error) - /* "View.MemoryView":568 + /* "View.MemoryView":573 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< * - * raise ValueError("Buffer view does not expose strides") + * raise ValueError, "Buffer view does not expose strides" */ } - /* "View.MemoryView":572 - * raise ValueError("Buffer view does not expose strides") + /* "View.MemoryView":577 + * raise ValueError, "Buffer view does not expose strides" * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __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, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 572, __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, 572, __pyx_L1_error) + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_8genexpr1__pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 577, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "View.MemoryView":567 + /* "View.MemoryView":571 + * return tuple([length for length in self.view.shape[:self.view.ndim]]) * - * @property - * def strides(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def strides(self): * if self.view.strides == NULL: - * */ /* function exit code */ @@ -8007,20 +9488,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st return __pyx_r; } -/* "View.MemoryView":575 +/* "View.MemoryView":579 + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) * - * @property - * def suboffsets(self): # <<<<<<<<<<<<<< + * @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) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8029,31 +9512,31 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_suboffset; + Py_ssize_t __pyx_8genexpr2__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_3; Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; - Py_ssize_t *__pyx_t_6; + PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":576 + /* "View.MemoryView":581 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< * return (-1,) * self.view.ndim * */ - __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL); if (__pyx_t_1) { - /* "View.MemoryView":577 + /* "View.MemoryView":582 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< @@ -8061,16 +9544,13 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ * 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, 577, __pyx_L1_error) + __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_tuple__4, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 577, __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; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":576 + /* "View.MemoryView":581 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< @@ -8079,7 +9559,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ */ } - /* "View.MemoryView":579 + /* "View.MemoryView":584 * return (-1,) * self.view.ndim * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -8087,36 +9567,38 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __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, 579, __pyx_L1_error) + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 579, __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, 579, __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; + __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 584, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; goto __pyx_L0; - /* "View.MemoryView":575 + /* "View.MemoryView":579 + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) * - * @property - * def suboffsets(self): # <<<<<<<<<<<<<< + * @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_XDECREF(__pyx_t_6); __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -8125,20 +9607,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ return __pyx_r; } -/* "View.MemoryView":582 +/* "View.MemoryView":586 + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) * - * @property - * def ndim(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def ndim(self): * return self.view.ndim - * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8153,9 +9637,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":583 + /* "View.MemoryView":588 * @property * def ndim(self): * return self.view.ndim # <<<<<<<<<<<<<< @@ -8163,18 +9647,18 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc * @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, 583, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":582 + /* "View.MemoryView":586 + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) * - * @property - * def ndim(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def ndim(self): * return self.view.ndim - * */ /* function exit code */ @@ -8188,20 +9672,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc return __pyx_r; } -/* "View.MemoryView":586 +/* "View.MemoryView":590 + * return self.view.ndim * - * @property - * def itemsize(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def itemsize(self): * return self.view.itemsize - * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8216,9 +9702,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":587 + /* "View.MemoryView":592 * @property * def itemsize(self): * return self.view.itemsize # <<<<<<<<<<<<<< @@ -8226,18 +9712,18 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 587, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":586 + /* "View.MemoryView":590 + * return self.view.ndim * - * @property - * def itemsize(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def itemsize(self): * return self.view.itemsize - * */ /* function exit code */ @@ -8251,20 +9737,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s return __pyx_r; } -/* "View.MemoryView":590 +/* "View.MemoryView":594 + * return self.view.itemsize * - * @property - * def nbytes(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def nbytes(self): * return self.size * self.view.itemsize - * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8281,9 +9769,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":591 + /* "View.MemoryView":596 * @property * def nbytes(self): * return self.size * self.view.itemsize # <<<<<<<<<<<<<< @@ -8291,11 +9779,11 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str * @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, 591, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 591, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 591, __pyx_L1_error) + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -8303,12 +9791,12 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str __pyx_t_3 = 0; goto __pyx_L0; - /* "View.MemoryView":590 + /* "View.MemoryView":594 + * return self.view.itemsize * - * @property - * def nbytes(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def nbytes(self): * return self.size * self.view.itemsize - * */ /* function exit code */ @@ -8324,20 +9812,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str return __pyx_r; } -/* "View.MemoryView":594 +/* "View.MemoryView":598 + * return self.size * self.view.itemsize * - * @property - * def size(self): # <<<<<<<<<<<<<< + * @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) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8351,17 +9841,16 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + Py_ssize_t *__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; + PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); - /* "View.MemoryView":595 + /* "View.MemoryView":600 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< @@ -8369,10 +9858,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc * */ __pyx_t_1 = (__pyx_v_self->_size == Py_None); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + if (__pyx_t_1) { - /* "View.MemoryView":596 + /* "View.MemoryView":601 * def size(self): * if self._size is None: * result = 1 # <<<<<<<<<<<<<< @@ -8382,35 +9870,35 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __Pyx_INCREF(__pyx_int_1); __pyx_v_result = __pyx_int_1; - /* "View.MemoryView":598 + /* "View.MemoryView":603 * 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, 598, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_t_5 = PyInt_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5); + __pyx_t_5 = 0; - /* "View.MemoryView":599 + /* "View.MemoryView":604 * * 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, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5); + __pyx_t_5 = 0; } - /* "View.MemoryView":601 + /* "View.MemoryView":606 * result *= length * * self._size = result # <<<<<<<<<<<<<< @@ -8423,7 +9911,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __Pyx_DECREF(__pyx_v_self->_size); __pyx_v_self->_size = __pyx_v_result; - /* "View.MemoryView":595 + /* "View.MemoryView":600 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< @@ -8432,7 +9920,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc */ } - /* "View.MemoryView":603 + /* "View.MemoryView":608 * self._size = result * * return self._size # <<<<<<<<<<<<<< @@ -8444,17 +9932,17 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __pyx_r = __pyx_v_self->_size; goto __pyx_L0; - /* "View.MemoryView":594 + /* "View.MemoryView":598 + * return self.size * self.view.itemsize * - * @property - * def size(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def size(self): * if self._size is None: - * result = 1 */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -8465,7 +9953,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc return __pyx_r; } -/* "View.MemoryView":605 +/* "View.MemoryView":610 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< @@ -8476,9 +9964,11 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc /* Python wrapper */ static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8488,21 +9978,19 @@ static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { 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":606 + /* "View.MemoryView":611 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< * return self.view.shape[0] * */ - __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + __pyx_t_1 = (__pyx_v_self->view.ndim >= 1); if (__pyx_t_1) { - /* "View.MemoryView":607 + /* "View.MemoryView":612 * def __len__(self): * if self.view.ndim >= 1: * return self.view.shape[0] # <<<<<<<<<<<<<< @@ -8512,7 +10000,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_r = (__pyx_v_self->view.shape[0]); goto __pyx_L0; - /* "View.MemoryView":606 + /* "View.MemoryView":611 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< @@ -8521,7 +10009,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 */ } - /* "View.MemoryView":609 + /* "View.MemoryView":614 * return self.view.shape[0] * * return 0 # <<<<<<<<<<<<<< @@ -8531,7 +10019,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":605 + /* "View.MemoryView":610 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< @@ -8541,11 +10029,10 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 /* function exit code */ __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":611 +/* "View.MemoryView":616 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< @@ -8556,9 +10043,11 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 /* Python wrapper */ static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8575,9 +10064,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_RefNannySetupContext("__repr__", 1); - /* "View.MemoryView":612 + /* "View.MemoryView":617 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< @@ -8585,48 +10074,48 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 * */ __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, 612, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":613 + /* "View.MemoryView":618 * def __repr__(self): * return "" % (self.base.__class__.__name__, * id(self)) # <<<<<<<<<<<<<< * * def __str__(self): */ - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 613, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "View.MemoryView":612 + /* "View.MemoryView":617 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< * id(self)) * */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error); __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, 612, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":611 + /* "View.MemoryView":616 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< @@ -8647,7 +10136,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 return __pyx_r; } -/* "View.MemoryView":615 +/* "View.MemoryView":620 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< @@ -8658,9 +10147,11 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 /* Python wrapper */ static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8676,9 +10167,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_RefNannySetupContext("__str__", 1); - /* "View.MemoryView":616 + /* "View.MemoryView":621 * * def __str__(self): * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< @@ -8686,27 +10177,27 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 * */ __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, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 616, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error); __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, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":615 + /* "View.MemoryView":620 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< @@ -8726,7 +10217,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 return __pyx_r; } -/* "View.MemoryView":619 +/* "View.MemoryView":624 * * * def is_c_contig(self): # <<<<<<<<<<<<<< @@ -8735,11 +10226,38 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 */ /* 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) { +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("is_c_contig", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_c_contig", 0))) return NULL; __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8757,19 +10275,19 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_c_contig", 0); + __Pyx_RefNannySetupContext("is_c_contig", 1); - /* "View.MemoryView":622 + /* "View.MemoryView":627 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'C', self.view.ndim) * */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 622, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 627, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; - /* "View.MemoryView":623 + /* "View.MemoryView":628 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< @@ -8777,13 +10295,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 * 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, 623, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":619 + /* "View.MemoryView":624 * * * def is_c_contig(self): # <<<<<<<<<<<<<< @@ -8802,7 +10320,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 return __pyx_r; } -/* "View.MemoryView":625 +/* "View.MemoryView":630 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< @@ -8811,11 +10329,38 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 */ /* 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) { +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("is_f_contig", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_f_contig", 0))) return NULL; __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8833,19 +10378,19 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_f_contig", 0); + __Pyx_RefNannySetupContext("is_f_contig", 1); - /* "View.MemoryView":628 + /* "View.MemoryView":633 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'F', self.view.ndim) * */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 628, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 633, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; - /* "View.MemoryView":629 + /* "View.MemoryView":634 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< @@ -8853,13 +10398,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 * 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, 629, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 634, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":625 + /* "View.MemoryView":630 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< @@ -8878,7 +10423,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 return __pyx_r; } -/* "View.MemoryView":631 +/* "View.MemoryView":636 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< @@ -8887,11 +10432,38 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 */ /* 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) { +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy", 0))) return NULL; __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -8909,9 +10481,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("copy", 0); + __Pyx_RefNannySetupContext("copy", 1); - /* "View.MemoryView":633 + /* "View.MemoryView":638 * def copy(self): * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< @@ -8920,7 +10492,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); - /* "View.MemoryView":635 + /* "View.MemoryView":640 * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS * * slice_copy(self, &mslice) # <<<<<<<<<<<<<< @@ -8929,17 +10501,17 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); - /* "View.MemoryView":636 + /* "View.MemoryView":641 * * slice_copy(self, &mslice) * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_C_CONTIGUOUS, */ - __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 636, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 641, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; - /* "View.MemoryView":641 + /* "View.MemoryView":646 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< @@ -8947,13 +10519,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 * 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, 641, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":631 + /* "View.MemoryView":636 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< @@ -8972,7 +10544,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 return __pyx_r; } -/* "View.MemoryView":643 +/* "View.MemoryView":648 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< @@ -8981,11 +10553,38 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 */ /* 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) { +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("copy_fortran", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy_fortran", 0))) return NULL; __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ @@ -9004,9 +10603,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("copy_fortran", 0); + __Pyx_RefNannySetupContext("copy_fortran", 1); - /* "View.MemoryView":645 + /* "View.MemoryView":650 * def copy_fortran(self): * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< @@ -9015,7 +10614,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); - /* "View.MemoryView":647 + /* "View.MemoryView":652 * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS * * slice_copy(self, &src) # <<<<<<<<<<<<<< @@ -9024,17 +10623,17 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); - /* "View.MemoryView":648 + /* "View.MemoryView":653 * * slice_copy(self, &src) * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_F_CONTIGUOUS, */ - __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 648, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 653, __pyx_L1_error) __pyx_v_dst = __pyx_t_1; - /* "View.MemoryView":653 + /* "View.MemoryView":658 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< @@ -9042,13 +10641,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 * */ __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, 653, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":643 + /* "View.MemoryView":648 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< @@ -9069,17 +10668,44 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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) { +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); @@ -9089,33 +10715,28 @@ static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_ 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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * 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__") + * 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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); @@ -9125,20 +10746,102 @@ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struc /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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__") + * 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) { +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -9146,33 +10849,28 @@ static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_ 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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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__") # <<<<<<<<<<<<<< + * 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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__") + * 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); @@ -9180,7 +10878,7 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st return __pyx_r; } -/* "View.MemoryView":657 +/* "View.MemoryView":662 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< @@ -9198,37 +10896,37 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + __Pyx_RefNannySetupContext("memoryview_cwrapper", 1); - /* "View.MemoryView":658 + /* "View.MemoryView":663 * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< * result.typeinfo = typeinfo * return result */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 658, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 658, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_o); __Pyx_GIVEREF(__pyx_v_o); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o)) __PYX_ERR(1, 663, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error); __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, 658, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":659 + /* "View.MemoryView":664 * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo # <<<<<<<<<<<<<< @@ -9237,7 +10935,7 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in */ __pyx_v_result->typeinfo = __pyx_v_typeinfo; - /* "View.MemoryView":660 + /* "View.MemoryView":665 * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo * return result # <<<<<<<<<<<<<< @@ -9245,11 +10943,11 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in * @cname('__pyx_memoryview_check') */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __Pyx_INCREF((PyObject *)__pyx_v_result); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":657 + /* "View.MemoryView":662 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< @@ -9271,23 +10969,21 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in return __pyx_r; } -/* "View.MemoryView":663 +/* "View.MemoryView":668 * * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { int __pyx_r; - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("memoryview_check", 0); - /* "View.MemoryView":664 + /* "View.MemoryView":669 * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o): + * cdef inline bint memoryview_check(object o) noexcept: * return isinstance(o, memoryview) # <<<<<<<<<<<<<< * * cdef tuple _unellipsify(object index, int ndim): @@ -9296,21 +10992,20 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { __pyx_r = __pyx_t_1; goto __pyx_L0; - /* "View.MemoryView":663 + /* "View.MemoryView":668 * * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ /* function exit code */ __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":666 +/* "View.MemoryView":671 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< @@ -9319,429 +11014,355 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { */ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_idx; PyObject *__pyx_v_tup = NULL; PyObject *__pyx_v_result = NULL; int __pyx_v_have_slices; int __pyx_v_seen_ellipsis; - 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; + PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; - PyObject *(*__pyx_t_6)(PyObject *); + Py_UCS4 __pyx_t_6; 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); + __Pyx_RefNannySetupContext("_unellipsify", 1); - /* "View.MemoryView":671 - * full slices. + /* "View.MemoryView":677 * """ - * if not isinstance(index, tuple): # <<<<<<<<<<<<<< - * tup = (index,) - * else: + * cdef Py_ssize_t idx + * tup = index if isinstance(index, tuple) else (index,) # <<<<<<<<<<<<<< + * + * result = [slice(None)] * ndim */ - __pyx_t_1 = PyTuple_Check(__pyx_v_index); - __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + __pyx_t_2 = PyTuple_Check(__pyx_v_index); if (__pyx_t_2) { - - /* "View.MemoryView":672 - * """ - * if not isinstance(index, tuple): - * tup = (index,) # <<<<<<<<<<<<<< - * else: - * tup = index - */ - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 672, __pyx_L1_error) + __Pyx_INCREF(((PyObject*)__pyx_v_index)); + __pyx_t_1 = __pyx_v_index; + } else { + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); - __pyx_v_tup = __pyx_t_3; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index)) __PYX_ERR(1, 677, __pyx_L1_error); + __pyx_t_1 = __pyx_t_3; __pyx_t_3 = 0; - - /* "View.MemoryView":671 - * full slices. - * """ - * if not isinstance(index, tuple): # <<<<<<<<<<<<<< - * tup = (index,) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":674 - * tup = (index,) - * else: - * tup = index # <<<<<<<<<<<<<< - * - * result = [] - */ - /*else*/ { - __Pyx_INCREF(__pyx_v_index); - __pyx_v_tup = __pyx_v_index; } - __pyx_L3:; + __pyx_v_tup = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "View.MemoryView":676 - * tup = index + /* "View.MemoryView":679 + * tup = index if isinstance(index, tuple) else (index,) * - * result = [] # <<<<<<<<<<<<<< + * result = [slice(None)] * ndim # <<<<<<<<<<<<<< * have_slices = False * seen_ellipsis = False */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 676, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_result = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_1 = PyList_New(1 * ((__pyx_v_ndim<0) ? 0:__pyx_v_ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_ndim; __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__5); + __Pyx_GIVEREF(__pyx_slice__5); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, __pyx_temp, __pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error); + } + } + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "View.MemoryView":677 + /* "View.MemoryView":680 * - * result = [] + * result = [slice(None)] * ndim * have_slices = False # <<<<<<<<<<<<<< * seen_ellipsis = False - * for idx, item in enumerate(tup): + * idx = 0 */ __pyx_v_have_slices = 0; - /* "View.MemoryView":678 - * result = [] + /* "View.MemoryView":681 + * result = [slice(None)] * ndim * have_slices = False * seen_ellipsis = False # <<<<<<<<<<<<<< - * for idx, item in enumerate(tup): - * if item is Ellipsis: + * idx = 0 + * for item in tup: */ __pyx_v_seen_ellipsis = 0; - /* "View.MemoryView":679 + /* "View.MemoryView":682 * have_slices = False * seen_ellipsis = False - * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * idx = 0 # <<<<<<<<<<<<<< + * for item in tup: + * if item is Ellipsis: + */ + __pyx_v_idx = 0; + + /* "View.MemoryView":683 + * seen_ellipsis = False + * idx = 0 + * for item in tup: # <<<<<<<<<<<<<< * if item is Ellipsis: * if not seen_ellipsis: */ - __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, 679, __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, 679, __pyx_L1_error) + if (unlikely(__pyx_v_tup == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 683, __pyx_L1_error) } + __pyx_t_1 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; for (;;) { - if (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, 679, __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, 679, __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, 679, __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, 679, __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, 679, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_7); + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 683, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; } - __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, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); - __pyx_t_3 = __pyx_t_7; - __pyx_t_7 = 0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 683, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3); + __pyx_t_3 = 0; - /* "View.MemoryView":680 - * seen_ellipsis = False - * for idx, item in enumerate(tup): + /* "View.MemoryView":684 + * idx = 0 + * for item in tup: * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: - * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * idx += ndim - len(tup) */ __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { + if (__pyx_t_2) { - /* "View.MemoryView":681 - * for idx, item in enumerate(tup): + /* "View.MemoryView":685 + * for item in tup: * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * idx += ndim - len(tup) * seen_ellipsis = True */ - __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); - if (__pyx_t_1) { + __pyx_t_2 = (!__pyx_v_seen_ellipsis); + if (__pyx_t_2) { - /* "View.MemoryView":682 + /* "View.MemoryView":686 * if item is Ellipsis: * if not seen_ellipsis: - * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * idx += ndim - len(tup) # <<<<<<<<<<<<<< * seen_ellipsis = True - * else: + * have_slices = True */ - __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 682, __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, 682, __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); - } + if (unlikely(__pyx_v_tup == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 686, __pyx_L1_error) } - __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 682, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_tup); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 686, __pyx_L1_error) + __pyx_v_idx = (__pyx_v_idx + (__pyx_v_ndim - __pyx_t_5)); - /* "View.MemoryView":683 + /* "View.MemoryView":687 * if not seen_ellipsis: - * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * idx += ndim - len(tup) * seen_ellipsis = True # <<<<<<<<<<<<<< - * else: - * result.append(slice(None)) + * have_slices = True + * else: */ __pyx_v_seen_ellipsis = 1; - /* "View.MemoryView":681 - * for idx, item in enumerate(tup): + /* "View.MemoryView":685 + * for item in tup: * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * idx += ndim - len(tup) * seen_ellipsis = True */ - goto __pyx_L7; } - /* "View.MemoryView":685 + /* "View.MemoryView":688 + * idx += ndim - len(tup) * 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, 685, __pyx_L1_error) - } - __pyx_L7:; - - /* "View.MemoryView":686 - * else: - * result.append(slice(None)) * have_slices = True # <<<<<<<<<<<<<< * else: - * if not isinstance(item, slice) and not PyIndex_Check(item): + * if isinstance(item, slice): */ __pyx_v_have_slices = 1; - /* "View.MemoryView":680 - * seen_ellipsis = False - * for idx, item in enumerate(tup): + /* "View.MemoryView":684 + * idx = 0 + * for item in tup: * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: - * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * idx += ndim - len(tup) */ - goto __pyx_L6; + goto __pyx_L5; } - /* "View.MemoryView":688 + /* "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)) - * + * if isinstance(item, slice): # <<<<<<<<<<<<<< + * have_slices = True + * elif not PyIndex_Check(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)) { + if (__pyx_t_2) { - /* "View.MemoryView":689 + /* "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) + * if isinstance(item, slice): + * have_slices = True # <<<<<<<<<<<<<< + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" */ - __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, 689, __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, 689, __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, 689, __pyx_L1_error) + __pyx_v_have_slices = 1; - /* "View.MemoryView":688 + /* "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)) - * + * if isinstance(item, slice): # <<<<<<<<<<<<<< + * have_slices = True + * elif not PyIndex_Check(item): */ + goto __pyx_L7; } - /* "View.MemoryView":691 - * raise TypeError("Cannot index with type '%s'" % type(item)) - * - * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< - * result.append(item) - * + /* "View.MemoryView":692 + * if isinstance(item, slice): + * have_slices = True + * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item + */ + __pyx_t_2 = (!(PyIndex_Check(__pyx_v_item) != 0)); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":693 + * have_slices = True + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" # <<<<<<<<<<<<<< + * result[idx] = item + * idx += 1 + */ + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = 0; + __pyx_t_6 = 127; + __Pyx_INCREF(__pyx_kp_u_Cannot_index_with_type); + __pyx_t_5 += 24; + __Pyx_GIVEREF(__pyx_kp_u_Cannot_index_with_type); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Cannot_index_with_type); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; + __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u__6); + __pyx_t_5 += 1; + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__6); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_t_7, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(1, 693, __pyx_L1_error) + + /* "View.MemoryView":692 + * if isinstance(item, slice): + * have_slices = True + * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item */ - __pyx_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; + __pyx_L7:; - /* "View.MemoryView":692 + /* "View.MemoryView":694 + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item # <<<<<<<<<<<<<< + * idx += 1 * - * 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, 692, __pyx_L1_error) + if (unlikely((__Pyx_SetItemInt(__pyx_v_result, __pyx_v_idx, __pyx_v_item, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(1, 694, __pyx_L1_error) } - __pyx_L6:; + __pyx_L5:; - /* "View.MemoryView":679 - * have_slices = False + /* "View.MemoryView":695 + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item + * idx += 1 # <<<<<<<<<<<<<< + * + * nslices = ndim - idx + */ + __pyx_v_idx = (__pyx_v_idx + 1); + + /* "View.MemoryView":683 * seen_ellipsis = False - * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * idx = 0 + * for item in 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":694 - * 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, 694, __pyx_L1_error) - __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); - - /* "View.MemoryView":695 - * - * nslices = ndim - len(result) - * if nslices: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * nslices) - * - */ - __pyx_t_1 = (__pyx_v_nslices != 0); - if (__pyx_t_1) { + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":696 - * nslices = ndim - len(result) - * if nslices: - * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + /* "View.MemoryView":697 + * idx += 1 * + * nslices = ndim - idx # <<<<<<<<<<<<<< * 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, 696, __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, 696, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "View.MemoryView":695 - * - * nslices = ndim - len(result) - * if nslices: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * nslices) * */ - } + __pyx_v_nslices = (__pyx_v_ndim - __pyx_v_idx); /* "View.MemoryView":698 - * result.extend([slice(None)] * nslices) * + * nslices = ndim - idx * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: */ __Pyx_XDECREF(__pyx_r); if (!__pyx_v_have_slices) { } else { - __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __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_7 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L9_bool_binop_done; } - __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __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, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 698, __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_7 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_L9_bool_binop_done:; + __pyx_t_7 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 698, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_7 = 0; + __pyx_r = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_r = ((PyObject*)__pyx_t_11); - __pyx_t_11 = 0; goto __pyx_L0; - /* "View.MemoryView":666 + /* "View.MemoryView":671 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< @@ -9751,16 +11372,14 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __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(); @@ -9770,31 +11389,28 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { /* "View.MemoryView":700 * return have_slices or nslices, tuple(result) * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ -static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { +static int 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 + int __pyx_r; 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":701 * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< * if suboffset >= 0: - * raise ValueError("Indirect dimensions not supported") + * 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++) { @@ -9802,60 +11418,62 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ __pyx_v_suboffset = (__pyx_t_1[0]); /* "View.MemoryView":702 - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError("Indirect dimensions not supported") - * + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag */ - __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + __pyx_t_4 = (__pyx_v_suboffset >= 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":703 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: - * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< - * + * raise ValueError, "Indirect dimensions not supported" # <<<<<<<<<<<<<< + * return 0 # return type just used as an error flag * */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 703, __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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Indirect_dimensions_not_supporte, 0, 0); __PYX_ERR(1, 703, __pyx_L1_error) /* "View.MemoryView":702 - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError("Indirect dimensions not supported") - * + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag */ } } + /* "View.MemoryView":704 + * if suboffset >= 0: + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + /* "View.MemoryView":700 * return have_slices or nslices, tuple(result) * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ /* function exit code */ - __pyx_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_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":710 +/* "View.MemoryView":711 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< @@ -9876,6 +11494,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ Py_ssize_t __pyx_v_start; Py_ssize_t __pyx_v_stop; Py_ssize_t __pyx_v_step; + Py_ssize_t __pyx_v_cindex; int __pyx_v_have_start; int __pyx_v_have_stop; int __pyx_v_have_step; @@ -9883,23 +11502,22 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ 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; + PyObject *__pyx_t_2 = NULL; + struct __pyx_memoryview_obj *__pyx_t_3; + char *__pyx_t_4; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + Py_ssize_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memview_slice", 0); + __Pyx_RefNannySetupContext("memview_slice", 1); - /* "View.MemoryView":711 + /* "View.MemoryView":712 * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< @@ -9909,7 +11527,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_v_new_ndim = 0; __pyx_v_suboffset_dim = -1; - /* "View.MemoryView":718 + /* "View.MemoryView":719 * * * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< @@ -9918,7 +11536,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); - /* "View.MemoryView":722 + /* "View.MemoryView":723 * cdef _memoryviewslice memviewsliceobj * * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< @@ -9926,15 +11544,18 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ * 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, 722, __pyx_L1_error) + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (__pyx_v_memview->view.ndim > 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 723, __pyx_L1_error) } } + #else + if ((1)); else __PYX_ERR(1, 723, __pyx_L1_error) #endif - /* "View.MemoryView":724 + /* "View.MemoryView":725 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -9942,23 +11563,22 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ * 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) { + if (__pyx_t_1) { - /* "View.MemoryView":725 + /* "View.MemoryView":726 * * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview # <<<<<<<<<<<<<< * p_src = &memviewsliceobj.from_slice * else: */ - if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 725, __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; + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 726, __pyx_L1_error) + __pyx_t_2 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; - /* "View.MemoryView":726 + /* "View.MemoryView":727 * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< @@ -9967,7 +11587,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); - /* "View.MemoryView":724 + /* "View.MemoryView":725 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -9977,7 +11597,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L3; } - /* "View.MemoryView":728 + /* "View.MemoryView":729 * p_src = &memviewsliceobj.from_slice * else: * slice_copy(memview, &src) # <<<<<<<<<<<<<< @@ -9987,7 +11607,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); - /* "View.MemoryView":729 + /* "View.MemoryView":730 * else: * slice_copy(memview, &src) * p_src = &src # <<<<<<<<<<<<<< @@ -9998,146 +11618,159 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __pyx_L3:; - /* "View.MemoryView":735 + /* "View.MemoryView":736 * * * 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; + __pyx_t_3 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_3; - /* "View.MemoryView":736 + /* "View.MemoryView":737 * * 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; + __pyx_t_4 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_4; - /* "View.MemoryView":741 + /* "View.MemoryView":742 * * * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< * cdef int *p_suboffset_dim = &suboffset_dim - * cdef Py_ssize_t start, stop, step + * cdef Py_ssize_t start, stop, step, cindex */ __pyx_v_p_dst = (&__pyx_v_dst); - /* "View.MemoryView":742 + /* "View.MemoryView":743 * * cdef __Pyx_memviewslice *p_dst = &dst * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< - * cdef Py_ssize_t start, stop, step + * cdef Py_ssize_t start, stop, step, cindex * cdef bint have_start, have_stop, have_step */ __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); - /* "View.MemoryView":746 + /* "View.MemoryView":747 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): - * slice_memviewslice( + * cindex = index */ - __pyx_t_6 = 0; + __pyx_t_5 = 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; + __pyx_t_2 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; } else { - __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 746, __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, 746, __pyx_L1_error) + __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 747, __pyx_L1_error) } for (;;) { - if (likely(!__pyx_t_8)) { - if (likely(PyList_CheckExact(__pyx_t_3))) { - if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) 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, 746, __pyx_L1_error) + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) #else - __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 746, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); #endif } else { - if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) 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, 746, __pyx_L1_error) + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) #else - __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 746, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); #endif } } else { - __pyx_t_9 = __pyx_t_8(__pyx_t_3); - if (unlikely(!__pyx_t_9)) { + __pyx_t_8 = __pyx_t_7(__pyx_t_2); + if (unlikely(!__pyx_t_8)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 746, __pyx_L1_error) + else __PYX_ERR(1, 747, __pyx_L1_error) } break; } - __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_8); } - __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); + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_v_dim = __pyx_t_5; + __pyx_t_5 = (__pyx_t_5 + 1); - /* "View.MemoryView":747 + /* "View.MemoryView":748 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * cindex = index * slice_memviewslice( - * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], */ - __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); - if (__pyx_t_2) { + __pyx_t_1 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":751 + /* "View.MemoryView":749 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * cindex = index # <<<<<<<<<<<<<< + * slice_memviewslice( * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], - * 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, 751, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 749, __pyx_L1_error) + __pyx_v_cindex = __pyx_t_9; - /* "View.MemoryView":748 - * for dim, index in enumerate(indices): + /* "View.MemoryView":750 * if PyIndex_Check(index): + * cindex = index * slice_memviewslice( # <<<<<<<<<<<<<< * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, */ - __pyx_t_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, 748, __pyx_L1_error) + __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_cindex, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) - /* "View.MemoryView":747 + /* "View.MemoryView":748 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * cindex = index * slice_memviewslice( - * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], */ goto __pyx_L6; } - /* "View.MemoryView":754 + /* "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); + __pyx_t_1 = (__pyx_v_index == Py_None); if (__pyx_t_1) { - /* "View.MemoryView":755 + /* "View.MemoryView":757 * False) * elif index is None: * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< @@ -10146,7 +11779,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; - /* "View.MemoryView":756 + /* "View.MemoryView":758 * elif index is None: * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< @@ -10155,7 +11788,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; - /* "View.MemoryView":757 + /* "View.MemoryView":759 * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< @@ -10164,7 +11797,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; - /* "View.MemoryView":758 + /* "View.MemoryView":760 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 * new_ndim += 1 # <<<<<<<<<<<<<< @@ -10173,7 +11806,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - /* "View.MemoryView":754 + /* "View.MemoryView":756 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< @@ -10183,7 +11816,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L6; } - /* "View.MemoryView":760 + /* "View.MemoryView":762 * new_ndim += 1 * else: * start = index.start or 0 # <<<<<<<<<<<<<< @@ -10191,114 +11824,114 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ * 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, 760, __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, 760, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 762, __pyx_L1_error) if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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, 760, __pyx_L1_error) - __pyx_t_10 = __pyx_t_12; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L7_bool_binop_done; } - __pyx_t_10 = 0; + __pyx_t_9 = 0; __pyx_L7_bool_binop_done:; - __pyx_v_start = __pyx_t_10; + __pyx_v_start = __pyx_t_9; - /* "View.MemoryView":761 + /* "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, 761, __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, 761, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 763, __pyx_L1_error) if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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, 761, __pyx_L1_error) - __pyx_t_10 = __pyx_t_12; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L9_bool_binop_done; } - __pyx_t_10 = 0; + __pyx_t_9 = 0; __pyx_L9_bool_binop_done:; - __pyx_v_stop = __pyx_t_10; + __pyx_v_stop = __pyx_t_9; - /* "View.MemoryView":762 + /* "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, 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) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 764, __pyx_L1_error) if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L11_bool_binop_done; } - __pyx_t_10 = 0; + __pyx_t_9 = 0; __pyx_L11_bool_binop_done:; - __pyx_v_step = __pyx_t_10; + __pyx_v_step = __pyx_t_9; - /* "View.MemoryView":764 + /* "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, 764, __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_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_have_start = __pyx_t_1; - /* "View.MemoryView":765 + /* "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, 765, __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_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_have_stop = __pyx_t_1; - /* "View.MemoryView":766 + /* "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, 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_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_have_step = __pyx_t_1; - /* "View.MemoryView":768 + /* "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, 768, __pyx_L1_error) + __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) - /* "View.MemoryView":774 + /* "View.MemoryView":776 * have_start, have_stop, have_step, * True) * new_ndim += 1 # <<<<<<<<<<<<<< @@ -10309,17 +11942,17 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __pyx_L6:; - /* "View.MemoryView":746 + /* "View.MemoryView":747 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): - * slice_memviewslice( + * cindex = index */ } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":776 + /* "View.MemoryView":778 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -10327,51 +11960,50 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ * 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) { + if (__pyx_t_1) { - /* "View.MemoryView":777 + /* "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)); + __Pyx_XDECREF((PyObject *)__pyx_r); - /* "View.MemoryView":778 + /* "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, 778, __pyx_L1_error) } + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) } - /* "View.MemoryView":779 + /* "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, 779, __pyx_L1_error) } + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } - /* "View.MemoryView":777 + /* "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, 777, __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, 777, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":776 + /* "View.MemoryView":778 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -10380,7 +12012,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ } - /* "View.MemoryView":782 + /* "View.MemoryView":784 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< @@ -10388,32 +12020,32 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ * */ /*else*/ { - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); - /* "View.MemoryView":783 + /* "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, 782, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - /* "View.MemoryView":782 + /* "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, 782, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); - __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; goto __pyx_L0; } - /* "View.MemoryView":710 + /* "View.MemoryView":711 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< @@ -10423,8 +12055,8 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -10435,7 +12067,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ return __pyx_r; } -/* "View.MemoryView":807 +/* "View.MemoryView":793 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< @@ -10453,37 +12085,40 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save; + #endif - /* "View.MemoryView":827 + /* "View.MemoryView":813 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< * * if start < 0: */ - __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + __pyx_t_1 = (!__pyx_v_is_slice); if (__pyx_t_1) { - /* "View.MemoryView":829 + /* "View.MemoryView":815 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< * start += shape * if not 0 <= start < shape: */ - __pyx_t_1 = ((__pyx_v_start < 0) != 0); + __pyx_t_1 = (__pyx_v_start < 0); if (__pyx_t_1) { - /* "View.MemoryView":830 + /* "View.MemoryView":816 * * if start < 0: * start += shape # <<<<<<<<<<<<<< * if not 0 <= start < shape: - * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - /* "View.MemoryView":829 + /* "View.MemoryView":815 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< @@ -10492,39 +12127,39 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":831 + /* "View.MemoryView":817 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) * else: */ __pyx_t_1 = (0 <= __pyx_v_start); if (__pyx_t_1) { __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); } - __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + __pyx_t_2 = (!__pyx_t_1); if (__pyx_t_2) { - /* "View.MemoryView":832 + /* "View.MemoryView":818 * start += shape * if not 0 <= start < shape: - * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * _err_dim(PyExc_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, 832, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_kp_s_Index_out_of_bounds_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 818, __pyx_L1_error) - /* "View.MemoryView":831 + /* "View.MemoryView":817 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) * else: */ } - /* "View.MemoryView":827 + /* "View.MemoryView":813 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< @@ -10534,62 +12169,86 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L3; } - /* "View.MemoryView":835 + /* "View.MemoryView":821 * else: * - * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< - * - * if have_step and step == 0: + * if have_step: # <<<<<<<<<<<<<< + * negative_step = step < 0 + * if 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; + __pyx_t_2 = (__pyx_v_have_step != 0); + if (__pyx_t_2) { - /* "View.MemoryView":837 - * negative_step = have_step != 0 and step < 0 + /* "View.MemoryView":822 * - * if have_step and step == 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * if have_step: + * negative_step = step < 0 # <<<<<<<<<<<<<< + * if step == 0: + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + */ + __pyx_v_negative_step = (__pyx_v_step < 0); + + /* "View.MemoryView":823 + * if have_step: + * negative_step = step < 0 + * if step == 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + * else: + */ + __pyx_t_2 = (__pyx_v_step == 0); + if (__pyx_t_2) { + + /* "View.MemoryView":824 + * negative_step = step < 0 + * if step == 0: + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * negative_step = False + */ + __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 824, __pyx_L1_error) + + /* "View.MemoryView":823 + * if have_step: + * negative_step = step < 0 + * if step == 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":821 + * else: * + * if have_step: # <<<<<<<<<<<<<< + * negative_step = step < 0 + * if step == 0: */ - __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; + goto __pyx_L6; } - __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":838 - * - * if have_step and step == 0: - * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< - * + /* "View.MemoryView":826 + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + * else: + * negative_step = False # <<<<<<<<<<<<<< + * step = 1 * */ - __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, 838, __pyx_L1_error) + /*else*/ { + __pyx_v_negative_step = 0; - /* "View.MemoryView":837 - * negative_step = have_step != 0 and step < 0 + /* "View.MemoryView":827 + * else: + * negative_step = False + * step = 1 # <<<<<<<<<<<<<< * - * if have_step and step == 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) * */ + __pyx_v_step = 1; } + __pyx_L6:; - /* "View.MemoryView":841 + /* "View.MemoryView":830 * * * if have_start: # <<<<<<<<<<<<<< @@ -10599,17 +12258,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_have_start != 0); if (__pyx_t_2) { - /* "View.MemoryView":842 + /* "View.MemoryView":831 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ - __pyx_t_2 = ((__pyx_v_start < 0) != 0); + __pyx_t_2 = (__pyx_v_start < 0); if (__pyx_t_2) { - /* "View.MemoryView":843 + /* "View.MemoryView":832 * if have_start: * if start < 0: * start += shape # <<<<<<<<<<<<<< @@ -10618,17 +12277,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - /* "View.MemoryView":844 + /* "View.MemoryView":833 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< * start = 0 * elif start >= shape: */ - __pyx_t_2 = ((__pyx_v_start < 0) != 0); + __pyx_t_2 = (__pyx_v_start < 0); if (__pyx_t_2) { - /* "View.MemoryView":845 + /* "View.MemoryView":834 * start += shape * if start < 0: * start = 0 # <<<<<<<<<<<<<< @@ -10637,7 +12296,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = 0; - /* "View.MemoryView":844 + /* "View.MemoryView":833 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< @@ -10646,37 +12305,36 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":842 + /* "View.MemoryView":831 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ - goto __pyx_L12; + goto __pyx_L9; } - /* "View.MemoryView":846 + /* "View.MemoryView":835 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< * if negative_step: * start = shape - 1 */ - __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + __pyx_t_2 = (__pyx_v_start >= __pyx_v_shape); if (__pyx_t_2) { - /* "View.MemoryView":847 + /* "View.MemoryView":836 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ - __pyx_t_2 = (__pyx_v_negative_step != 0); - if (__pyx_t_2) { + if (__pyx_v_negative_step) { - /* "View.MemoryView":848 + /* "View.MemoryView":837 * elif start >= shape: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< @@ -10685,17 +12343,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_shape - 1); - /* "View.MemoryView":847 + /* "View.MemoryView":836 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ - goto __pyx_L14; + goto __pyx_L11; } - /* "View.MemoryView":850 + /* "View.MemoryView":839 * start = shape - 1 * else: * start = shape # <<<<<<<<<<<<<< @@ -10705,9 +12363,9 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, /*else*/ { __pyx_v_start = __pyx_v_shape; } - __pyx_L14:; + __pyx_L11:; - /* "View.MemoryView":846 + /* "View.MemoryView":835 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< @@ -10715,19 +12373,19 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, * start = shape - 1 */ } - __pyx_L12:; + __pyx_L9:; - /* "View.MemoryView":841 + /* "View.MemoryView":830 * * * if have_start: # <<<<<<<<<<<<<< * if start < 0: * start += shape */ - goto __pyx_L11; + goto __pyx_L8; } - /* "View.MemoryView":852 + /* "View.MemoryView":841 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -10735,10 +12393,9 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, * else: */ /*else*/ { - __pyx_t_2 = (__pyx_v_negative_step != 0); - if (__pyx_t_2) { + if (__pyx_v_negative_step) { - /* "View.MemoryView":853 + /* "View.MemoryView":842 * else: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< @@ -10747,17 +12404,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_shape - 1); - /* "View.MemoryView":852 + /* "View.MemoryView":841 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ - goto __pyx_L15; + goto __pyx_L12; } - /* "View.MemoryView":855 + /* "View.MemoryView":844 * start = shape - 1 * else: * start = 0 # <<<<<<<<<<<<<< @@ -10767,11 +12424,11 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, /*else*/ { __pyx_v_start = 0; } - __pyx_L15:; + __pyx_L12:; } - __pyx_L11:; + __pyx_L8:; - /* "View.MemoryView":857 + /* "View.MemoryView":846 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< @@ -10781,17 +12438,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_have_stop != 0); if (__pyx_t_2) { - /* "View.MemoryView":858 + /* "View.MemoryView":847 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ - __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + __pyx_t_2 = (__pyx_v_stop < 0); if (__pyx_t_2) { - /* "View.MemoryView":859 + /* "View.MemoryView":848 * if have_stop: * if stop < 0: * stop += shape # <<<<<<<<<<<<<< @@ -10800,17 +12457,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); - /* "View.MemoryView":860 + /* "View.MemoryView":849 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< * stop = 0 * elif stop > shape: */ - __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + __pyx_t_2 = (__pyx_v_stop < 0); if (__pyx_t_2) { - /* "View.MemoryView":861 + /* "View.MemoryView":850 * stop += shape * if stop < 0: * stop = 0 # <<<<<<<<<<<<<< @@ -10819,7 +12476,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = 0; - /* "View.MemoryView":860 + /* "View.MemoryView":849 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< @@ -10828,27 +12485,27 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":858 + /* "View.MemoryView":847 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ - goto __pyx_L17; + goto __pyx_L14; } - /* "View.MemoryView":862 + /* "View.MemoryView":851 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< * stop = shape * else: */ - __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + __pyx_t_2 = (__pyx_v_stop > __pyx_v_shape); if (__pyx_t_2) { - /* "View.MemoryView":863 + /* "View.MemoryView":852 * stop = 0 * elif stop > shape: * stop = shape # <<<<<<<<<<<<<< @@ -10857,7 +12514,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = __pyx_v_shape; - /* "View.MemoryView":862 + /* "View.MemoryView":851 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< @@ -10865,19 +12522,19 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, * else: */ } - __pyx_L17:; + __pyx_L14:; - /* "View.MemoryView":857 + /* "View.MemoryView":846 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< * if stop < 0: * stop += shape */ - goto __pyx_L16; + goto __pyx_L13; } - /* "View.MemoryView":865 + /* "View.MemoryView":854 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -10885,10 +12542,9 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, * else: */ /*else*/ { - __pyx_t_2 = (__pyx_v_negative_step != 0); - if (__pyx_t_2) { + if (__pyx_v_negative_step) { - /* "View.MemoryView":866 + /* "View.MemoryView":855 * else: * if negative_step: * stop = -1 # <<<<<<<<<<<<<< @@ -10897,59 +12553,31 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = -1L; - /* "View.MemoryView":865 + /* "View.MemoryView":854 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< * stop = -1 * else: */ - goto __pyx_L19; + goto __pyx_L16; } - /* "View.MemoryView":868 + /* "View.MemoryView":857 * stop = -1 * else: * stop = shape # <<<<<<<<<<<<<< * - * if not have_step: + * */ /*else*/ { __pyx_v_stop = __pyx_v_shape; } - __pyx_L19:; - } - __pyx_L16:; - - /* "View.MemoryView":870 - * stop = shape - * - * if not have_step: # <<<<<<<<<<<<<< - * step = 1 - * - */ - __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":871 - * - * if not have_step: - * step = 1 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_step = 1; - - /* "View.MemoryView":870 - * stop = shape - * - * if not have_step: # <<<<<<<<<<<<<< - * step = 1 - * - */ + __pyx_L16:; } + __pyx_L13:; - /* "View.MemoryView":875 + /* "View.MemoryView":861 * * with cython.cdivision(True): * new_shape = (stop - start) // step # <<<<<<<<<<<<<< @@ -10958,7 +12586,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); - /* "View.MemoryView":877 + /* "View.MemoryView":863 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< @@ -10968,7 +12596,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":878 + /* "View.MemoryView":864 * * if (stop - start) - step * new_shape: * new_shape += 1 # <<<<<<<<<<<<<< @@ -10977,7 +12605,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = (__pyx_v_new_shape + 1); - /* "View.MemoryView":877 + /* "View.MemoryView":863 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< @@ -10986,17 +12614,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":880 + /* "View.MemoryView":866 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< * new_shape = 0 * */ - __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + __pyx_t_2 = (__pyx_v_new_shape < 0); if (__pyx_t_2) { - /* "View.MemoryView":881 + /* "View.MemoryView":867 * * if new_shape < 0: * new_shape = 0 # <<<<<<<<<<<<<< @@ -11005,7 +12633,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = 0; - /* "View.MemoryView":880 + /* "View.MemoryView":866 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< @@ -11014,7 +12642,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":884 + /* "View.MemoryView":870 * * * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< @@ -11023,7 +12651,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); - /* "View.MemoryView":885 + /* "View.MemoryView":871 * * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< @@ -11032,7 +12660,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; - /* "View.MemoryView":886 + /* "View.MemoryView":872 * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< @@ -11043,17 +12671,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L3:; - /* "View.MemoryView":889 + /* "View.MemoryView":875 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ - __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + __pyx_t_2 = ((__pyx_v_suboffset_dim[0]) < 0); if (__pyx_t_2) { - /* "View.MemoryView":890 + /* "View.MemoryView":876 * * if suboffset_dim[0] < 0: * dst.data += start * stride # <<<<<<<<<<<<<< @@ -11062,17 +12690,17 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); - /* "View.MemoryView":889 + /* "View.MemoryView":875 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ - goto __pyx_L23; + goto __pyx_L19; } - /* "View.MemoryView":892 + /* "View.MemoryView":878 * dst.data += start * stride * else: * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< @@ -11083,88 +12711,88 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __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:; + __pyx_L19:; - /* "View.MemoryView":894 + /* "View.MemoryView":880 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< * if not is_slice: * if new_ndim == 0: */ - __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + __pyx_t_2 = (__pyx_v_suboffset >= 0); if (__pyx_t_2) { - /* "View.MemoryView":895 + /* "View.MemoryView":881 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ - __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + __pyx_t_2 = (!__pyx_v_is_slice); if (__pyx_t_2) { - /* "View.MemoryView":896 + /* "View.MemoryView":882 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< * dst.data = ( dst.data)[0] + suboffset * else: */ - __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); + __pyx_t_2 = (__pyx_v_new_ndim == 0); if (__pyx_t_2) { - /* "View.MemoryView":897 + /* "View.MemoryView":883 * if not is_slice: * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< * else: - * _err_dim(IndexError, "All dimensions preceding dimension %d " + * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " */ __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); - /* "View.MemoryView":896 + /* "View.MemoryView":882 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< * dst.data = ( dst.data)[0] + suboffset * else: */ - goto __pyx_L26; + goto __pyx_L22; } - /* "View.MemoryView":899 + /* "View.MemoryView":885 * dst.data = ( dst.data)[0] + suboffset * else: - * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< * "must be indexed and not sliced", dim) * else: */ /*else*/ { - /* "View.MemoryView":900 + /* "View.MemoryView":886 * else: - * _err_dim(IndexError, "All dimensions preceding dimension %d " + * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< * else: * suboffset_dim[0] = new_ndim */ - __pyx_t_3 = __pyx_memoryview_err_dim(__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, 899, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 885, __pyx_L1_error) } - __pyx_L26:; + __pyx_L22:; - /* "View.MemoryView":895 + /* "View.MemoryView":881 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ - goto __pyx_L25; + goto __pyx_L21; } - /* "View.MemoryView":902 + /* "View.MemoryView":888 * "must be indexed and not sliced", dim) * else: * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< @@ -11174,9 +12802,9 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, /*else*/ { (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; } - __pyx_L25:; + __pyx_L21:; - /* "View.MemoryView":894 + /* "View.MemoryView":880 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -11185,7 +12813,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":904 + /* "View.MemoryView":890 * suboffset_dim[0] = new_ndim * * return 0 # <<<<<<<<<<<<<< @@ -11195,7 +12823,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":807 + /* "View.MemoryView":793 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< @@ -11205,21 +12833,19 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, /* 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 - } + #ifdef WITH_THREAD + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif __pyx_L0:; return __pyx_r; } -/* "View.MemoryView":910 +/* "View.MemoryView":896 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< @@ -11238,13 +12864,14 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; + Py_UCS4 __pyx_t_4; + PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("pybuffer_index", 0); + __Pyx_RefNannySetupContext("pybuffer_index", 1); - /* "View.MemoryView":912 + /* "View.MemoryView":898 * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< @@ -11253,7 +12880,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_suboffset = -1L; - /* "View.MemoryView":913 + /* "View.MemoryView":899 * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< @@ -11263,53 +12890,53 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_1 = __pyx_v_view->itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":916 + /* "View.MemoryView":902 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len / itemsize + * shape = view.len // itemsize * stride = itemsize */ - __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + __pyx_t_2 = (__pyx_v_view->ndim == 0); if (__pyx_t_2) { - /* "View.MemoryView":917 + /* "View.MemoryView":903 * * if view.ndim == 0: - * shape = view.len / itemsize # <<<<<<<<<<<<<< + * 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, 917, __pyx_L1_error) + __PYX_ERR(1, 903, __pyx_L1_error) } - else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(1, 917, __pyx_L1_error) + __PYX_ERR(1, 903, __pyx_L1_error) } __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); - /* "View.MemoryView":918 + /* "View.MemoryView":904 * if view.ndim == 0: - * shape = view.len / itemsize + * shape = view.len // itemsize * stride = itemsize # <<<<<<<<<<<<<< * else: * shape = view.shape[dim] */ __pyx_v_stride = __pyx_v_itemsize; - /* "View.MemoryView":916 + /* "View.MemoryView":902 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len / itemsize + * shape = view.len // itemsize * stride = itemsize */ goto __pyx_L3; } - /* "View.MemoryView":920 + /* "View.MemoryView":906 * stride = itemsize * else: * shape = view.shape[dim] # <<<<<<<<<<<<<< @@ -11319,7 +12946,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P /*else*/ { __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); - /* "View.MemoryView":921 + /* "View.MemoryView":907 * else: * shape = view.shape[dim] * stride = view.strides[dim] # <<<<<<<<<<<<<< @@ -11328,17 +12955,17 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); - /* "View.MemoryView":922 + /* "View.MemoryView":908 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< * suboffset = view.suboffsets[dim] * */ - __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + __pyx_t_2 = (__pyx_v_view->suboffsets != NULL); if (__pyx_t_2) { - /* "View.MemoryView":923 + /* "View.MemoryView":909 * stride = view.strides[dim] * if view.suboffsets != NULL: * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< @@ -11347,7 +12974,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); - /* "View.MemoryView":922 + /* "View.MemoryView":908 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -11358,64 +12985,77 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P } __pyx_L3:; - /* "View.MemoryView":925 + /* "View.MemoryView":911 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< * index += view.shape[dim] * if index < 0: */ - __pyx_t_2 = ((__pyx_v_index < 0) != 0); + __pyx_t_2 = (__pyx_v_index < 0); if (__pyx_t_2) { - /* "View.MemoryView":926 + /* "View.MemoryView":912 * * if index < 0: * index += view.shape[dim] # <<<<<<<<<<<<<< * if index < 0: - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" */ __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); - /* "View.MemoryView":927 + /* "View.MemoryView":913 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ - __pyx_t_2 = ((__pyx_v_index < 0) != 0); + __pyx_t_2 = (__pyx_v_index < 0); if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":928 + /* "View.MemoryView":914 * index += view.shape[dim] * if index < 0: - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< * * if index >= shape: */ - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 928, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_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, 928, __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, 928, __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_t_1 = 0; + __pyx_t_4 = 127; + __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); + __pyx_t_1 += 37; + __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); + __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_kp_u__7); + __pyx_t_1 += 1; + __Pyx_GIVEREF(__pyx_kp_u__7); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__7); + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 928, __pyx_L1_error) + __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_5, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 914, __pyx_L1_error) - /* "View.MemoryView":927 + /* "View.MemoryView":913 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ } - /* "View.MemoryView":925 + /* "View.MemoryView":911 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< @@ -11424,46 +13064,59 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":930 - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + /* "View.MemoryView":916 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ - __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + __pyx_t_2 = (__pyx_v_index >= __pyx_v_shape); if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":931 + /* "View.MemoryView":917 * * if index >= shape: - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< * * resultp = bufp + index * stride */ - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 931, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = 0; + __pyx_t_4 = 127; + __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); + __pyx_t_1 += 37; + __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); + __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_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, 931, __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, 931, __pyx_L1_error) + __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_kp_u__7); + __pyx_t_1 += 1; + __Pyx_GIVEREF(__pyx_kp_u__7); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u__7); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_5, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_3, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 931, __pyx_L1_error) + __PYX_ERR(1, 917, __pyx_L1_error) - /* "View.MemoryView":930 - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + /* "View.MemoryView":916 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ } - /* "View.MemoryView":933 - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + /* "View.MemoryView":919 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * * resultp = bufp + index * stride # <<<<<<<<<<<<<< * if suboffset >= 0: @@ -11471,17 +13124,17 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); - /* "View.MemoryView":934 + /* "View.MemoryView":920 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< * resultp = ( resultp)[0] + suboffset * */ - __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + __pyx_t_2 = (__pyx_v_suboffset >= 0); if (__pyx_t_2) { - /* "View.MemoryView":935 + /* "View.MemoryView":921 * resultp = bufp + index * stride * if suboffset >= 0: * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< @@ -11490,7 +13143,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); - /* "View.MemoryView":934 + /* "View.MemoryView":920 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -11499,7 +13152,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":937 + /* "View.MemoryView":923 * resultp = ( resultp)[0] + suboffset * * return resultp # <<<<<<<<<<<<<< @@ -11509,7 +13162,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_r = __pyx_v_resultp; goto __pyx_L0; - /* "View.MemoryView":910 + /* "View.MemoryView":896 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< @@ -11520,7 +13173,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P /* 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.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -11528,10 +13181,10 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P return __pyx_r; } -/* "View.MemoryView":943 +/* "View.MemoryView":929 * * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< * cdef int ndim = memslice.memview.view.ndim * */ @@ -11555,10 +13208,13 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save; + #endif - /* "View.MemoryView":944 + /* "View.MemoryView":930 * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< * * cdef Py_ssize_t *shape = memslice.shape @@ -11566,7 +13222,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; __pyx_v_ndim = __pyx_t_1; - /* "View.MemoryView":946 + /* "View.MemoryView":932 * cdef int ndim = memslice.memview.view.ndim * * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< @@ -11576,7 +13232,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_2 = __pyx_v_memslice->shape; __pyx_v_shape = __pyx_t_2; - /* "View.MemoryView":947 + /* "View.MemoryView":933 * * cdef Py_ssize_t *shape = memslice.shape * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< @@ -11586,10 +13242,10 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_2 = __pyx_v_memslice->strides; __pyx_v_strides = __pyx_t_2; - /* "View.MemoryView":951 + /* "View.MemoryView":937 * * cdef int i, j - * for i in range(ndim / 2): # <<<<<<<<<<<<<< + * for i in range(ndim // 2): # <<<<<<<<<<<<<< * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] */ @@ -11598,17 +13254,17 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":952 + /* "View.MemoryView":938 * cdef int i, j - * for i in range(ndim / 2): + * 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":953 - * for i in range(ndim / 2): + /* "View.MemoryView":939 + * for i in range(ndim // 2): * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< * shape[i], shape[j] = shape[j], shape[i] @@ -11619,7 +13275,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; - /* "View.MemoryView":954 + /* "View.MemoryView":940 * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< @@ -11631,90 +13287,90 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; - /* "View.MemoryView":956 + /* "View.MemoryView":942 * 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") + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") * */ - __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); + __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0); if (!__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L6_bool_binop_done; } - __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); + __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0); __pyx_t_7 = __pyx_t_8; __pyx_L6_bool_binop_done:; if (__pyx_t_7) { - /* "View.MemoryView":957 + /* "View.MemoryView":943 * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: - * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< * - * return 1 + * return 0 */ - __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, 957, __pyx_L1_error) + __pyx_t_9 = __pyx_memoryview_err(PyExc_ValueError, __pyx_kp_s_Cannot_transpose_memoryview_with); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L1_error) - /* "View.MemoryView":956 + /* "View.MemoryView":942 * 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") + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") * */ } } - /* "View.MemoryView":959 - * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + /* "View.MemoryView":945 + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") * - * return 1 # <<<<<<<<<<<<<< + * return 0 # <<<<<<<<<<<<<< * * */ - __pyx_r = 1; + __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":943 + /* "View.MemoryView":929 * * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< * cdef int ndim = memslice.memview.view.ndim * */ /* function exit code */ __pyx_L1_error:; - { - #ifdef WITH_THREAD - 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; + #ifdef WITH_THREAD + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif __pyx_L0:; return __pyx_r; } -/* "View.MemoryView":976 +/* "View.MemoryView":963 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) * */ /* Python wrapper */ static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ @@ -11722,32 +13378,29 @@ static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { } 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":977 + /* "View.MemoryView":964 * * def __dealloc__(self): - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ - __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + __PYX_XCLEAR_MEMVIEW((&__pyx_v_self->from_slice), 1); - /* "View.MemoryView":976 + /* "View.MemoryView":963 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) * */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":979 - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) +/* "View.MemoryView":966 + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * if self.to_object_func != NULL: @@ -11762,19 +13415,19 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("convert_item_to_object", 0); + __Pyx_RefNannySetupContext("convert_item_to_object", 1); - /* "View.MemoryView":980 + /* "View.MemoryView":967 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< * return self.to_object_func(itemp) * else: */ - __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); + __pyx_t_1 = (__pyx_v_self->to_object_func != NULL); if (__pyx_t_1) { - /* "View.MemoryView":981 + /* "View.MemoryView":968 * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: * return self.to_object_func(itemp) # <<<<<<<<<<<<<< @@ -11782,13 +13435,13 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor * 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, 981, __pyx_L1_error) + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 968, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":980 + /* "View.MemoryView":967 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< @@ -11797,7 +13450,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor */ } - /* "View.MemoryView":983 + /* "View.MemoryView":970 * return self.to_object_func(itemp) * else: * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< @@ -11806,15 +13459,15 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor */ /*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, 983, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 970, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } - /* "View.MemoryView":979 - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + /* "View.MemoryView":966 + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * if self.to_object_func != NULL: @@ -11832,7 +13485,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor return __pyx_r; } -/* "View.MemoryView":985 +/* "View.MemoryView":972 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -11849,28 +13502,28 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("assign_item_from_object", 0); + __Pyx_RefNannySetupContext("assign_item_from_object", 1); - /* "View.MemoryView":986 + /* "View.MemoryView":973 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< * self.to_dtype_func(itemp, value) * else: */ - __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); + __pyx_t_1 = (__pyx_v_self->to_dtype_func != NULL); if (__pyx_t_1) { - /* "View.MemoryView":987 + /* "View.MemoryView":974 * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< * else: * memoryview.assign_item_from_object(self, itemp, value) */ - __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 987, __pyx_L1_error) + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 974, __pyx_L1_error) - /* "View.MemoryView":986 + /* "View.MemoryView":973 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< @@ -11880,21 +13533,21 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo goto __pyx_L3; } - /* "View.MemoryView":989 + /* "View.MemoryView":976 * self.to_dtype_func(itemp, value) * else: * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< * - * @property + * cdef _get_base(self): */ /*else*/ { - __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 989, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; - /* "View.MemoryView":985 + /* "View.MemoryView":972 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -11915,48 +13568,35 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo return __pyx_r; } -/* "View.MemoryView":992 +/* "View.MemoryView":978 + * memoryview.assign_item_from_object(self, itemp, value) * - * @property - * def base(self): # <<<<<<<<<<<<<< + * cdef _get_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) { +static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("_get_base", 1); - /* "View.MemoryView":993 - * @property - * def base(self): + /* "View.MemoryView":979 + * + * cdef _get_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":992 + /* "View.MemoryView":978 + * memoryview.assign_item_from_object(self, itemp, value) * - * @property - * def base(self): # <<<<<<<<<<<<<< + * cdef _get_base(self): # <<<<<<<<<<<<<< * return self.from_object * */ @@ -11970,16 +13610,43 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__ /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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) { +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ @@ -11990,33 +13657,28 @@ static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__p 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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * 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__") + * 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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); @@ -12026,20 +13688,102 @@ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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__") + * 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) { +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -12047,33 +13791,28 @@ static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *_ 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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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__") # <<<<<<<<<<<<<< + * 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * 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__") + * 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); @@ -12107,7 +13846,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + __Pyx_RefNannySetupContext("memoryview_fromslice", 1); /* "View.MemoryView":1007 * cdef _memoryviewslice result @@ -12116,7 +13855,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl * return None * */ - __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + __pyx_t_1 = (((PyObject *)__pyx_v_memviewslice.memview) == Py_None); if (__pyx_t_1) { /* "View.MemoryView":1008 @@ -12142,7 +13881,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl /* "View.MemoryView":1013 * * - * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) # <<<<<<<<<<<<<< * * result.from_slice = memviewslice */ @@ -12152,21 +13891,21 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None)) __PYX_ERR(1, 1013, __pyx_L1_error); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0)) __PYX_ERR(1, 1013, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error); __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, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_2 = ((PyObject *)__pyx_tp_new__memoryviewslice(((PyTypeObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":1015 - * result = _memoryviewslice(None, 0, dtype_is_object) + * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) * * result.from_slice = memviewslice # <<<<<<<<<<<<<< * __PYX_INC_MEMVIEW(&memviewslice, 1) @@ -12179,18 +13918,18 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl * result.from_slice = memviewslice * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< * - * result.from_object = ( memviewslice.memview).base + * result.from_object = ( memviewslice.memview)._get_base() */ __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); /* "View.MemoryView":1018 * __PYX_INC_MEMVIEW(&memviewslice, 1) * - * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< + * result.from_object = ( memviewslice.memview)._get_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, 1018, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->__pyx_vtab)->_get_base(((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_result->from_object); @@ -12200,7 +13939,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl /* "View.MemoryView":1019 * - * result.from_object = ( memviewslice.memview).base + * result.from_object = ( memviewslice.memview)._get_base() * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< * * result.view = memviewslice.memview.view @@ -12341,7 +14080,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl * result.view.suboffsets = result.from_slice.suboffsets * break */ - __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); + __pyx_t_1 = (__pyx_v_suboffset >= 0); if (__pyx_t_1) { /* "View.MemoryView":1039 @@ -12441,7 +14180,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl * @cname('__pyx_memoryview_get_slice_from_memoryview') */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __Pyx_INCREF((PyObject *)__pyx_v_result); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; @@ -12480,12 +14219,11 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p __Pyx_memviewslice *__pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + __Pyx_RefNannySetupContext("get_slice_from_memview", 1); /* "View.MemoryView":1055 * __Pyx_memviewslice *mslice) except NULL: @@ -12495,8 +14233,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p * 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) { + if (__pyx_t_1) { /* "View.MemoryView":1056 * cdef _memoryviewslice obj @@ -12506,10 +14243,10 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p * else: */ if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1056, __pyx_L1_error) - __pyx_t_3 = ((PyObject *)__pyx_v_memview); - __Pyx_INCREF(__pyx_t_3); - __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_2 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; /* "View.MemoryView":1057 * if isinstance(memview, _memoryviewslice): @@ -12561,7 +14298,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -12573,7 +14310,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p /* "View.MemoryView":1063 * * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< * cdef int dim * cdef (Py_ssize_t*) shape, strides, suboffsets */ @@ -12583,13 +14320,12 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem 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); + int __pyx_t_6; /* "View.MemoryView":1067 * cdef (Py_ssize_t*) shape, strides, suboffsets @@ -12676,7 +14412,8 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem * * @cname('__pyx_memoryview_copy_object') */ - if ((__pyx_v_suboffsets != 0)) { + __pyx_t_6 = (__pyx_v_suboffsets != 0); + if (__pyx_t_6) { __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); } else { __pyx_t_5 = -1L; @@ -12687,13 +14424,12 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem /* "View.MemoryView":1063 * * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< * cdef int dim * cdef (Py_ssize_t*) shape, strides, suboffsets */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":1080 @@ -12712,7 +14448,7 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_copy", 0); + __Pyx_RefNannySetupContext("memoryview_copy", 1); /* "View.MemoryView":1083 * "Create a new memoryview object" @@ -12770,14 +14506,13 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview 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; + PyObject *(*__pyx_t_2)(char *); + int (*__pyx_t_3)(char *, PyObject *); + PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 1); /* "View.MemoryView":1094 * cdef int (*to_dtype_func)(char *, object) except 0 @@ -12787,8 +14522,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview * 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) { + if (__pyx_t_1) { /* "View.MemoryView":1095 * @@ -12797,8 +14531,8 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview * 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; + __pyx_t_2 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_2; /* "View.MemoryView":1096 * if isinstance(memview, _memoryviewslice): @@ -12807,8 +14541,8 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview * 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; + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_3; /* "View.MemoryView":1094 * cdef int (*to_dtype_func)(char *, object) except 0 @@ -12857,10 +14591,10 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview * * */ - __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, 1101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_t_4 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; /* "View.MemoryView":1087 @@ -12873,7 +14607,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -12885,62 +14619,38 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview /* "View.MemoryView":1109 * * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< - * if arg < 0: - * return -arg + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< + * return -arg if arg < 0 else arg + * */ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { Py_ssize_t __pyx_r; - int __pyx_t_1; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; /* "View.MemoryView":1110 * - * 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":1111 - * 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":1110 - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: - * if arg < 0: # <<<<<<<<<<<<<< - * return -arg - * else: - */ - } - - /* "View.MemoryView":1113 - * return -arg - * else: - * return arg # <<<<<<<<<<<<<< + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: + * return -arg if arg < 0 else arg # <<<<<<<<<<<<<< * * @cname('__pyx_get_best_slice_order') */ - /*else*/ { - __pyx_r = __pyx_v_arg; - goto __pyx_L0; + __pyx_t_2 = (__pyx_v_arg < 0); + if (__pyx_t_2) { + __pyx_t_1 = (-__pyx_v_arg); + } else { + __pyx_t_1 = __pyx_v_arg; } + __pyx_r = __pyx_t_1; + goto __pyx_L0; /* "View.MemoryView":1109 * * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< - * if arg < 0: - * return -arg + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< + * return -arg if arg < 0 else arg + * */ /* function exit code */ @@ -12948,10 +14658,10 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { return __pyx_r; } -/* "View.MemoryView":1116 +/* "View.MemoryView":1113 * * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<< * """ * Figure out the best memory access order for a given slice. */ @@ -12966,7 +14676,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ int __pyx_t_3; int __pyx_t_4; - /* "View.MemoryView":1121 + /* "View.MemoryView":1118 * """ * cdef int i * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< @@ -12975,7 +14685,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_c_stride = 0; - /* "View.MemoryView":1122 + /* "View.MemoryView":1119 * cdef int i * cdef Py_ssize_t c_stride = 0 * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< @@ -12984,7 +14694,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_f_stride = 0; - /* "View.MemoryView":1124 + /* "View.MemoryView":1121 * cdef Py_ssize_t f_stride = 0 * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -12994,17 +14704,17 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":1125 + /* "View.MemoryView":1122 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * c_stride = mslice.strides[i] * break */ - __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); if (__pyx_t_2) { - /* "View.MemoryView":1126 + /* "View.MemoryView":1123 * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< @@ -13013,7 +14723,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1127 + /* "View.MemoryView":1124 * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< @@ -13022,7 +14732,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ goto __pyx_L4_break; - /* "View.MemoryView":1125 + /* "View.MemoryView":1122 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -13033,7 +14743,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ } __pyx_L4_break:; - /* "View.MemoryView":1129 + /* "View.MemoryView":1126 * break * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -13045,17 +14755,17 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1130 + /* "View.MemoryView":1127 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * f_stride = mslice.strides[i] * break */ - __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); if (__pyx_t_2) { - /* "View.MemoryView":1131 + /* "View.MemoryView":1128 * for i in range(ndim): * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< @@ -13064,7 +14774,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1132 + /* "View.MemoryView":1129 * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< @@ -13073,7 +14783,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ goto __pyx_L7_break; - /* "View.MemoryView":1130 + /* "View.MemoryView":1127 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -13084,17 +14794,17 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ } __pyx_L7_break:; - /* "View.MemoryView":1134 + /* "View.MemoryView":1131 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< * return 'C' * else: */ - __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); + __pyx_t_2 = (abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)); if (__pyx_t_2) { - /* "View.MemoryView":1135 + /* "View.MemoryView":1132 * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): * return 'C' # <<<<<<<<<<<<<< @@ -13104,7 +14814,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_r = 'C'; goto __pyx_L0; - /* "View.MemoryView":1134 + /* "View.MemoryView":1131 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< @@ -13113,7 +14823,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ } - /* "View.MemoryView":1137 + /* "View.MemoryView":1134 * return 'C' * else: * return 'F' # <<<<<<<<<<<<<< @@ -13125,10 +14835,10 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ goto __pyx_L0; } - /* "View.MemoryView":1116 + /* "View.MemoryView":1113 * * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<< * """ * Figure out the best memory access order for a given slice. */ @@ -13138,7 +14848,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ return __pyx_r; } -/* "View.MemoryView":1140 +/* "View.MemoryView":1137 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< @@ -13154,12 +14864,11 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v Py_ssize_t __pyx_v_dst_stride; int __pyx_t_1; int __pyx_t_2; - int __pyx_t_3; + Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; - Py_ssize_t __pyx_t_6; - /* "View.MemoryView":1147 + /* "View.MemoryView":1144 * * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< @@ -13168,7 +14877,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_extent = (__pyx_v_src_shape[0]); - /* "View.MemoryView":1148 + /* "View.MemoryView":1145 * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< @@ -13177,7 +14886,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); - /* "View.MemoryView":1149 + /* "View.MemoryView":1146 * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< @@ -13186,7 +14895,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_stride = (__pyx_v_src_strides[0]); - /* "View.MemoryView":1150 + /* "View.MemoryView":1147 * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< @@ -13195,114 +14904,113 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); - /* "View.MemoryView":1152 + /* "View.MemoryView":1149 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): */ - __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + __pyx_t_1 = (__pyx_v_ndim == 1); if (__pyx_t_1) { - /* "View.MemoryView":1153 + /* "View.MemoryView":1150 * * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) + * if (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); + __pyx_t_2 = (__pyx_v_src_stride > 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } - __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); + __pyx_t_2 = (__pyx_v_dst_stride > 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } - /* "View.MemoryView":1154 + /* "View.MemoryView":1151 * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< - * memcpy(dst_data, src_data, itemsize * dst_extent) - * else: + * 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_t_1 = __pyx_t_2; __pyx_L5_bool_binop_done:; - /* "View.MemoryView":1153 + /* "View.MemoryView":1150 * * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) + * if (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":1155 - * 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): + /* "View.MemoryView":1152 + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); - /* "View.MemoryView":1153 + /* "View.MemoryView":1150 * * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) + * if (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":1157 - * 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 + /* "View.MemoryView":1154 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride */ /*else*/ { - __pyx_t_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":1158 - * else: - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< - * src_data += src_stride - * dst_data += dst_stride + __pyx_t_3 = __pyx_v_dst_extent; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":1155 + * else: + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< + * src_data += src_stride + * dst_data += dst_stride */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); - /* "View.MemoryView":1159 - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride # <<<<<<<<<<<<<< - * dst_data += dst_stride + /* "View.MemoryView":1156 + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride * else: */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - /* "View.MemoryView":1160 - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride - * dst_data += dst_stride # <<<<<<<<<<<<<< + /* "View.MemoryView":1157 + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< * else: * for i in range(dst_extent): */ @@ -13311,30 +15019,30 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v } __pyx_L4:; - /* "View.MemoryView":1152 + /* "View.MemoryView":1149 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): */ goto __pyx_L3; } - /* "View.MemoryView":1162 - * dst_data += dst_stride + /* "View.MemoryView":1159 + * dst_data += dst_stride * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< * _copy_strided_to_strided(src_data, src_strides + 1, * dst_data, dst_strides + 1, */ /*else*/ { - __pyx_t_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; + __pyx_t_3 = __pyx_v_dst_extent; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; - /* "View.MemoryView":1163 + /* "View.MemoryView":1160 * else: * for i in range(dst_extent): * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< @@ -13343,7 +15051,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ _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":1167 + /* "View.MemoryView":1164 * src_shape + 1, dst_shape + 1, * ndim - 1, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< @@ -13352,7 +15060,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - /* "View.MemoryView":1168 + /* "View.MemoryView":1165 * ndim - 1, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< @@ -13364,7 +15072,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v } __pyx_L3:; - /* "View.MemoryView":1140 + /* "View.MemoryView":1137 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< @@ -13375,40 +15083,40 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v /* function exit code */ } -/* "View.MemoryView":1170 +/* "View.MemoryView":1167 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) nogil: + * int ndim, size_t itemsize) noexcept nogil: */ static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { - /* "View.MemoryView":1173 + /* "View.MemoryView":1170 * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) nogil: + * int ndim, size_t itemsize) noexcept nogil: * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< * src.shape, dst.shape, ndim, itemsize) * */ _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); - /* "View.MemoryView":1170 + /* "View.MemoryView":1167 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) nogil: + * int ndim, size_t itemsize) noexcept nogil: */ /* function exit code */ } -/* "View.MemoryView":1177 +/* "View.MemoryView":1174 * * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize */ @@ -13422,8 +15130,8 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; - /* "View.MemoryView":1179 - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: + /* "View.MemoryView":1176 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< * @@ -13432,7 +15140,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_size = __pyx_t_1; - /* "View.MemoryView":1181 + /* "View.MemoryView":1178 * cdef Py_ssize_t shape, size = src.memview.view.itemsize * * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< @@ -13444,7 +15152,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_t_2 = __pyx_t_4; __pyx_v_shape = (__pyx_t_2[0]); - /* "View.MemoryView":1182 + /* "View.MemoryView":1179 * * for shape in src.shape[:ndim]: * size *= shape # <<<<<<<<<<<<<< @@ -13454,7 +15162,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_v_size = (__pyx_v_size * __pyx_v_shape); } - /* "View.MemoryView":1184 + /* "View.MemoryView":1181 * size *= shape * * return size # <<<<<<<<<<<<<< @@ -13464,10 +15172,10 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_r = __pyx_v_size; goto __pyx_L0; - /* "View.MemoryView":1177 + /* "View.MemoryView":1174 * * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize */ @@ -13477,12 +15185,12 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr return __pyx_r; } -/* "View.MemoryView":1187 +/* "View.MemoryView":1184 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) nogil: + * int ndim, char order) noexcept nogil: */ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { @@ -13493,17 +15201,17 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ int __pyx_t_3; int __pyx_t_4; - /* "View.MemoryView":1196 + /* "View.MemoryView":1193 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< * for idx in range(ndim): * strides[idx] = stride */ - __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + __pyx_t_1 = (__pyx_v_order == 'F'); if (__pyx_t_1) { - /* "View.MemoryView":1197 + /* "View.MemoryView":1194 * * if order == 'F': * for idx in range(ndim): # <<<<<<<<<<<<<< @@ -13515,7 +15223,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_idx = __pyx_t_4; - /* "View.MemoryView":1198 + /* "View.MemoryView":1195 * if order == 'F': * for idx in range(ndim): * strides[idx] = stride # <<<<<<<<<<<<<< @@ -13524,7 +15232,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - /* "View.MemoryView":1199 + /* "View.MemoryView":1196 * for idx in range(ndim): * strides[idx] = stride * stride *= shape[idx] # <<<<<<<<<<<<<< @@ -13534,7 +15242,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); } - /* "View.MemoryView":1196 + /* "View.MemoryView":1193 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< @@ -13544,7 +15252,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ goto __pyx_L3; } - /* "View.MemoryView":1201 + /* "View.MemoryView":1198 * stride *= shape[idx] * else: * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -13555,7 +15263,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { __pyx_v_idx = __pyx_t_2; - /* "View.MemoryView":1202 + /* "View.MemoryView":1199 * else: * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride # <<<<<<<<<<<<<< @@ -13564,7 +15272,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - /* "View.MemoryView":1203 + /* "View.MemoryView":1200 * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride * stride *= shape[idx] # <<<<<<<<<<<<<< @@ -13576,7 +15284,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ } __pyx_L3:; - /* "View.MemoryView":1205 + /* "View.MemoryView":1202 * stride *= shape[idx] * * return stride # <<<<<<<<<<<<<< @@ -13586,12 +15294,12 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ __pyx_r = __pyx_v_stride; goto __pyx_L0; - /* "View.MemoryView":1187 + /* "View.MemoryView":1184 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) nogil: + * int ndim, char order) noexcept nogil: */ /* function exit code */ @@ -13599,7 +15307,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ return __pyx_r; } -/* "View.MemoryView":1208 +/* "View.MemoryView":1205 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -13622,8 +15330,11 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save; + #endif - /* "View.MemoryView":1219 + /* "View.MemoryView":1216 * cdef void *result * * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< @@ -13633,7 +15344,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":1220 + /* "View.MemoryView":1217 * * cdef size_t itemsize = src.memview.view.itemsize * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< @@ -13642,44 +15353,44 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); - /* "View.MemoryView":1222 + /* "View.MemoryView":1219 * cdef size_t size = slice_get_size(src, ndim) * * result = malloc(size) # <<<<<<<<<<<<<< * if not result: - * _err(MemoryError, NULL) + * _err_no_memory() */ __pyx_v_result = malloc(__pyx_v_size); - /* "View.MemoryView":1223 + /* "View.MemoryView":1220 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< - * _err(MemoryError, NULL) + * _err_no_memory() * */ - __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + __pyx_t_2 = (!(__pyx_v_result != 0)); if (__pyx_t_2) { - /* "View.MemoryView":1224 + /* "View.MemoryView":1221 * result = malloc(size) * if not result: - * _err(MemoryError, NULL) # <<<<<<<<<<<<<< + * _err_no_memory() # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1224, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_no_memory(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1221, __pyx_L1_error) - /* "View.MemoryView":1223 + /* "View.MemoryView":1220 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< - * _err(MemoryError, NULL) + * _err_no_memory() * */ } - /* "View.MemoryView":1227 + /* "View.MemoryView":1224 * * * tmpslice.data = result # <<<<<<<<<<<<<< @@ -13688,7 +15399,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_tmpslice->data = ((char *)__pyx_v_result); - /* "View.MemoryView":1228 + /* "View.MemoryView":1225 * * tmpslice.data = result * tmpslice.memview = src.memview # <<<<<<<<<<<<<< @@ -13698,7 +15409,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_4 = __pyx_v_src->memview; __pyx_v_tmpslice->memview = __pyx_t_4; - /* "View.MemoryView":1229 + /* "View.MemoryView":1226 * tmpslice.data = result * tmpslice.memview = src.memview * for i in range(ndim): # <<<<<<<<<<<<<< @@ -13710,7 +15421,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1230 + /* "View.MemoryView":1227 * tmpslice.memview = src.memview * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< @@ -13719,26 +15430,26 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); - /* "View.MemoryView":1231 + /* "View.MemoryView":1228 * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) */ (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; } - /* "View.MemoryView":1233 + /* "View.MemoryView":1230 * tmpslice.suboffsets[i] = -1 * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< - * ndim, order) + * 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":1237 + /* "View.MemoryView":1233 * * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -13750,17 +15461,17 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1238 + /* "View.MemoryView":1234 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< * tmpslice.strides[i] = 0 * */ - __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); + __pyx_t_2 = ((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1); if (__pyx_t_2) { - /* "View.MemoryView":1239 + /* "View.MemoryView":1235 * for i in range(ndim): * if tmpslice.shape[i] == 1: * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< @@ -13769,7 +15480,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; - /* "View.MemoryView":1238 + /* "View.MemoryView":1234 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< @@ -13779,17 +15490,17 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, } } - /* "View.MemoryView":1241 + /* "View.MemoryView":1237 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< * memcpy(result, src.data, size) * else: */ - __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); + __pyx_t_2 = __pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim); if (__pyx_t_2) { - /* "View.MemoryView":1242 + /* "View.MemoryView":1238 * * if slice_is_contig(src[0], order, ndim): * memcpy(result, src.data, size) # <<<<<<<<<<<<<< @@ -13798,7 +15509,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); - /* "View.MemoryView":1241 + /* "View.MemoryView":1237 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< @@ -13808,7 +15519,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, goto __pyx_L9; } - /* "View.MemoryView":1244 + /* "View.MemoryView":1240 * memcpy(result, src.data, size) * else: * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< @@ -13820,7 +15531,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, } __pyx_L9:; - /* "View.MemoryView":1246 + /* "View.MemoryView":1242 * copy_strided_to_strided(src, tmpslice, ndim, itemsize) * * return result # <<<<<<<<<<<<<< @@ -13830,7 +15541,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_r = __pyx_v_result; goto __pyx_L0; - /* "View.MemoryView":1208 + /* "View.MemoryView":1205 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -13840,34 +15551,32 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, /* 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 - } + #ifdef WITH_THREAD + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif __pyx_L0:; return __pyx_r; } -/* "View.MemoryView":1251 +/* "View.MemoryView":1247 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< * Py_ssize_t extent2) except -1 with gil: - * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" */ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_2; + Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; @@ -13877,61 +15586,69 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent #endif __Pyx_RefNannySetupContext("_err_extents", 0); - /* "View.MemoryView":1254 + /* "View.MemoryView":1249 + * 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)) # <<<<<<<<<<<<<< + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err_dim') */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1254, __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, 1254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1254, __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":1253 - * 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, 1253, __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, 1253, __pyx_L1_error) + __pyx_t_3 = 127; + __Pyx_INCREF(__pyx_kp_u_got_differing_extents_in_dimensi); + __pyx_t_2 += 35; + __Pyx_GIVEREF(__pyx_kp_u_got_differing_extents_in_dimensi); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_got_differing_extents_in_dimensi); + __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_kp_u_got); + __pyx_t_2 += 6; + __Pyx_GIVEREF(__pyx_kp_u_got); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_got); + __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent1, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_kp_u_and); + __pyx_t_2 += 5; + __Pyx_GIVEREF(__pyx_kp_u_and); + PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_and); + __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent2, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_kp_u__7); + __pyx_t_2 += 1; + __Pyx_GIVEREF(__pyx_kp_u__7); + PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__7); + __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_4, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 1253, __pyx_L1_error) + __PYX_ERR(1, 1249, __pyx_L1_error) - /* "View.MemoryView":1251 + /* "View.MemoryView":1247 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< * Py_ssize_t extent2) except -1 with gil: - * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_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; @@ -13942,21 +15659,19 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent return __pyx_r; } -/* "View.MemoryView":1257 +/* "View.MemoryView":1252 * * @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) + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error, msg % dim * */ -static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, PyObject *__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; @@ -13964,49 +15679,29 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_dim", 0); - __Pyx_INCREF(__pyx_v_error); + __Pyx_INCREF(__pyx_v_msg); - /* "View.MemoryView":1258 + /* "View.MemoryView":1253 * @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) # <<<<<<<<<<<<<< + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + * raise error, msg % 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, 1258, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_v_msg, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1253, __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, 1258, __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, 1258, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_t_2, 0, 0); __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, 1258, __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, 1258, __pyx_L1_error) + __PYX_ERR(1, 1253, __pyx_L1_error) - /* "View.MemoryView":1257 + /* "View.MemoryView":1252 * * @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) + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error, msg % dim * */ @@ -14014,11 +15709,9 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, __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_XDECREF(__pyx_v_msg); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); @@ -14026,22 +15719,17 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, return __pyx_r; } -/* "View.MemoryView":1261 +/* "View.MemoryView":1256 * * @cname('__pyx_memoryview_err') - * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< - * if msg != NULL: - * raise error(msg.decode('ascii')) + * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< + * raise error, msg + * */ -static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { +static int __pyx_memoryview_err(PyObject *__pyx_v_error, PyObject *__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; @@ -14049,94 +15737,83 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err", 0); - __Pyx_INCREF(__pyx_v_error); + __Pyx_INCREF(__pyx_v_msg); - /* "View.MemoryView":1262 + /* "View.MemoryView":1257 * @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":1263 - * cdef int _err(object error, char *msg) except -1 with gil: - * if msg != NULL: - * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< - * else: - * raise error + * cdef int _err(PyObject *error, str msg) except -1 with gil: + * raise error, msg # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_no_memory') */ - __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, 1263, __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, 1263, __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, 1263, __pyx_L1_error) + __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_v_msg, 0, 0); + __PYX_ERR(1, 1257, __pyx_L1_error) - /* "View.MemoryView":1262 + /* "View.MemoryView":1256 + * * @cname('__pyx_memoryview_err') - * cdef int _err(object error, char *msg) except -1 with gil: - * if msg != NULL: # <<<<<<<<<<<<<< - * raise error(msg.decode('ascii')) - * else: + * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< + * raise error, msg + * */ - } - /* "View.MemoryView":1265 - * raise error(msg.decode('ascii')) - * else: - * raise error # <<<<<<<<<<<<<< + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1260 + * + * @cname('__pyx_memoryview_err_no_memory') + * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< + * raise MemoryError * - * @cname('__pyx_memoryview_copy_contents') */ - /*else*/ { - __Pyx_Raise(__pyx_v_error, 0, 0, 0); - __PYX_ERR(1, 1265, __pyx_L1_error) - } + +static int __pyx_memoryview_err_no_memory(void) { + int __pyx_r; + 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 /* "View.MemoryView":1261 + * @cname('__pyx_memoryview_err_no_memory') + * cdef int _err_no_memory() except -1 with gil: + * raise MemoryError # <<<<<<<<<<<<<< + * + * + */ + PyErr_NoMemory(); __PYX_ERR(1, 1261, __pyx_L1_error) + + /* "View.MemoryView":1260 + * + * @cname('__pyx_memoryview_err_no_memory') + * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< + * raise MemoryError * - * @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_AddTraceback("View.MemoryView._err_no_memory", __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":1268 +/* "View.MemoryView":1265 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< @@ -14161,12 +15838,14 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ 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; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save; + #endif - /* "View.MemoryView":1276 + /* "View.MemoryView":1273 * Check for overlapping memory and verify the shapes. * """ * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< @@ -14175,7 +15854,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_tmpdata = NULL; - /* "View.MemoryView":1277 + /* "View.MemoryView":1274 * """ * cdef void *tmpdata = NULL * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< @@ -14185,7 +15864,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_1 = __pyx_v_src.memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":1279 + /* "View.MemoryView":1276 * cdef size_t itemsize = src.memview.view.itemsize * cdef int i * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< @@ -14194,7 +15873,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); - /* "View.MemoryView":1280 + /* "View.MemoryView":1277 * cdef int i * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False # <<<<<<<<<<<<<< @@ -14203,7 +15882,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_broadcasting = 0; - /* "View.MemoryView":1281 + /* "View.MemoryView":1278 * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False * cdef bint direct_copy = False # <<<<<<<<<<<<<< @@ -14212,17 +15891,17 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = 0; - /* "View.MemoryView":1284 + /* "View.MemoryView":1281 * 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); + __pyx_t_2 = (__pyx_v_src_ndim < __pyx_v_dst_ndim); if (__pyx_t_2) { - /* "View.MemoryView":1285 + /* "View.MemoryView":1282 * * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< @@ -14231,7 +15910,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); - /* "View.MemoryView":1284 + /* "View.MemoryView":1281 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< @@ -14241,17 +15920,17 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L3; } - /* "View.MemoryView":1286 + /* "View.MemoryView":1283 * 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); + __pyx_t_2 = (__pyx_v_dst_ndim < __pyx_v_src_ndim); if (__pyx_t_2) { - /* "View.MemoryView":1287 + /* "View.MemoryView":1284 * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< @@ -14260,7 +15939,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); - /* "View.MemoryView":1286 + /* "View.MemoryView":1283 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< @@ -14270,7 +15949,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_L3:; - /* "View.MemoryView":1289 + /* "View.MemoryView":1286 * broadcast_leading(&dst, dst_ndim, src_ndim) * * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< @@ -14279,14 +15958,15 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_t_3 = __pyx_v_dst_ndim; __pyx_t_4 = __pyx_v_src_ndim; - if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_2 = (__pyx_t_3 > __pyx_t_4); + if (__pyx_t_2) { __pyx_t_5 = __pyx_t_3; } else { __pyx_t_5 = __pyx_t_4; } __pyx_v_ndim = __pyx_t_5; - /* "View.MemoryView":1291 + /* "View.MemoryView":1288 * cdef int ndim = max(src_ndim, dst_ndim) * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -14298,27 +15978,27 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1292 + /* "View.MemoryView":1289 * * 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); + __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])); if (__pyx_t_2) { - /* "View.MemoryView":1293 + /* "View.MemoryView":1290 * 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); + __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) == 1); if (__pyx_t_2) { - /* "View.MemoryView":1294 + /* "View.MemoryView":1291 * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: * broadcasting = True # <<<<<<<<<<<<<< @@ -14327,7 +16007,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_broadcasting = 1; - /* "View.MemoryView":1295 + /* "View.MemoryView":1292 * if src.shape[i] == 1: * broadcasting = True * src.strides[i] = 0 # <<<<<<<<<<<<<< @@ -14336,7 +16016,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ (__pyx_v_src.strides[__pyx_v_i]) = 0; - /* "View.MemoryView":1293 + /* "View.MemoryView":1290 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< @@ -14346,7 +16026,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L7; } - /* "View.MemoryView":1297 + /* "View.MemoryView":1294 * src.strides[i] = 0 * else: * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< @@ -14354,11 +16034,11 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ * 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, 1297, __pyx_L1_error) + __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, 1294, __pyx_L1_error) } __pyx_L7:; - /* "View.MemoryView":1292 + /* "View.MemoryView":1289 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< @@ -14367,56 +16047,56 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1299 + /* "View.MemoryView":1296 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Dimension %d is not direct", i) + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) * */ - __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + __pyx_t_2 = ((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0); if (__pyx_t_2) { - /* "View.MemoryView":1300 + /* "View.MemoryView":1297 * * if src.suboffsets[i] >= 0: - * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * _err_dim(PyExc_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, 1300, __pyx_L1_error) + __pyx_t_6 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Dimension_d_is_not_direct, __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error) - /* "View.MemoryView":1299 + /* "View.MemoryView":1296 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Dimension %d is not direct", i) + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) * */ } } - /* "View.MemoryView":1302 - * _err_dim(ValueError, "Dimension %d is not direct", i) + /* "View.MemoryView":1299 + * _err_dim(PyExc_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); + __pyx_t_2 = __pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); if (__pyx_t_2) { - /* "View.MemoryView":1304 + /* "View.MemoryView":1301 * 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); + __pyx_t_2 = (!__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim)); if (__pyx_t_2) { - /* "View.MemoryView":1305 + /* "View.MemoryView":1302 * * if not slice_is_contig(src, order, ndim): * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< @@ -14425,7 +16105,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); - /* "View.MemoryView":1304 + /* "View.MemoryView":1301 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< @@ -14434,17 +16114,17 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1307 + /* "View.MemoryView":1304 * 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, 1307, __pyx_L1_error) + __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, 1304, __pyx_L1_error) __pyx_v_tmpdata = __pyx_t_7; - /* "View.MemoryView":1308 + /* "View.MemoryView":1305 * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) * src = tmp # <<<<<<<<<<<<<< @@ -14453,8 +16133,8 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_src = __pyx_v_tmp; - /* "View.MemoryView":1302 - * _err_dim(ValueError, "Dimension %d is not direct", i) + /* "View.MemoryView":1299 + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< * @@ -14462,27 +16142,27 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1310 + /* "View.MemoryView":1307 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< * * */ - __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + __pyx_t_2 = (!__pyx_v_broadcasting); if (__pyx_t_2) { - /* "View.MemoryView":1313 + /* "View.MemoryView":1310 * * * 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); + __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim); if (__pyx_t_2) { - /* "View.MemoryView":1314 + /* "View.MemoryView":1311 * * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< @@ -14491,7 +16171,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); - /* "View.MemoryView":1313 + /* "View.MemoryView":1310 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< @@ -14501,17 +16181,17 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L12; } - /* "View.MemoryView":1315 + /* "View.MemoryView":1312 * 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); + __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim); if (__pyx_t_2) { - /* "View.MemoryView":1316 + /* "View.MemoryView":1313 * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< @@ -14520,7 +16200,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); - /* "View.MemoryView":1315 + /* "View.MemoryView":1312 * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< @@ -14530,54 +16210,53 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_L12:; - /* "View.MemoryView":1318 + /* "View.MemoryView":1315 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * - * refcount_copying(&dst, dtype_is_object, ndim, False) + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) */ - __pyx_t_2 = (__pyx_v_direct_copy != 0); - if (__pyx_t_2) { + if (__pyx_v_direct_copy) { - /* "View.MemoryView":1320 + /* "View.MemoryView":1317 * if direct_copy: * - * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, True) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1321 + /* "View.MemoryView":1318 * - * refcount_copying(&dst, dtype_is_object, ndim, False) + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, True) + * refcount_copying(&dst, dtype_is_object, ndim, inc=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":1322 - * refcount_copying(&dst, dtype_is_object, ndim, False) + /* "View.MemoryView":1319 + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< * free(tmpdata) * return 0 */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1323 + /* "View.MemoryView":1320 * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, True) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * free(tmpdata) # <<<<<<<<<<<<<< * return 0 * */ free(__pyx_v_tmpdata); - /* "View.MemoryView":1324 - * refcount_copying(&dst, dtype_is_object, ndim, True) + /* "View.MemoryView":1321 + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * free(tmpdata) * return 0 # <<<<<<<<<<<<<< * @@ -14586,16 +16265,16 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":1318 + /* "View.MemoryView":1315 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * - * refcount_copying(&dst, dtype_is_object, ndim, False) + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) */ } - /* "View.MemoryView":1310 + /* "View.MemoryView":1307 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< @@ -14604,7 +16283,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1326 + /* "View.MemoryView":1323 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< @@ -14615,28 +16294,27 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ 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) { + if (__pyx_t_2) { - /* "View.MemoryView":1329 + /* "View.MemoryView":1326 * * * 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, 1329, __pyx_L1_error) + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1326, __pyx_L1_error) - /* "View.MemoryView":1330 + /* "View.MemoryView":1327 * * transpose_memslice(&src) * transpose_memslice(&dst) # <<<<<<<<<<<<<< * - * refcount_copying(&dst, dtype_is_object, ndim, False) + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) */ - __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1330, __pyx_L1_error) + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1327, __pyx_L1_error) - /* "View.MemoryView":1326 + /* "View.MemoryView":1323 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< @@ -14645,35 +16323,35 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1332 + /* "View.MemoryView":1329 * transpose_memslice(&dst) * - * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, True) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1333 + /* "View.MemoryView":1330 * - * refcount_copying(&dst, dtype_is_object, ndim, False) + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, True) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * */ copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - /* "View.MemoryView":1334 - * refcount_copying(&dst, dtype_is_object, ndim, False) + /* "View.MemoryView":1331 + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< * * free(tmpdata) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1336 - * refcount_copying(&dst, dtype_is_object, ndim, True) + /* "View.MemoryView":1333 + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * * free(tmpdata) # <<<<<<<<<<<<<< * return 0 @@ -14681,7 +16359,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ free(__pyx_v_tmpdata); - /* "View.MemoryView":1337 + /* "View.MemoryView":1334 * * free(tmpdata) * return 0 # <<<<<<<<<<<<<< @@ -14691,7 +16369,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":1268 + /* "View.MemoryView":1265 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< @@ -14701,26 +16379,24 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ /* 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 - } + #ifdef WITH_THREAD + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif __pyx_L0:; return __pyx_r; } -/* "View.MemoryView":1340 +/* "View.MemoryView":1337 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, - * int ndim_other) nogil: + * int ndim_other) noexcept nogil: */ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { @@ -14730,8 +16406,8 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic int __pyx_t_2; int __pyx_t_3; - /* "View.MemoryView":1344 - * int ndim_other) nogil: + /* "View.MemoryView":1341 + * int ndim_other) noexcept nogil: * cdef int i * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< * @@ -14739,7 +16415,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); - /* "View.MemoryView":1346 + /* "View.MemoryView":1343 * cdef int offset = ndim_other - ndim * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -14749,7 +16425,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":1347 + /* "View.MemoryView":1344 * * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< @@ -14758,7 +16434,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); - /* "View.MemoryView":1348 + /* "View.MemoryView":1345 * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< @@ -14767,7 +16443,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1349 + /* "View.MemoryView":1346 * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< @@ -14777,7 +16453,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); } - /* "View.MemoryView":1351 + /* "View.MemoryView":1348 * mslice.suboffsets[i + offset] = mslice.suboffsets[i] * * for i in range(offset): # <<<<<<<<<<<<<< @@ -14789,7 +16465,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "View.MemoryView":1352 + /* "View.MemoryView":1349 * * for i in range(offset): * mslice.shape[i] = 1 # <<<<<<<<<<<<<< @@ -14798,7 +16474,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->shape[__pyx_v_i]) = 1; - /* "View.MemoryView":1353 + /* "View.MemoryView":1350 * for i in range(offset): * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< @@ -14807,7 +16483,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); - /* "View.MemoryView":1354 + /* "View.MemoryView":1351 * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< @@ -14817,125 +16493,128 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; } - /* "View.MemoryView":1340 + /* "View.MemoryView":1337 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, - * int ndim_other) nogil: + * int ndim_other) noexcept nogil: */ /* function exit code */ } -/* "View.MemoryView":1362 +/* "View.MemoryView":1359 * * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< - * int ndim, bint inc) nogil: + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< * + * if dtype_is_object: */ 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":1366 - * + /* "View.MemoryView":1361 + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: * * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, - * dst.strides, ndim, inc) + * 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) { + if (__pyx_v_dtype_is_object) { - /* "View.MemoryView":1367 + /* "View.MemoryView":1362 * * if dtype_is_object: - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< - * dst.strides, ndim, inc) + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) # <<<<<<<<<<<<<< * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') */ __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":1366 - * + /* "View.MemoryView":1361 + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: * * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, - * dst.strides, ndim, inc) + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * */ } - /* "View.MemoryView":1362 + /* "View.MemoryView":1359 * * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< - * int ndim, bint inc) nogil: + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< * + * if dtype_is_object: */ /* function exit code */ } -/* "View.MemoryView":1371 +/* "View.MemoryView":1365 * * @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: + * bint inc) noexcept 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":1374 + /* "View.MemoryView":1368 * Py_ssize_t *strides, int ndim, - * bint inc) with gil: + * bint inc) noexcept 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":1371 + /* "View.MemoryView":1365 * * @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: + * bint inc) noexcept with gil: */ /* function exit code */ - __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } -/* "View.MemoryView":1377 +/* "View.MemoryView":1371 * * @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): + * Py_ssize_t *strides, int ndim, bint inc) noexcept: * 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_v_stride; 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":1381 + /* "View.MemoryView":1374 + * Py_ssize_t *strides, int ndim, bint inc) noexcept: * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * + * for i in range(shape[0]): + */ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1376 + * cdef Py_ssize_t stride = strides[0] * * for i in range(shape[0]): # <<<<<<<<<<<<<< * if ndim == 1: @@ -14946,27 +16625,26 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "View.MemoryView":1382 + /* "View.MemoryView":1377 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< * if inc: * Py_INCREF(( data)[0]) */ - __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + __pyx_t_4 = (__pyx_v_ndim == 1); if (__pyx_t_4) { - /* "View.MemoryView":1383 + /* "View.MemoryView":1378 * 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) { + if (__pyx_v_inc) { - /* "View.MemoryView":1384 + /* "View.MemoryView":1379 * if ndim == 1: * if inc: * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< @@ -14975,7 +16653,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss */ Py_INCREF((((PyObject **)__pyx_v_data)[0])); - /* "View.MemoryView":1383 + /* "View.MemoryView":1378 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< @@ -14985,19 +16663,19 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss goto __pyx_L6; } - /* "View.MemoryView":1386 + /* "View.MemoryView":1381 * Py_INCREF(( data)[0]) * else: * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) */ /*else*/ { Py_DECREF((((PyObject **)__pyx_v_data)[0])); } __pyx_L6:; - /* "View.MemoryView":1382 + /* "View.MemoryView":1377 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< @@ -15007,102 +16685,93 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss goto __pyx_L5; } - /* "View.MemoryView":1388 + /* "View.MemoryView":1383 * Py_DECREF(( data)[0]) * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< - * ndim - 1, inc) + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) # <<<<<<<<<<<<<< * + * data += stride */ /*else*/ { - - /* "View.MemoryView":1389 - * 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":1391 - * ndim - 1, inc) + /* "View.MemoryView":1385 + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) * - * data += strides[0] # <<<<<<<<<<<<<< + * data += stride # <<<<<<<<<<<<<< * * */ - __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } - /* "View.MemoryView":1377 + /* "View.MemoryView":1371 * * @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): + * Py_ssize_t *strides, int ndim, bint inc) noexcept: * cdef Py_ssize_t i */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":1397 +/* "View.MemoryView":1391 * * @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: + * bint dtype_is_object) noexcept 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":1400 + /* "View.MemoryView":1394 * 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) + * bint dtype_is_object) noexcept nogil: + * refcount_copying(dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, inc=True) */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1401 - * 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) + /* "View.MemoryView":1395 + * bint dtype_is_object) noexcept nogil: + * refcount_copying(dst, dtype_is_object, ndim, inc=False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) # <<<<<<<<<<<<<< + * refcount_copying(dst, dtype_is_object, ndim, inc=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":1403 - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, - * itemsize, item) - * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + /* "View.MemoryView":1396 + * refcount_copying(dst, dtype_is_object, ndim, inc=False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< * * */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1397 + /* "View.MemoryView":1391 * * @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: + * bint dtype_is_object) noexcept nogil: */ /* function exit code */ } -/* "View.MemoryView":1407 +/* "View.MemoryView":1400 * * @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: + * size_t itemsize, void *item) noexcept 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) { @@ -15114,8 +16783,8 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; - /* "View.MemoryView":1411 - * size_t itemsize, void *item) nogil: + /* "View.MemoryView":1404 + * size_t itemsize, void *item) noexcept nogil: * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t extent = shape[0] @@ -15123,7 +16792,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_v_stride = (__pyx_v_strides[0]); - /* "View.MemoryView":1412 + /* "View.MemoryView":1405 * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< @@ -15132,17 +16801,17 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_v_extent = (__pyx_v_shape[0]); - /* "View.MemoryView":1414 + /* "View.MemoryView":1407 * 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); + __pyx_t_1 = (__pyx_v_ndim == 1); if (__pyx_t_1) { - /* "View.MemoryView":1415 + /* "View.MemoryView":1408 * * if ndim == 1: * for i in range(extent): # <<<<<<<<<<<<<< @@ -15154,7 +16823,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1416 + /* "View.MemoryView":1409 * if ndim == 1: * for i in range(extent): * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< @@ -15163,7 +16832,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); - /* "View.MemoryView":1417 + /* "View.MemoryView":1410 * for i in range(extent): * memcpy(data, item, itemsize) * data += stride # <<<<<<<<<<<<<< @@ -15173,7 +16842,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } - /* "View.MemoryView":1414 + /* "View.MemoryView":1407 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -15183,12 +16852,12 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t goto __pyx_L3; } - /* "View.MemoryView":1419 + /* "View.MemoryView":1412 * data += stride * else: * for i in range(extent): # <<<<<<<<<<<<<< - * _slice_assign_scalar(data, shape + 1, strides + 1, - * ndim - 1, itemsize, item) + * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) + * data += stride */ /*else*/ { __pyx_t_2 = __pyx_v_extent; @@ -15196,18 +16865,18 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1420 + /* "View.MemoryView":1413 * else: * for i in range(extent): - * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< - * ndim - 1, itemsize, item) + * _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":1422 - * _slice_assign_scalar(data, shape + 1, strides + 1, - * ndim - 1, itemsize, item) + /* "View.MemoryView":1414 + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) * data += stride # <<<<<<<<<<<<<< * * @@ -15217,12 +16886,12 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t } __pyx_L3:; - /* "View.MemoryView":1407 + /* "View.MemoryView":1400 * * @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: + * size_t itemsize, void *item) noexcept nogil: */ /* function exit code */ @@ -15235,70 +16904,114 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ /* 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) { +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,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); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - 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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) 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--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) 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--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) 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) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 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); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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; + goto __pyx_L6_skip; __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_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -15306,6 +17019,12 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *_ __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 */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -15315,128 +17034,119 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 1); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum */ - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0); - if (__pyx_t_1) { + __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__8, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { /* "(tree fragment)":5 * cdef object __pyx_result - * if __pyx_checksum != 0xb068931: + * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum * __pyx_result = Enum.__new__(__pyx_type) */ - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __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_2, 0, __pyx_n_s_PickleError); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_2); - __pyx_v___pyx_PickleError = __pyx_t_2; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __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_3); __pyx_t_3 = 0; /* "(tree fragment)":6 - * if __pyx_checksum != 0xb068931: + * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum # <<<<<<<<<<<<<< * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: */ - __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = Enum.__new__(__pyx_type) @@ -15445,13 +17155,13 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE * 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_3 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) @@ -15479,10 +17189,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -15508,14 +17217,14 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ int __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; + int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 1); /* "(tree fragment)":12 * return __pyx_result @@ -15546,16 +17255,15 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ 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); + __pyx_t_3 = __Pyx_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); 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_t_2 = __pyx_t_4; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { @@ -15564,33 +17272,40 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ * 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_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); 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; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 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_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; } } - __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; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 @@ -15614,9 +17329,9 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ goto __pyx_L0; __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_8); __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -15624,476 +17339,918 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ __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; -} +/* "talkingface/utils/vits_utils/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_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); +static void __pyx_f_11talkingface_5utils_10vits_utils_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_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_each *__pyx_optional_args) { + float __pyx_v_max_neg_val = __pyx_k__9; + 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; + int __pyx_t_7; + long __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; + } } - 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; - } -} + /* "talkingface/utils/vits_utils/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); -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; -} + /* "talkingface/utils/vits_utils/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; -static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); -} + /* "talkingface/utils/vits_utils/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; + __pyx_t_7 = (__pyx_t_4 < __pyx_t_5); + if (__pyx_t_7) { + __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; + __pyx_t_7 = (__pyx_t_5 > __pyx_t_6); + if (__pyx_t_7) { + __pyx_t_8 = __pyx_t_5; + } else { + __pyx_t_8 = __pyx_t_6; + } + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_5 = __pyx_t_8; __pyx_t_5 < __pyx_t_6; __pyx_t_5+=1) { + __pyx_v_x = __pyx_t_5; -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} -}; + /* "talkingface/utils/vits_utils/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_7 = (__pyx_v_x == __pyx_v_y); + if (__pyx_t_7) { -static struct PyGetSetDef __pyx_getsets_array[] = { - {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; + /* "talkingface/utils/vits_utils/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; -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*/ -}; + /* "talkingface/utils/vits_utils/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; + } -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*/ -}; + /* "talkingface/utils/vits_utils/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:; -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*/ -}; + /* "talkingface/utils/vits_utils/monotonic_align/core.pyx":21 + * else: + * v_cur = value[y-1, x] + * if x == 0: # <<<<<<<<<<<<<< + * if y == 0: + * v_prev = 0. + */ + __pyx_t_7 = (__pyx_v_x == 0); + if (__pyx_t_7) { -static PyTypeObject __pyx_type___pyx_array = { - PyVarObject_HEAD_INIT(0, 0) - "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 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; + /* "talkingface/utils/vits_utils/monotonic_align/core.pyx":22 + * v_cur = value[y-1, x] + * if x == 0: + * if y == 0: # <<<<<<<<<<<<<< + * v_prev = 0. + * else: + */ + __pyx_t_7 = (__pyx_v_y == 0); + if (__pyx_t_7) { -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; -} + /* "talkingface/utils/vits_utils/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.; -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; + /* "talkingface/utils/vits_utils/monotonic_align/core.pyx":22 + * v_cur = value[y-1, x] + * if x == 0: + * if y == 0: # <<<<<<<<<<<<<< + * v_prev = 0. + * else: + */ + goto __pyx_L9; + } + + /* "talkingface/utils/vits_utils/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:; + + /* "talkingface/utils/vits_utils/monotonic_align/core.pyx":21 + * else: + * v_cur = value[y-1, x] + * if x == 0: # <<<<<<<<<<<<<< + * if y == 0: + * v_prev = 0. + */ + goto __pyx_L8; + } + + /* "talkingface/utils/vits_utils/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:; + + /* "talkingface/utils/vits_utils/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; + __pyx_t_7 = (__pyx_t_11 > __pyx_t_12); + if (__pyx_t_7) { + __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; + } } - #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; + /* "talkingface/utils/vits_utils/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; + + /* "talkingface/utils/vits_utils/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; + + /* "talkingface/utils/vits_utils/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); + if (__pyx_t_14) { + } else { + __pyx_t_7 = __pyx_t_14; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_14 = (__pyx_v_index == __pyx_v_y); + if (!__pyx_t_14) { + } else { + __pyx_t_7 = __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)) )))); + __pyx_t_7 = __pyx_t_14; + __pyx_L13_bool_binop_done:; + if (__pyx_t_7) { + + /* "talkingface/utils/vits_utils/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); + + /* "talkingface/utils/vits_utils/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 + * + */ + } } - 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; + /* "talkingface/utils/vits_utils/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 */ } -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} -}; +/* "talkingface/utils/vits_utils/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 PyTypeObject __pyx_type___pyx_MemviewEnum = { - PyVarObject_HEAD_INIT(0, 0) - "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*/ +static PyObject *__pyx_pw_11talkingface_5utils_10vits_utils_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static void __pyx_f_11talkingface_5utils_10vits_utils_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; + __Pyx_RefNannyDeclarations + 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save; #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 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; -static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + __Pyx_RefNannySetupContext("maximum_path_c", 1); -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; -} + /* "talkingface/utils/vits_utils/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]); -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); + /* "talkingface/utils/vits_utils/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]) + */ { - 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); -} + #ifdef WITH_THREAD + PyThreadState *_save; + _save = NULL; + if (PyGILState_Check()) { + Py_UNBLOCK_THREADS + } + __Pyx_FastGIL_Remember(); + #endif + /*try:*/ { + __pyx_t_1 = __pyx_v_b; + { + int __pyx_parallel_temp0 = ((int)0xbad0bad0); + const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; + PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; + int __pyx_parallel_why; + __pyx_parallel_why = 0; + #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) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) + #endif /* _OPENMP */ + { + #ifdef _OPENMP + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + Py_BEGIN_ALLOW_THREADS + #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++){ + if (__pyx_parallel_why < 2) + { + __pyx_v_i = (int)(0 + 1 * __pyx_t_2); -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; + /* "talkingface/utils/vits_utils/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; } -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; -} +__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; -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; - } -} +__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; -static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +__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; } -static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); -} +__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; -static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); -} +__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; -static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +__pyx_t_6 = __pyx_v_i; + __pyx_t_7 = __pyx_v_i; + __pyx_f_11talkingface_5utils_10vits_utils_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); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 42, __pyx_L8_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); + __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); + __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; + goto __pyx_L11; + __pyx_L8_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + #ifdef _OPENMP + #pragma omp flush(__pyx_parallel_exc_type) + #endif /* _OPENMP */ + if (!__pyx_parallel_exc_type) { + __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); + __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; + __Pyx_GOTREF(__pyx_parallel_exc_type); + } + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_parallel_why = 4; + goto __pyx_L10; + __pyx_L10:; + #ifdef _OPENMP + #pragma omp critical(__pyx_parallel_lastprivates0) + #endif /* _OPENMP */ + { + __pyx_parallel_temp0 = __pyx_v_i; + } + __pyx_L11:; + #ifdef _OPENMP + #pragma omp flush(__pyx_parallel_why) + #endif /* _OPENMP */ + } + } + #ifdef _OPENMP + Py_END_ALLOW_THREADS + #else +{ +#ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + #endif /* _OPENMP */ + /* Clean up any temporaries */ + __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); + __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); + __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + #ifndef _OPENMP } +#endif /* _OPENMP */ + } + } + if (__pyx_parallel_exc_type) { + /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ + __pyx_parallel_why = 4; + } + if (__pyx_parallel_why) { + __pyx_v_i = __pyx_parallel_temp0; + switch (__pyx_parallel_why) { + case 4: + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_GIVEREF(__pyx_parallel_exc_type); + __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); + __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + goto __pyx_L4_error; + } + } + } + #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 + } -static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); -} + /* "talkingface/utils/vits_utils/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(); + if (_save) { + Py_BLOCK_THREADS + } + #endif + goto __pyx_L5; + } + __pyx_L4_error: { + #ifdef WITH_THREAD + __Pyx_FastGIL_Forget(); + if (_save) { + Py_BLOCK_THREADS + } + #endif + goto __pyx_L1_error; + } + __pyx_L5:; + } + } -static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); + /* "talkingface/utils/vits_utils/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 */ + goto __pyx_L0; + __pyx_L1_error:; + #ifdef WITH_THREAD + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1); + __Pyx_AddTraceback("talkingface.utils.vits_utils.monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + __pyx_L0:; + __Pyx_RefNannyFinishContextNogil() } -static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +/* Python wrapper */ +static PyObject *__pyx_pw_11talkingface_5utils_10vits_utils_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_11talkingface_5utils_10vits_utils_15monotonic_align_4core_1maximum_path_c = {"maximum_path_c", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_11talkingface_5utils_10vits_utils_15monotonic_align_4core_1maximum_path_c, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_11talkingface_5utils_10vits_utils_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + __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 } }; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {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); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_paths,&__pyx_n_s_values,&__pyx_n_s_t_ys,&__pyx_n_s_t_xs,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_paths)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_values)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) + 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_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_ys)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) + 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_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_xs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, 3); __PYX_ERR(0, 38, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "maximum_path_c") < 0)) __PYX_ERR(0, 38, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__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_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("maximum_path_c", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __PYX_XCLEAR_MEMVIEW(&__pyx_v_paths, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_values, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_ys, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_xs, 1); + __Pyx_AddTraceback("talkingface.utils.vits_utils.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_11talkingface_5utils_10vits_utils_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_XCLEAR_MEMVIEW(&__pyx_v_paths, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_values, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_ys, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_xs, 1); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -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_pf_11talkingface_5utils_10vits_utils_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", 1); + __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_f_11talkingface_5utils_10vits_utils_15monotonic_align_4core_maximum_path_c(__pyx_v_paths, __pyx_v_values, __pyx_v_t_ys, __pyx_v_t_xs, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); 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("talkingface.utils.vits_utils.monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } +static struct __pyx_vtabstruct_array __pyx_vtable_array; -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 PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + 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 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}, +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((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_array) { + 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); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} +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 { + __Pyx_TypeName o_type_name; + o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); + __Pyx_DECREF_TypeName(o_type_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)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 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}, +static struct PyGetSetDef __pyx_getsets_array[] = { + {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +#if !CYTHON_COMPILING_IN_LIMITED_API -static PySequenceMethods __pyx_tp_as_sequence_memoryview = { - __pyx_memoryview___len__, /*sq_length*/ +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*/ +}; +#endif +static PyType_Slot __pyx_type___pyx_array_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_array}, + {Py_sq_length, (void *)__pyx_array___len__}, + {Py_sq_item, (void *)__pyx_sq_item_array}, + {Py_mp_length, (void *)__pyx_array___len__}, + {Py_mp_subscript, (void *)__pyx_array___getitem__}, + {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_array}, + {Py_tp_getattro, (void *)__pyx_tp_getattro_array}, + #if defined(Py_bf_getbuffer) + {Py_bf_getbuffer, (void *)__pyx_array_getbuffer}, + #endif + {Py_tp_methods, (void *)__pyx_methods_array}, + {Py_tp_getset, (void *)__pyx_getsets_array}, + {Py_tp_new, (void *)__pyx_tp_new_array}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_array_spec = { + "talkingface.utils.vits_utils.monotonic_align.core.array", + sizeof(struct __pyx_array_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, + __pyx_type___pyx_array_slots, +}; +#else + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ - __pyx_sq_item_memoryview, /*sq_item*/ + __pyx_sq_item_array, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ @@ -16102,13 +18259,13 @@ static PySequenceMethods __pyx_tp_as_sequence_memoryview = { 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 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_memoryview = { +static PyBufferProcs __pyx_tp_as_buffer_array = { #if PY_MAJOR_VERSION < 3 0, /*bf_getreadbuffer*/ #endif @@ -16121,16 +18278,16 @@ static PyBufferProcs __pyx_tp_as_buffer_memoryview = { #if PY_MAJOR_VERSION < 3 0, /*bf_getcharbuffer*/ #endif - __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + __pyx_array_getbuffer, /*bf_getbuffer*/ 0, /*bf_releasebuffer*/ }; -static PyTypeObject __pyx_type___pyx_memoryview = { +static PyTypeObject __pyx_type___pyx_array = { PyVarObject_HEAD_INIT(0, 0) - "monotonic_align.core.memoryview", /*tp_name*/ - sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + "talkingface.utils.vits_utils.monotonic_align.core.""array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ - __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif @@ -16145,35 +18302,37 @@ static PyTypeObject __pyx_type___pyx_memoryview = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_repr*/ 0, /*tp_as_number*/ - &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - __pyx_memoryview___str__, /*tp_str*/ - 0, /*tp_getattro*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*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*/ + &__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|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ 0, /*tp_doc*/ - __pyx_tp_traverse_memoryview, /*tp_traverse*/ - __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ - __pyx_methods_memoryview, /*tp_methods*/ + __pyx_methods_array, /*tp_methods*/ 0, /*tp_members*/ - __pyx_getsets_memoryview, /*tp_getset*/ + __pyx_getsets_array, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ - __pyx_tp_new_memoryview, /*tp_new*/ + __pyx_tp_new_array, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ @@ -16184,91 +18343,121 @@ static PyTypeObject __pyx_type___pyx_memoryview = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ #endif - #if PY_VERSION_HEX >= 0x030800b1 + #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 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif }; -static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; +#endif -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); +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + 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_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; + #endif + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); return o; } -static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_Enum) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else { - 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); + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); } - Py_CLEAR(p->from_object); - PyObject_GC_Track(o); - __pyx_tp_dealloc_memoryview(o); + #endif } -static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { +static int __pyx_tp_traverse_Enum(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; + 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__memoryviewslice(PyObject *o) { +static int __pyx_tp_clear_Enum(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); + 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); - __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 PyObject *__pyx_specialmethod___pyx_MemviewEnum___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_MemviewEnum___repr__(self); } -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}, +static PyMethodDef __pyx_methods_Enum[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_MemviewEnum___repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 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} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type___pyx_MemviewEnum_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_Enum}, + {Py_tp_repr, (void *)__pyx_MemviewEnum___repr__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_Enum}, + {Py_tp_clear, (void *)__pyx_tp_clear_Enum}, + {Py_tp_methods, (void *)__pyx_methods_Enum}, + {Py_tp_init, (void *)__pyx_MemviewEnum___init__}, + {Py_tp_new, (void *)__pyx_tp_new_Enum}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_MemviewEnum_spec = { + "talkingface.utils.vits_utils.monotonic_align.core.Enum", + sizeof(struct __pyx_MemviewEnum_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type___pyx_MemviewEnum_slots, }; +#else -static PyTypeObject __pyx_type___pyx_memoryviewslice = { +static PyTypeObject __pyx_type___pyx_MemviewEnum = { PyVarObject_HEAD_INIT(0, 0) - "monotonic_align.core._memoryviewslice", /*tp_name*/ - sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + "talkingface.utils.vits_utils.monotonic_align.core.""Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ - __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif @@ -16283,43 +18472,37 @@ static PyTypeObject __pyx_type___pyx_memoryviewslice = { #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 + __pyx_MemviewEnum___repr__, /*tp_repr*/ 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_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__memoryviewslice, /*tp_methods*/ + __pyx_methods_Enum, /*tp_methods*/ 0, /*tp_members*/ - __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ - 0, /*tp_init*/ + #endif + __pyx_MemviewEnum___init__, /*tp_init*/ 0, /*tp_alloc*/ - __pyx_tp_new__memoryviewslice, /*tp_new*/ + __pyx_tp_new_Enum, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ @@ -16330,2886 +18513,6244 @@ static PyTypeObject __pyx_type___pyx_memoryviewslice = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ #endif - #if PY_VERSION_HEX >= 0x030800b1 + #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 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif -}; - -static PyMethodDef __pyx_methods[] = { - {"maximum_path_c", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_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} + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif }; #endif +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "core", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); #else - -1, /* m_size */ + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ + 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((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_memoryview) { + 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); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); #else - NULL, /* m_reload */ + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } #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_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 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, 133, __pyx_L1_error) - __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 148, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 151, __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, 404, __pyx_L1_error) - __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 613, __pyx_L1_error) - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 832, __pyx_L1_error) +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; - __pyx_L1_error:; - return -1; } -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 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; +} - /* "View.MemoryView":133 - * - * 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, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + __Pyx_TypeName o_type_name; + o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + return -1; + } +} - /* "View.MemoryView":136 - * - * 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, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "View.MemoryView":148 - * - * 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, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "View.MemoryView":176 - * 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, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - - /* "View.MemoryView":192 - * 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, 192, __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":418 - * 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, 418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - - /* "View.MemoryView":495 - * 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, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "View.MemoryView":520 - * 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, 520, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - - /* "View.MemoryView":570 - * 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, 570, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - - /* "View.MemoryView":577 - * 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, 577, __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); +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} - /* "(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); +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} - /* "View.MemoryView":682 - * 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, 682, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__16); - __Pyx_GIVEREF(__pyx_slice__16); +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} - /* "View.MemoryView":703 - * 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, 703, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} - /* "(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); +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} - /* "(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); +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} - /* "View.MemoryView":286 - * return self.name - * - * cdef generic = Enum("") # <<<<<<<<<<<<<< - * cdef strided = Enum("") # default - * cdef indirect = Enum("") - */ - __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 286, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} - /* "View.MemoryView":287 - * - * cdef generic = Enum("") - * cdef strided = Enum("") # default # <<<<<<<<<<<<<< - * cdef indirect = Enum("") - * - */ - __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} - /* "View.MemoryView":288 - * cdef generic = Enum("") - * cdef strided = Enum("") # default - * cdef indirect = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} - /* "View.MemoryView":291 - * - * - * cdef contiguous = Enum("") # <<<<<<<<<<<<<< - * cdef indirect_contiguous = Enum("") - * - */ - __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); +static PyObject *__pyx_specialmethod___pyx_memoryview___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_memoryview___repr__(self); +} - /* "View.MemoryView":292 - * - * cdef contiguous = Enum("") - * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__24); - __Pyx_GIVEREF(__pyx_tuple__24); +static PyMethodDef __pyx_methods_memoryview[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_memoryview___repr__, METH_NOARGS|METH_COEXIST, 0}, + {"is_c_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_c_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"is_f_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_f_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"copy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"copy_fortran", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy_fortran, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_tuple__25 = 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__25)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__25); - __Pyx_GIVEREF(__pyx_tuple__25); - __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} +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} +}; +#if CYTHON_USE_TYPE_SPECS +#if !CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - /* InitThreads.init */ - #ifdef WITH_THREAD -PyEval_InitThreads(); +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*/ +}; #endif +static PyType_Slot __pyx_type___pyx_memoryview_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_memoryview}, + {Py_tp_repr, (void *)__pyx_memoryview___repr__}, + {Py_sq_length, (void *)__pyx_memoryview___len__}, + {Py_sq_item, (void *)__pyx_sq_item_memoryview}, + {Py_mp_length, (void *)__pyx_memoryview___len__}, + {Py_mp_subscript, (void *)__pyx_memoryview___getitem__}, + {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_memoryview}, + {Py_tp_str, (void *)__pyx_memoryview___str__}, + #if defined(Py_bf_getbuffer) + {Py_bf_getbuffer, (void *)__pyx_memoryview_getbuffer}, + #endif + {Py_tp_traverse, (void *)__pyx_tp_traverse_memoryview}, + {Py_tp_clear, (void *)__pyx_tp_clear_memoryview}, + {Py_tp_methods, (void *)__pyx_methods_memoryview}, + {Py_tp_getset, (void *)__pyx_getsets_memoryview}, + {Py_tp_new, (void *)__pyx_tp_new_memoryview}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_memoryview_spec = { + "talkingface.utils.vits_utils.monotonic_align.core.memoryview", + sizeof(struct __pyx_memoryview_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type___pyx_memoryview_slots, +}; +#else -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) +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*/ +}; - 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_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 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 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 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 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(); +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "talkingface.utils.vits_utils.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*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#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((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc__memoryviewslice) { + 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_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); +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_XCLEAR_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type___pyx_memoryviewslice_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc__memoryviewslice}, + {Py_tp_doc, (void *)PyDoc_STR("Internal class for passing memoryview slices to Python")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse__memoryviewslice}, + {Py_tp_clear, (void *)__pyx_tp_clear__memoryviewslice}, + {Py_tp_methods, (void *)__pyx_methods__memoryviewslice}, + {Py_tp_new, (void *)__pyx_tp_new__memoryviewslice}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_memoryviewslice_spec = { + "talkingface.utils.vits_utils.monotonic_align.core._memoryviewslice", + sizeof(struct __pyx_memoryviewslice_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, + __pyx_type___pyx_memoryviewslice_slots, +}; +#else + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "talkingface.utils.vits_utils.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 || 0 + __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 || 0 + __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|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ + PyDoc_STR("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*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 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 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +#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 +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, + {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, + {&__pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_k_All_dimensions_preceding_dimensi, sizeof(__pyx_k_All_dimensions_preceding_dimensi), 0, 0, 1, 0}, + {&__pyx_n_s_AssertionError, __pyx_k_AssertionError, sizeof(__pyx_k_AssertionError), 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_u_Cannot_index_with_type, __pyx_k_Cannot_index_with_type, sizeof(__pyx_k_Cannot_index_with_type), 0, 1, 0, 0}, + {&__pyx_kp_s_Cannot_transpose_memoryview_with, __pyx_k_Cannot_transpose_memoryview_with, sizeof(__pyx_k_Cannot_transpose_memoryview_with), 0, 0, 1, 0}, + {&__pyx_kp_s_Dimension_d_is_not_direct, __pyx_k_Dimension_d_is_not_direct, sizeof(__pyx_k_Dimension_d_is_not_direct), 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_Index_out_of_bounds_axis_d, __pyx_k_Index_out_of_bounds_axis_d, sizeof(__pyx_k_Index_out_of_bounds_axis_d), 0, 0, 1, 0}, + {&__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_u_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 1, 0, 0}, + {&__pyx_kp_u_Invalid_shape_in_axis, __pyx_k_Invalid_shape_in_axis, sizeof(__pyx_k_Invalid_shape_in_axis), 0, 1, 0, 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_u_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, 1, 0, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_Sequence, __pyx_k_Sequence, sizeof(__pyx_k_Sequence), 0, 0, 1, 1}, + {&__pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_k_Step_may_not_be_zero_axis_d, sizeof(__pyx_k_Step_may_not_be_zero_axis_d), 0, 0, 1, 0}, + {&__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_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, + {&__pyx_n_s__23, __pyx_k__23, sizeof(__pyx_k__23), 0, 0, 1, 1}, + {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1}, + {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, + {&__pyx_kp_u__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0, 0}, + {&__pyx_n_s_abc, __pyx_k_abc, sizeof(__pyx_k_abc), 0, 0, 1, 1}, + {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, + {&__pyx_kp_u_and, __pyx_k_and, sizeof(__pyx_k_and), 0, 1, 0, 0}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 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_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 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_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, + {&__pyx_kp_s_collections_abc, __pyx_k_collections_abc, sizeof(__pyx_k_collections_abc), 0, 0, 1, 0}, + {&__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_kp_s_core_pyx, __pyx_k_core_pyx, sizeof(__pyx_k_core_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__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_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_kp_u_got, __pyx_k_got, sizeof(__pyx_k_got), 0, 1, 0, 0}, + {&__pyx_kp_u_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 1, 0, 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_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, + {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__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_maximum_path_c, __pyx_k_maximum_path_c, sizeof(__pyx_k_maximum_path_c), 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_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_register, __pyx_k_register, sizeof(__pyx_k_register), 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_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 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_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 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_talkingface_utils_vits_utils_mon, __pyx_k_talkingface_utils_vits_utils_mon, sizeof(__pyx_k_talkingface_utils_vits_utils_mon), 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}, + {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ +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___import__ = __Pyx_GetBuiltinName(__pyx_n_s_import); if (!__pyx_builtin___import__) __PYX_ERR(1, 100, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 156, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 159, __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_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) __PYX_ERR(1, 373, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 408, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 618, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 914, __pyx_L1_error) return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "View.MemoryView":582 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __pyx_tuple__4 = PyTuple_New(1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_tuple__4, 0, __pyx_int_neg_1)) __PYX_ERR(1, 582, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "View.MemoryView":679 + * tup = index if isinstance(index, tuple) else (index,) + * + * result = [slice(None)] * ndim # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_slice__5 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__5); + __Pyx_GIVEREF(__pyx_slice__5); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum + */ + __pyx_tuple__8 = PyTuple_Pack(3, __pyx_int_136983863, __pyx_int_112105877, __pyx_int_184977713); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":100 + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: + * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * else: + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_tuple__11 = PyTuple_Pack(2, __pyx_int_3, __pyx_int_3); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "View.MemoryView":101 + * try: + * if __import__("sys").version_info >= (3, 3): + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< + * else: + * __pyx_collections_abc_Sequence = __import__("collections").Sequence + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_collections_abc); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "View.MemoryView":103 + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * else: + * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< + * except: + * + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_collections); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "View.MemoryView":309 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "View.MemoryView":310 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "View.MemoryView":311 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "View.MemoryView":314 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "View.MemoryView":315 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__19 = 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__19)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "talkingface/utils/vits_utils/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 + */ + __pyx_tuple__21 = PyTuple_Pack(4, __pyx_n_s_paths, __pyx_n_s_values, __pyx_n_s_t_ys, __pyx_n_s_t_xs); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_core_pyx, __pyx_n_s_maximum_path_c, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 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_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __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; +} +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + /* AssertionsEnabled.init */ + if (likely(__Pyx_init_assertions_enabled() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* InitThreads.init */ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 +PyEval_InitThreads(); +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_module ### */ + +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 ---*/ + __pyx_collections_abc_Sequence = Py_None; Py_INCREF(Py_None); + 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 + PyObject *__pyx_t_1 = NULL; + 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 CYTHON_USE_TYPE_SPECS + __pyx_array_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_array_spec, NULL); if (unlikely(!__pyx_array_type)) __PYX_ERR(1, 114, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_array_type->tp_as_buffer = &__pyx_tp_as_buffer_array; + if (!__pyx_array_type->tp_as_buffer->bf_releasebuffer && __pyx_array_type->tp_base->tp_as_buffer && __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer) { + __pyx_array_type->tp_as_buffer->bf_releasebuffer = __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer; + } + #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) + /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ + #elif defined(_MSC_VER) + #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") + #else + #warning "The buffer protocol is not supported in the Limited C-API < 3.11." + #endif + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_array_spec, __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + #else + __pyx_array_type = &__pyx_type___pyx_array; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_array_type->tp_print = 0; + #endif + if (__Pyx_SetVtable(__pyx_array_type, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_MemviewEnum_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_MemviewEnum_spec, NULL); if (unlikely(!__pyx_MemviewEnum_type)) __PYX_ERR(1, 302, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_MemviewEnum_spec, __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) + #else + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_MemviewEnum_type->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_MemviewEnum_type->tp_dictoffset && __pyx_MemviewEnum_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_MemviewEnum_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) + #endif + __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; + __pyx_vtable_memoryview._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryview__get_base; + #if CYTHON_USE_TYPE_SPECS + __pyx_memoryview_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryview_spec, NULL); if (unlikely(!__pyx_memoryview_type)) __PYX_ERR(1, 337, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_memoryview_type->tp_as_buffer = &__pyx_tp_as_buffer_memoryview; + if (!__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer && __pyx_memoryview_type->tp_base->tp_as_buffer && __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer) { + __pyx_memoryview_type->tp_as_buffer->bf_releasebuffer = __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer; + } + #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) + /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ + #elif defined(_MSC_VER) + #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") + #else + #warning "The buffer protocol is not supported in the Limited C-API < 3.11." + #endif + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryview_spec, __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) + #else + __pyx_memoryview_type = &__pyx_type___pyx_memoryview; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_memoryview_type->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryview_type->tp_dictoffset && __pyx_memoryview_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_memoryview_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_memoryview_type, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 337, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) + #endif + __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_vtable__memoryviewslice.__pyx_base._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryviewslice__get_base; + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_memoryview_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_memoryviewslice_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryviewslice_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_memoryviewslice_type)) __PYX_ERR(1, 952, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryviewslice_spec, __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) + #else + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_memoryviewslice_type->tp_base = __pyx_memoryview_type; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_memoryviewslice_type->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryviewslice_type->tp_dictoffset && __pyx_memoryviewslice_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_memoryviewslice_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_memoryviewslice_type, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 952, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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; +} + + +#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 + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "core", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* 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 + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + +#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; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +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) +#endif +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + 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, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + 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; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + 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 +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + 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; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + static PyThread_type_lock __pyx_t_8[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 + /*--- 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); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "core" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #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(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 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(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 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 + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + 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_talkingface__utils__vits_utils__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, "talkingface.utils.vits_utils.monotonic_align.core")) { + if (unlikely((PyDict_SetItemString(modules, "talkingface.utils.vits_utils.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 + + /* "View.MemoryView":99 + * + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: # <<<<<<<<<<<<<< + * if __import__("sys").version_info >= (3, 3): + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "View.MemoryView":100 + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: + * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * else: + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_version_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 100, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_tuple__11, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 100, __pyx_L2_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + + /* "View.MemoryView":101 + * try: + * if __import__("sys").version_info >= (3, 3): + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< + * else: + * __pyx_collections_abc_Sequence = __import__("collections").Sequence + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_abc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 101, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_collections_abc_Sequence); + __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":100 + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: + * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":103 + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * else: + * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< + * except: + * + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 103, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 103, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XGOTREF(__pyx_collections_abc_Sequence); + __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":99 + * + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: # <<<<<<<<<<<<<< + * if __import__("sys").version_info >= (3, 3): + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L7_try_end; + __pyx_L2_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":104 + * else: + * __pyx_collections_abc_Sequence = __import__("collections").Sequence + * except: # <<<<<<<<<<<<<< + * + * __pyx_collections_abc_Sequence = None + */ + /*except:*/ { + __Pyx_AddTraceback("View.MemoryView", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(1, 104, __pyx_L4_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_7); + + /* "View.MemoryView":106 + * except: + * + * __pyx_collections_abc_Sequence = None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_INCREF(Py_None); + __Pyx_XGOTREF(__pyx_collections_abc_Sequence); + __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L3_exception_handled; + } + + /* "View.MemoryView":99 + * + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: # <<<<<<<<<<<<<< + * if __import__("sys").version_info >= (3, 3): + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + */ + __pyx_L4_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L3_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L7_try_end:; + } + + /* "View.MemoryView":241 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + /*try:*/ { + + /* "View.MemoryView":242 + * + * try: + * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< + * index = __pyx_collections_abc_Sequence.index + * except: + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 242, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 242, __pyx_L11_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":243 + * try: + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 243, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 243, __pyx_L11_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":241 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L16_try_end; + __pyx_L11_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":244 + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L12_exception_handled; + } + __pyx_L12_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); + __pyx_L16_try_end:; + } + + /* "View.MemoryView":309 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":310 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":311 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":314 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":315 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":323 + * + * + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":324 + * + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_8[0] = PyThread_allocate_lock(); + __pyx_t_8[1] = PyThread_allocate_lock(); + __pyx_t_8[2] = PyThread_allocate_lock(); + __pyx_t_8[3] = PyThread_allocate_lock(); + __pyx_t_8[4] = PyThread_allocate_lock(); + __pyx_t_8[5] = PyThread_allocate_lock(); + __pyx_t_8[6] = PyThread_allocate_lock(); + __pyx_t_8[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_8, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":982 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "View.MemoryView":983 + * + * try: + * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< + * index = __pyx_collections_abc_Sequence.index + * except: + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 983, __pyx_L17_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 983, __pyx_L17_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "View.MemoryView":984 + * try: + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 984, __pyx_L17_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 984, __pyx_L17_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "View.MemoryView":982 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L22_try_end; + __pyx_L17_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":985 + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L18_exception_handled; + } + __pyx_L18_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L22_try_end:; + } + + /* "View.MemoryView":988 + * pass + * + * try: # <<<<<<<<<<<<<< + * if __pyx_collections_abc_Sequence: + * + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + /*try:*/ { + + /* "View.MemoryView":989 + * + * try: + * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_collections_abc_Sequence); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 989, __pyx_L23_error) + if (__pyx_t_6) { + + /* "View.MemoryView":993 + * + * + * __pyx_collections_abc_Sequence.register(_memoryviewslice) # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence.register(array) + * except: + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 993, __pyx_L23_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)__pyx_memoryviewslice_type)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 993, __pyx_L23_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":994 + * + * __pyx_collections_abc_Sequence.register(_memoryviewslice) + * __pyx_collections_abc_Sequence.register(array) # <<<<<<<<<<<<<< + * except: + * pass # ignore failure, it's a minor issue + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 994, __pyx_L23_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_array_type)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 994, __pyx_L23_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":989 + * + * try: + * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":988 + * pass + * + * try: # <<<<<<<<<<<<<< + * if __pyx_collections_abc_Sequence: + * + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L28_try_end; + __pyx_L23_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":995 + * __pyx_collections_abc_Sequence.register(_memoryviewslice) + * __pyx_collections_abc_Sequence.register(array) + * except: # <<<<<<<<<<<<<< + * pass # ignore failure, it's a minor issue + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L24_exception_handled; + } + __pyx_L24_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); + __pyx_L28_try_end:; + } + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_7) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "talkingface/utils/vits_utils/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__9 = (-1e9); + + /* "talkingface/utils/vits_utils/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 + */ + __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_11talkingface_5utils_10vits_utils_15monotonic_align_4core_1maximum_path_c, 0, __pyx_n_s_maximum_path_c, NULL, __pyx_n_s_talkingface_utils_vits_utils_mon, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_maximum_path_c, __pyx_t_7) < 0) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "talkingface/utils/vits_utils/monotonic_align/core.pyx":1 + * cimport cython # <<<<<<<<<<<<<< + * from cython.parallel import prange + * + */ + __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + if (__pyx_m) { + if (__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init talkingface.utils.vits_utils.monotonic_align.core", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init talkingface.utils.vits_utils.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 +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- 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 + +/* 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; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + 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); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *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 +} +#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 + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#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; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + 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; +} + +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + 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 || CYTHON_COMPILING_IN_LIMITED_API + 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 +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 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 *const *kwvalues, + 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; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + 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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 = ( + #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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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; + } + } + Py_XDECREF(key); + Py_XDECREF(value); + 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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + 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; + } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + 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 PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE + 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); + } +#else + 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); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +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; +} +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_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + 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 + +/* 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 PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + 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 -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; +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + 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 -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, 105, __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, 105, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error) - __pyx_array_type = &__pyx_type___pyx_array; - if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __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, 279, __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, 330, __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, 330, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __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, 965, __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, 965, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error) - __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); + } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif } -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; +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + 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; +/* CIntToDigits */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; +#if CYTHON_PEP393_ENABLED + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); +#else + Py_UNICODE *udata; + uval = PyUnicode_FromUnicode(NULL, ulength); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_AS_UNICODE(uval); +#endif + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp; + PyObject *repeat = PyInt_FromSsize_t(uoffset - prepend_sign); + if (unlikely(!repeat)) goto done_or_error; + tmp = PyNumber_Multiply(padding, repeat); + Py_DECREF(repeat); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyNumber_Add(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyNumber_Add(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + return uval; +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(int)*3+2]; + char *dpos, *end = digits + sizeof(int)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + int remaining; +#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 (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (int) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (int) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (int) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); } -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; +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(Py_ssize_t)*3+2]; + char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + Py_ssize_t remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (Py_ssize_t) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (Py_ssize_t) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (Py_ssize_t) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + CYTHON_MAYBE_UNUSED_VAR(max_char); +#if CYTHON_PEP393_ENABLED + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); +#else + result_uval = PyUnicode_FromUnicode(NULL, result_ulength); + if (unlikely(!result_uval)) return NULL; + result_ukind = sizeof(Py_UNICODE); + kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; + result_udata = PyUnicode_AS_UNICODE(result_uval); +#endif + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); + if (unlikely(__Pyx_PyUnicode_READY(uval))) + goto bad; + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + CYTHON_UNUSED_VAR(value_count); + return PyUnicode_Join(__pyx_empty_unicode, value_tuple); +#endif } +/* 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); +} -#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 +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!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 -#define __Pyx_PyMODINIT_FUNC void + 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 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + 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 { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_subscript) { + PyObject *r, *key = PyInt_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } #else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } #endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} - -#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); +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -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; + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { + PyObject *runerr = NULL; + Py_ssize_t key_value; + 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); } - 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)) { + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + __Pyx_TypeName index_type_name = __Pyx_PyType_GetName(Py_TYPE(index)); PyErr_Clear(); - } else { - result = -1; + PyErr_Format(PyExc_IndexError, + "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); + __Pyx_DECREF_TypeName(index_type_name); } - return result; + return NULL; } -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); +static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { + __Pyx_TypeName obj_type_name; + if (likely(PyType_Check(obj))) { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem); + if (!meth) { + PyErr_Clear(); + } else { + PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); + Py_DECREF(meth); + return result; + } + } + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); return NULL; } +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { + PyTypeObject *tp = Py_TYPE(obj); + PyMappingMethods *mm = tp->tp_as_mapping; + PySequenceMethods *sm = tp->tp_as_sequence; + if (likely(mm && mm->mp_subscript)) { + return mm->mp_subscript(obj, key); + } + if (likely(sm && sm->sq_item)) { + return __Pyx_PyObject_GetIndex(obj, key); + } + return __Pyx_PyObject_GetItem_Slow(obj, key); +} +#endif - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; #endif + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; #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"); -} + goto invalid_keyword; + } +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; #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(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ - PyEval_InitThreads(); - #endif - #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_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, "monotonic_align.core")) { - if (unlikely(PyDict_SetItemString(modules, "monotonic_align.core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } +#endif + return 1; } - } - #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 - - /* "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); - - /* "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":209 - * 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, 209, __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, 209, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - PyType_Modified(__pyx_array_type); - - /* "View.MemoryView":286 - * 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__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __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":287 - * - * 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(strided); - __Pyx_DECREF_SET(strided, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; + while (PyDict_Next(kw, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if (!kw_allowed && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 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(indirect); - __Pyx_DECREF_SET(indirect, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; +/* 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; +} - /* "View.MemoryView":291 - * - * - * cdef contiguous = Enum("") # <<<<<<<<<<<<<< - * cdef indirect_contiguous = Enum("") - * - */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __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; +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyString_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif +} - /* "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(indirect_contiguous); - __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; +/* 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 - /* "View.MemoryView":316 - * - * 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; +/* 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 && PY_VERSION_HEX < 0x030d0000 + 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; + } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } +#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); +} - /* "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(), - * 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)); +/* 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); +} - /* "View.MemoryView":549 - * 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, 549, __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, 549, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - PyType_Modified(__pyx_memoryview_type); +/* 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"); +} - /* "View.MemoryView":995 - * 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, 995, __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, 995, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - PyType_Modified(__pyx_memoryviewslice_type); +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} - /* "(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; +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + __Pyx_TypeName obj_type_name; + __Pyx_TypeName type_name; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetName(type); + PyErr_Format(PyExc_TypeError, + "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, + obj_type_name, type_name); + __Pyx_DECREF_TypeName(obj_type_name); + __Pyx_DECREF_TypeName(type_name); + return 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__'): - */ +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif - /*--- Wrapped vars code ---*/ +/* 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 && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif 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; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else + 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 +} +#endif - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init monotonic_align.core", __pyx_clineno, __pyx_lineno, __pyx_filename); +/* 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 = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init 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; + 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; #endif +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif 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; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + 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; + #endif + } + #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; } -/* --- 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; +/* 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 && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif 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 -/* 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); +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (unlikely(!py_import)) + goto bad; + if (!from_list) { + empty_list = PyList_New(0); + if (unlikely(!empty_list)) + goto bad; + from_list = empty_list; + } + #endif + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!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 (unlikely(!py_level)) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, level); + #endif + } + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + return module; +} + +/* ImportDottedModule */ +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { + PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; + if (unlikely(PyErr_Occurred())) { + PyErr_Clear(); + } + if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) { + partial_name = name; + } else { + slice = PySequence_GetSlice(parts_tuple, 0, count); + if (unlikely(!slice)) + goto bad; + sep = PyUnicode_FromStringAndSize(".", 1); + if (unlikely(!sep)) + goto bad; + partial_name = PyUnicode_Join(sep, slice); + } + PyErr_Format( #if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); + PyExc_ImportError, + "No module named '%s'", PyString_AS_STRING(partial_name)); +#else +#if PY_VERSION_HEX >= 0x030600B1 + PyExc_ModuleNotFoundError, +#else + PyExc_ImportError, #endif - return PyObject_GetAttr(obj, attr_name); + "No module named '%U'", partial_name); +#endif +bad: + Py_XDECREF(sep); + Py_XDECREF(slice); + Py_XDECREF(partial_name); + return NULL; } #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); +static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { + PyObject *imported_module; +#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + return NULL; + imported_module = __Pyx_PyDict_GetItemStr(modules, name); + Py_XINCREF(imported_module); #else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + imported_module = PyImport_GetModule(name); #endif - } - return result; + return imported_module; } - -/* 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; - } +#endif +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { + Py_ssize_t i, nparts; + nparts = PyTuple_GET_SIZE(parts_tuple); + for (i=1; i < nparts && module; i++) { + PyObject *part, *submodule; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + part = PyTuple_GET_ITEM(parts_tuple, i); +#else + part = PySequence_ITEM(parts_tuple, i); +#endif + submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); +#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(part); +#endif + Py_DECREF(module); + module = submodule; } - memviewslice->memview = memview; - memviewslice->data = (char *)buf->buf; - if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { - Py_INCREF(memview); + if (unlikely(!module)) { + return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); } - retval = 0; - goto no_fail; -fail: - memviewslice->memview = 0; - memviewslice->data = 0; - retval = -1; -no_fail: - __Pyx_RefNannyFinishContext(); - return retval; + return module; } -#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]; -#ifdef HAVE_STDARG_PROTOTYPES - va_start(vargs, fmt); +static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if PY_MAJOR_VERSION < 3 + PyObject *module, *from_list, *star = __pyx_n_s__3; + CYTHON_UNUSED_VAR(parts_tuple); + from_list = PyList_New(1); + if (unlikely(!from_list)) + return NULL; + Py_INCREF(star); + PyList_SET_ITEM(from_list, 0, star); + module = __Pyx_Import(name, from_list, 0); + Py_DECREF(from_list); + return module; #else - va_start(vargs); + PyObject *imported_module; + PyObject *module = __Pyx_Import(name, NULL, 0); + if (!parts_tuple || unlikely(!module)) + return module; + imported_module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(imported_module)) { + Py_DECREF(module); + return imported_module; + } + PyErr_Clear(); + return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); #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 PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 + PyObject *module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(module)) { + PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); + if (likely(spec)) { + PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing); + if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { + Py_DECREF(spec); + spec = NULL; + } + Py_XDECREF(unsafe); + } + if (likely(!spec)) { + PyErr_Clear(); + return module; + } + Py_DECREF(spec); + Py_DECREF(module); + } else if (PyErr_Occurred()) { + PyErr_Clear(); + } +#endif + return __Pyx__ImportDottedModule(name, parts_tuple); } -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; + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; } -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 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); } -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); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; } - } else { - memslice->memview = NULL; + return 0; } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } - -/* 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 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 (exact) { - more_or_less = "exactly"; + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } } - 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); + __Pyx_ErrRestore(exception, value, tb); + return res; } - -/* 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 +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } } - -/* 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; +#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= 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; + if (likely(exc_type == t)) return 1; + #endif + if (likely(PyExceptionClass_Check(t))) { + if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1; } 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 +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { + if (likely(err == exc_type)) return 1; + if (likely(PyExceptionClass_Check(err))) { + if (likely(PyExceptionClass_Check(exc_type))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); + } else if (likely(PyTuple_Check(exc_type))) { + return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type); + } else { + } } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; + return PyErr_GivenExceptionMatches(err, exc_type); +} +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { + assert(PyExceptionClass_Check(exc_type1)); + assert(PyExceptionClass_Check(exc_type2)); + if (likely(err == exc_type1 || err == exc_type2)) return 1; + if (likely(PyExceptionClass_Check(err))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); - return 0; + return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); } +#endif -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = func->ob_type->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) +/* PySequenceMultiply */ +static PyObject* __Pyx_PySequence_Multiply_Generic(PyObject *seq, Py_ssize_t mul) { + PyObject *result, *pymul = PyInt_FromSsize_t(mul); + if (unlikely(!pymul)) 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"); - } + result = PyNumber_Multiply(seq, pymul); + Py_DECREF(pymul); return result; } +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul) { +#if CYTHON_USE_TYPE_SLOTS + PyTypeObject *type = Py_TYPE(seq); + if (likely(type->tp_as_sequence && type->tp_as_sequence->sq_repeat)) { + return type->tp_as_sequence->sq_repeat(seq, mul); + } else #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; + { + return __Pyx_PySequence_Multiply_Generic(seq, mul); + } } -#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; +/* SetItemInt */ +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (unlikely(!j)) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; } -#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; - } +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, 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) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; } } 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; + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_ass_subscript) { + int r; + PyObject *key = PyInt_FromSsize_t(i); + if (unlikely(!key)) return -1; + r = mm->mp_ass_subscript(o, key, v); + Py_DECREF(key); + return r; } - 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); + if (likely(sm && sm->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return sm->sq_ass_item(o, i, v); } + } +#else + if (is_list || !PyMapping_Check(o)) + { + return PySequence_SetItem(o, i, v); + } #endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +/* RaiseUnboundLocalError */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* 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)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__2); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); } -bad: - Py_XDECREF(owned_instance); - return; + if (unlikely(!value)) { + 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; } -#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); +/* HasAttr */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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 (!r) { + PyErr_Clear(); + return 0; } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + Py_DECREF(r); + return 1; } } #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; +/* ErrOccurredWithGIL */ +static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) { + int err; + #ifdef WITH_THREAD + PyGILState_STATE _save = PyGILState_Ensure(); + #endif + err = !!PyErr_Occurred(); + #ifdef WITH_THREAD + PyGILState_Release(_save); + #endif + return err; } -#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; + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); #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; + __Pyx_DECREF_TypeName(type_name); + 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); } - 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; - } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } - 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; + 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; } - 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; + return descr; } #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); +/* 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); } - #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; + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } +#endif -/* 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"); +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); } - return result; +#endif + return 0; } #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; +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -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); + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif #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 (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } } } - return __Pyx__PyObject_CallOneArg(func, arg); -} + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); #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; -} + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); #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); + __Pyx_DECREF_TypeName(type_name); + return 0; #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_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); - } + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; #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; +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; } #endif + *method = attr; + return 0; } -/* 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); +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); #else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; + n = PyTuple_Size(bases); + if (n < 0) return -1; #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); + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; #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)) + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif 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 + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); #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 + if (dictoffset == 0) { - 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; + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; } } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); #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 -} - -/* None */ -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; + return 0; } - -/* 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); +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; #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)); + return PyType_Ready(t); #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; + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; } - } - 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; + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; } - } 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(); - } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; } - return m->sq_item(o, i); } + Py_DECREF(gc); + #endif } +#endif + return r; +#endif +} + +/* SetVTable */ +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); - } + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; } -/* 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); - } +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); 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; +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; + { + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; } - 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; itp_base; + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = base->tp_base; + } + } } + PyErr_Clear(); + free(base_vtables); return 0; -} -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { - PyObject *exc_type = tstate->curexc_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); +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; } #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; +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(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 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); +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 - dictptr = _PyObject_GetDictPtr(obj); -#endif + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; } - 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) + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } #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; + 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 - 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); - } + 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 - 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); + 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_GetAttrStrNoError(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); + } } - PyErr_Clear(); + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_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 - return __Pyx_GetBuiltinName(name); + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; } +#endif -/* 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); +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); } -/* 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"); +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; } - -/* RaiseNoneIterError */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; } +#endif -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; } - 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; + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; } - -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { - _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; + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); } - return exc_info; + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #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); +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; } -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); +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif - -/* GetException */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); #else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { - 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; + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; #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)) + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #else - if (unlikely(PyErr_Occurred())) + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } #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; + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; } - #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); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #else - PyErr_SetExcInfo(local_type, local_value, local_tb); + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) #endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); 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; +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; } +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) #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; -} + if (unlikely(value == NULL || !PyString_Check(value))) #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 - } + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; + Py_DECREF(res); + return result; } - -/* 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; +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; } - return b == &PyBaseObject_Type; + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; } -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; +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; } - return 0; } - return __Pyx_InBases(a, b); + Py_INCREF(result); + return result; } -#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; +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; } } - __Pyx_ErrRestore(exception, value, tb); - return res; + Py_INCREF(result); + return result; } -#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); +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; } - return res; + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; } -#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; ifunc_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } #endif - for (i=0; ifunc_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); } +ignore: + PyErr_Clear(); } - return 0; +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); } -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { - if (likely(err == exc_type)) return 1; - if (likely(PyExceptionClass_Check(err))) { - if (likely(PyExceptionClass_Check(exc_type))) { - return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); - } else if (likely(PyTuple_Check(exc_type))) { - return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type); - } else { - } - } - return PyErr_GivenExceptionMatches(err, exc_type); +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); } -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { - assert(PyExceptionClass_Check(exc_type1)); - assert(PyExceptionClass_Check(exc_type2)); - if (likely(err == exc_type1 || err == exc_type2)) return 1; - if (likely(PyExceptionClass_Check(err))) { - return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); - } - return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); } #endif - -/* PyIntBinop */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { - (void)inplace; - (void)zerodivision_check; - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long x; - long a = PyInt_AS_LONG(op1); - x = (long)((unsigned long)a + b); - if (likely((x^a) >= 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; +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #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; + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #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; +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #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; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #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); + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif } +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) #endif - -/* None */ -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; +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; } - -/* 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 +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); } - return value; +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; } - -/* 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; +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); } - r = __Pyx_GetAttr(o, n); - if (unlikely(!r)) { - PyErr_Clear(); - return 0; - } else { - Py_DECREF(r); - return 1; + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } -} - -/* 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); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_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); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); } - 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 result; +} +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; } + ret = 1; } - return descr; + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; } +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #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); + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, NULL); } -#endif - -/* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 - PyObject *ob = PyCapsule_New(vtable, 0, 0); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #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); + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - return result; + return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); } - -/* 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 PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); } -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; #else - if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), #endif -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + 0, #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; + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + offsetof(PyCFunctionObject, m_weakreflist), #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); + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, #endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -19223,7 +24764,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__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); @@ -19234,7 +24775,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } if (!use_cline) { c_line = 0; - PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + (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; @@ -19245,6 +24786,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API 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) { @@ -19318,49 +24860,141 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { 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); + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} +#endif + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); } - -/* AddTraceback */ -#include "compile.h" -#include "frameobject.h" -#include "traceback.h" +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { - PyCodeObject *py_code = 0; - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); - #else - py_srcfile = PyUnicode_FromString(filename); - #endif 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); - #else - py_funcname = PyUnicode_FromString(funcname); + if (!py_funcname) goto bad; #endif } - if (!py_funcname) goto bad; + #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -19373,11 +25007,16 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); - Py_DECREF(py_funcname); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); return py_code; bad: - Py_XDECREF(py_srcfile); 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, @@ -19385,14 +25024,24 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, 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) goto bad; + 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( @@ -19408,13 +25057,19 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + __Pyx_TypeName obj_type_name; 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); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' does not have the buffer interface", + obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { @@ -19489,19 +25144,6 @@ __pyx_slices_overlap(__Pyx_memviewslice *slice1, 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) { @@ -19589,7 +25231,7 @@ static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; - default: return "unparseable format string"; + default: return "unparsable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { @@ -19639,7 +25281,8 @@ 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) { +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, int is_complex) { + CYTHON_UNUSED_VAR(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); @@ -19671,7 +25314,8 @@ 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) { +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, int is_complex) { + CYTHON_UNUSED_VAR(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); @@ -19836,7 +25480,7 @@ static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { ctx->is_complex = 0; return 0; } -static PyObject * +static int __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; @@ -19845,9 +25489,9 @@ __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); - return NULL; + return -1; } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { @@ -19855,29 +25499,35 @@ __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) 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, + if (number == -1) return -1; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { + 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, + return -1; + } + if (*ts != ',' && *ts != ')') { + PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); + return -1; + } if (*ts == ',') ts++; i++; } - if (i != ndim) - return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + if (i != ndim) { + PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); + return -1; + } if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); - return NULL; + return -1; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; - return Py_None; + return 0; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; @@ -20003,7 +25653,7 @@ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const cha ++ts; break; case '(': - if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + if (__pyx_buffmt_parse_array(ctx, &ts) < 0) return NULL; break; default: { @@ -20111,8 +25761,9 @@ __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) return 0; } static int -__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) +__pyx_check_suboffsets(Py_buffer *buf, int dim, int ndim, int spec) { + CYTHON_UNUSED_VAR(ndim); if (spec & __Pyx_MEMVIEW_DIRECT) { if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { PyErr_Format(PyExc_ValueError, @@ -20306,37 +25957,6 @@ static int __Pyx_ValidateAndInit_memviewslice( return result; } -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; - 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); - } -} - /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) @@ -20359,37 +25979,6 @@ static int __Pyx_ValidateAndInit_memviewslice( return (target_type) value;\ } -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; - 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); - } -} - /* MemviewSliceCopyTemplate */ static __Pyx_memviewslice __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, @@ -20457,13 +26046,219 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, return new_mvs; } +/* 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_type *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_type *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) +{ + __pyx_nonatomic_int_type old_acquisition_count; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + return; + } + old_acquisition_count = __pyx_add_acquisition_count(memview); + if (unlikely(old_acquisition_count <= 0)) { + if (likely(old_acquisition_count == 0)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count+1, lineno); + } + } +} +static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + __pyx_nonatomic_int_type old_acquisition_count; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + old_acquisition_count = __pyx_sub_acquisition_count(memview); + memslice->data = NULL; + if (likely(old_acquisition_count > 1)) { + memslice->memview = NULL; + } else if (likely(old_acquisition_count == 1)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count-1, lineno); + } +} + +/* 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; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +#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)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -20477,40 +26272,45 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, 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])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + 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 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; + 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; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -20523,109 +26323,181 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + 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)) { + } 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]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + 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 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) - 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 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) - 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; + 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; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + 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)) { + } 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 PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -20646,13 +26518,84 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, 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; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +#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)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -20666,40 +26609,45 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, 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])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + 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 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; + 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; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -20712,109 +26660,181 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + 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)) { + } 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]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + 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 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) - 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 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) - 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; + 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; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + 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)) { + } 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 PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -20837,11 +26857,18 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, /* CIntFromPy */ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { - const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0; +#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)) { + if ((sizeof(char) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -20855,40 +26882,45 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, 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])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + 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 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; + 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; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -20901,109 +26933,181 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, goto raise_neg_overflow; } #endif - if (sizeof(char) <= sizeof(unsigned long)) { + 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)) { + } 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]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + 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 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) - 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 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) - 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; + 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; + break; + } } #endif - if (sizeof(char) <= sizeof(long)) { + 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)) { + } 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 PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (char) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (char) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (char) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (char) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((char) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((char) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (char) -1; } } else { @@ -21024,26 +27128,95 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, return (char) -1; } +/* FormatTypeName */ + #if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name_2); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__23); + } + return name; +} +#endif + /* CheckBinaryVersion */ - static int __Pyx_check_binary_version(void) { - char ctversion[4], rtversion[4]; - PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); - if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* InitStrings */ - static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + #if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -21051,30 +27224,34 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } 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; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -21129,7 +27306,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -21158,22 +27335,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #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)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -21239,13 +27420,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* 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; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -21288,6 +27467,23 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { 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); } @@ -21296,4 +27492,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/talkingface/utils/vits_utils/monotonic_align/core.cpython-37m-x86_64-linux-gnu.so b/talkingface/utils/vits_utils/monotonic_align/core.cpython-37m-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..d9d6578d592244ca763ea175efb642f8f188dc9c GIT binary patch literal 1323528 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ë*lck}Ori z@z=P-S7?^64*pEErciU`!|}p^2fJ&eu)kKRqJTD~QLkSeOqq9lhcbQg>0IJW%I3wQ z#gnNP07JgQg4pi=ZX`5tL?jP6-P*tjI`omor)GHyJM>u-8BUH{QbVKLYcVvKeI=K2 z$bwIj)G#}EY2J{`T_<9X=YHD4Pse^;dg;_ZG#fue_dep5(vsA3!=Ax_Ja>b(0=a9> z?_8v9Z|9gnU0{Fb+26VLSDd?Zk+^T?B5~->MJ@U}bz0}trp~ETI;T$RoI0^{ zYGdcrc<0pG&Z#3hrw;9$I=FLcRp-<}ol`42r&e@+9cO@kIT8gYck9Satx|np0n#DX zGKJ9}HaIS`=WuAGM-3oM1nCcd@Kw5WJodEP=?@Wou6^GZuG~qrb-CluFH$h4tJjmD z9pV{H@$9JT1lu?+>cw*pwkQLapDXIMzExWfW0dx#NQ zFC=T$>4qM6pK85ZSH=2t)a_5)bGo5t7xiwn%X{gk{~z++1w5+i`uk5H2?2={6$CA6 z)YyVbg({W^Xhwq0;6zbT@s0&8t+t{hs8t{~Gs<)vq>5Hs`YWxpwboXx6csTf+_hc+ zZ&<71{T!o$qJWo@|L42*IWrT$w!ioHzR&YM{}&%K=j^@DzO23W+H0-7*4mNe0;o$g z8|#pt&J8jmVPor2mu_3@M+V?;&0A$;z}V_BJnXLsK!Pb{8^k!sS8rl<6;JZjyUbXM zsXRIM0k58h(d5Zl@4D(iJjq#)AZR>Y!V^)1tgfyN)uhN2b}nl A%^wZv1T4;d+ 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%0Ar0y`qjiz{i62v=A@d8sEO5(>%af2zgk$9IW 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 uV1>r zC_j4)SjDj7`Dv^Pj5V`mPB1pLs`(^*YD7a!&A5$^$0K-~uj3|xcu>CzPg6hj@qCho z{um$12F9mJwicGqc(9MrRfY6jZ0?kpWuegRu<9#5t zWML}}xvh;eAdljX%BQbSl22k&Mg`fAc)V%zR67a@W&RjFo$9pE{z$=0UNJx_N9d_& z=z}>?#^kH!5y`P3rg9tNz(Ti`gl?NJ2ra&yR`7!?iO`RukWzt#g_G!96t@X69A$N$ zi_5y{LgKoJ;V28NTwFH9mBocg1xXwOH5D4DX=FOXogudEIBHM0$oe(gc*RWIWw+g$ zyKr*6(+YW>i!Q=Z9~1-ASC&X0S$SXmvMdyO%kt2B!Y|oEqzg6Gn%}s^N{-qHm}6`N z%I~a`>CfJtTpgzErw%GT)+YO#o#ASCdwh*f{A3?mR@EmMex4ndRA*Pg1Sq(5x%Qz8 zMpoWO8%M97n_kOZuT}r6hKSOt88@kh?IzW7{f@9a-PcHi$Yw-OQ)$R;KeKwIX^b_J zh(L^LqP~Z^Rv+|14pbR7>t8SL8#)pFrN8;h4vVNy5UIFTY@Qr=@prGwlt$ z)OpLQWp`TE5bp@X&U6250$%8(d@aHGZ^fVJ=Qd^`+AQ=AHnq89E-4A*j=5a(0(mT0 zrluY9Y$EW;Z(++Kn3f9U3%IFN>1#XYN6)I7j+jcPQV`ku??q+=ua=0TxvTnI--=iu z2~-mGd0R#N1&kv7#T6bJ5U#uxe~p2=UVVH|vzM6q;(H*?%K~u;7*&RWo=`R@ZXoqm+t@!IE+`H@(O`5&0sV~t4(!53!j4B$rwBd!L`Dhc) z(D{E8R=9iMe}lNfLFC7bUZ=#$wB%i z^?CbCA^?mc{Y5Yyz!9#z6@M*=eab%3q}dO}XaZ?oqX|Y8ja=GrDVpl3>rFJTr-^6S zExmpa&rqK?-ozSU6zMO&@ywBM<*k%ng-V0Tj6t(MkDdY2ym|(VD(Z!_;e|Z2+ICKP zB~LuV4l%Dr^%(*3+Wu}I4^N2`a)JKZ6>G8u(}NZsV0!ALnW(I$rA;hkZsO_2(eE&M zOoO^`Wvia=!6@zfwxr}a4yC30_ex7Q@Ri2aCOh~_V+)yWccrEK?n+BH-j&AAJI^L4 zE!}!oTDteHw8RIkB38FwE546yLq6D!x)knbb^EnbH1<6>v&YK2>~+{7o$4-o)|@-Vcy<+@)@l6vL)%_zTBLx}#RWj#iE8-L z6l#cR4mHFyi5g-nZGiF}&YnMgEU))wY2<|KNOLX$(G1749EAZyj9x~U=dctZ;dyzyduJ^qT{eVGE1iXuCHrEIhJ_bDK$+3?}j zTOuEDxsB{{!wE?CHdXQcV|}og0+P)QUm+avi)Z9w#^qJw5{|4LSdV^cPJiWjYA0Jd+H1TO!h*;$9PdlK&F3D_EvwR1MdkRzKf&p zQ!t&;P`G#$^c;I&pplkmR}ZD2`}$n>^||ir3%Z}Pg=C1jug`T~pX+J@-Lhr^c1hPw ze`bx4h+LbryhP4%48zoiZMY*}nhWh+EHy|K86Fuvj`Bwdv+*z6b(g2*hX3NbInPdN zxWIIMdFK3x;hpaMa)&Yflkc4^5g(QO)xHNxrg9yq{DTac;XY}P;}$LY z|FqX6%RYGjozAl0DPCrOVeG!Zc_+;Rw>l}izZ(}fDwwxtH~7;=8+aA%eKsh|?H1rQ zMv|+F9rHZB#cNi=#|vENdGi~9wUL^t6iA^3?&y5mn!C|8=>mD~Yk_^5ZC2xpu_o{) zBQ=WjWT6y>D%$*o*UUWFItQztBLX0QYIu2V-e+^JIWEp}SG zk6-If0#QPKT4)72yw$@nNki|9Bp^Z1nrYMWOR!eqgI+Ovbs)(odoYt%@+7wC_83=t z1MpNMHPN`x3cRH!RT*5q9-9YVZzQRD^Sl@QD-D^NY8%bH%r)r(X}p*hT6eiU{0aM)h5eIJ~i))_xHE zyTkqa$2PHTWx%uzTcKmOv*jn2D-X7JK;$y;+$}XF?#$|YFSfsYXFCQ)N<1|pFPiac z#w~W!F)&i%Lng8uN_7uvp-^l(`|zaPNTZP`E_>)Si2I}2_i%s5WeQ8~<~!z7xw!1{ zjv#Kx#6;~jBQCmNb1p7>8>AhBWhQht*RczXYOe=wF)qoJ_?`G@%X%RCG<>;6*#qNg zIPe@M%PmqM3d_TqKopj^0#R6gS_Js#(mi@}PxH<_qc4FdAq@}vjFcOOzzQmxaqDIW3!j?pIyVmE!9oM?+ zH*ni`fB#z02H*pY)C}0XThE)|GHCIF{GH--0=$QjnyM6dk-jkAsdA6E=B8bfE|9MQ z6khJrnulABhsK(~STpP2L*8N^Cj5u_Y>PDWMe2Ztn7Y8HoYW1)DJSNs8W#R&`*5G$ zHvz|uq{|X85gM(|lFhw))s#_PoQUEpJaU_WXek{Fc(2F>JlsgyF8KaN8*W^mC^vFgyb>HZ9yFkS0!z-ygrQ!e9vGd|g zmGx;=8BAL>8mL+Ha;tfs9ko+~(WEft#)^?CoB66vu0&z-<`u!#+xF*O8(f?1*(sSf z@JD=^?_cocD`15uX4K-m<^*5Nc%f%g7BOv;w(enV%EEAO@PV#JR#gXBs_x@eU${3o zRxJeQ^EPfEpzvl{r^=bK^=YU2Rwk*?oP3?q*lx08Gw5ekvk1nDQPV;$TxlNu7x#1~ zsna1G?Jp^48WTr`I{F9cz`)XYvPez%_B-n{h|BtjawE~ zi&aASKlMzbhv|mp;&LD{Qa12XQ%KkzYH&W1UT<*k7{4P7UKUAL8zkBy>t{y7wzi#f zW~Z>d)F6%*Qfj&UMrp9T3ctM2YdMin`C!bIAr6SOWy|NV{4s9%TyFVXZuwkp`P^WZ z&!v{DW~u2qHU{Iv84PTv-Gh^~lZD$Sw~~0b*hwL7+e(3KY&dbuZ>%#kL~Osz+|dws zHgiYJgp%^9o_c3!XWLmUUrg*YUrp@DtLXYCu4{g)qc>v~n@`l?U>qv1qMv1_-)Ki6 z0pIDQ3E<@}?8Vj1hVie|Ji$8t={^9=lrj?M$G$j|XXFfyp)aZdq~w#lGtQiEF!s+G zQnEe3>~B5qq23v121!YI$J^v@^d__Q;Zplmc!nq3pc;dtOS(XMpR$pH3=B#Oogn_Z zj7L57BkXc3NB;Drjg*3VzI%x>OdTo_%u$9P;OlJ|ZIm%w+fi0~K(boK8sL{&HNks% z0?YyrH zth}GzBBqb;W!-f5YWT)u!sY$wY2igCrtWPEvwY1?F_`LzMOcpW7_6!pI=^B5Q$Bq3 z75Ce!I<-~#Qe)%O3G%Iy@LgDa#F@vOTUm}9e$q-oF!sx^1pF&AMgs_DWRs;dusz7( zqGMXw3npbH-+-@gv4P*=eW43HEH1@>7rHZ7)?gA_8UT{LY69tt@0AArl+Wy4V0#>W zl7)m2l~a0Cp3<9G;1Ecy362Sz4Ux_B6wNAEv-k%VFXkf^0w!3R8B9*EwZO?HA&^OG zxH@}lO@U|$Up_l+Ms>QNwwmUieCaT(zpS%;KFNOx#YGm+%UZDp|HNrW)!>drcDQ=s z-Zh0qMqFB*y8q~bD|DxyuEP){O%WdExS{H(%-Kpytq9#*-X1h{{>_f^xs$CmgP>xJ{9Lz(@`i36}uX<$s0+8-Y(bgbOqJ=9SB+-2*p zpTP{*?I$e;vAoSci2ZH;Gz$jxLR$u&=@0{gg!WQjiELTHOvMsQx+6(T zPaUeZGy`qBDgAg?K4;43YE5*U3$x#?SzO6~#ul|3sOqw60Qoxo>|=xG6Ma10#F+U7 zA1AYALfG_qpw(eamf-@}8lDl?8g|?MQLKs#S2&h+tE|H5Q*qq&wK}OUT)DVq%QdzP zXY_8ld|}AqSQ?~6Vmk6j&9sqGxtbsKChi%1#h6E)4<>HW=%NZeIjVAuoKae)$&zXS zre)O%Nkk+^btmyed*|;fHk6a!sz_@8P_>)c+!B^DEv-ftg|FAKFlYt$p;o`OuXlts zOx(qHY!b9}Np}PaIj~E$c#-y>oo;u4HpHJ**Niyc6QH=$mO5srn$9bxOp6xnRv|Y! z$+u0~9!aYXEqYGo-E4db%TIRdPVupBmG8oS&zDrI3YRhYC1DsBQi*bD$Avxug~Zgt zrI3&^D;h#BZZa1)nTyNbC0t0mxm=v@vqtUaQtd+d@#eN!JIb^GJlRNl$aBtHSBxHT zvK&|5H@pH%lYj5yZhlW?7}*?4_mK)rnWRd7?=@T~p^~gjQ*(x@XWcfFR@!DN-@aIe z=BWGSXf_aWL)D8bg861kVx^V-5Jz3v?xN~#2JS1F8C~kW-8*v^h`5p_npdf`wiU=I z+>P#3``cAfyw=LQ)yP0xy$)KrEJXZKc9e(%uXNHR@Uiym(cyL*rB@nNE;E3i>S3hx z+sFuf`YxgUAhB1sP(s7Ux;j(9cIEtrSFf;K%miXib;&b8OjETcYD!OY{bzt*YZ*FG zQ`!+3fo)wUvT3rdYp&^fG<~$o-2_B8)pWgU`u@lWyrQM)`kE4I6_zeTwhxXz_c8%G z&4VB5?aTsENJcmyjg%G$!}fcJv~s^zD_}&+1P(;>fUW3flJg&>qRpc$0aQQm3q2{i zz}iWhfvBN1!K8+$27JD|X)}(ePiRf>KS#Dale%OQT}Nx~Z{4S#hnpL}`lIp5k8)xC z2`%fvZ+25>ftW0}%MSssXax&QYDlnvxIr}rN0-bF=8{=la&xOuFg_8V58{&M4jVhr zP2a;A3;?Ps_)>R97l>uD8UbRE)=VuDwlv1dhDAhHY2awlOlnbK3ADI1fM5!qR;gf= zl&j=74`pg9XR2r5L{qd<&QvX>wbW=}`(dU*^lI-~q)sep*XG|@9ougT4WgrXVDP&6H0k*xzxDG#Zr#%Ch`W8 zmWDtzA>)|hEibPSY=pF4_Oy*=*E0m8#LHn7U@o+&;|o z=+YE`m&iW#7US8?CR%Aku-~i|M>JYu?3FPdNC%NrNZS@t+O&|;mWw&0{-Mzy_}D+2 zi<}&>b_f@cun1RAEEXu_xwRgPP&i!fP`azzxgL11lV*UJ5$aOH5_x_ah$S*Q z0I@{4fM;5+2^SDMLkp>O^7?V}bkDSPnIGFxheRwvSEYg1nJIE#+t+l90->O2OCTit z94kS=-K|QHaC@u-1+TX%x#0#nBO_s8sPM!;x10}-0U7gv{CbyAQT+`5t<%P8aKCu) zY*#f<>+LlyZl>ju7H$4Pv>DcGLHq0Hjcd(Avfe%N(3;YXMwNBSAj(PQ2OT<)lfpK0 z(2E?R2S~5mVu|+m-mm9?WQcG9ueJ!uP9N|~PFkOONw{zb$DxXPF!vd|US>Lx#WF>s z$V@X6uy7%pv6b(abJBkxl{kGm=bsui6@$>P0jhTbZR5ER+tF8hHD<-A(33 zj2qS8aFFLQQwyP^z#(QP^wd`9y%xpNud{YfTAD=xt3RenTQft{)I^v?tE=#!RK`&XtOMUnXoS zubIEw)M&HX>OR$uq6iQR#W{PU9L`Z%v?d@rX;mTg;V!fbyu?UD)hT;}FORe?4L#aS zS3W#~QA$f2uc{xK6p~o3s8c4@kes43Ei_!Dbz@DkQ966h6xnE?+*?aEpJm9_IDCz&R&P18J=hnU5z~rV-vXf7VviFR9XWrBq4isV|2sY{Pw$)j1Ov z2`rQgYoXyPWhy-ko^#3S_1+7;47zwAnM*S+k$J}UFd1d@*3ybaC08SQu{Pa@Z=DUr z&E;3>n`N1}(goRaxz|9mN0>O}1Eb1NHJ&N5OQ$o^ukN(TYhMPWTJ9>he)`FveOax) z;LuD1q@8nJNbD=^D5(Nm|DAA37HYsrBL(+T+T{n%h}iV_B@@5zw_)7?yoZrwfAZYU z1tUxUX`dRw7k$sUuQ9mT+seK-!xhlGtgZb_Sq%z!wcFICk@uKnWlLKr#XW3d(g*^T z6Nw+Vof5m4aE-2S*DC5F$e5yo4-MPQzc(J@v}PQBQvo}A`GN4~5sFC4W0vhvrg zk=R)G@b89pC+#Sc9Plh7X&}ItIZa-FG5jT`t**hhIBl#3-@}7AUV|Uwv^6#OB&V&d z!T4gRTIVVCbLU%GgYWYFV2+Ne;D8=N*?ga6KHYijThowl|H(}`5S zG%|YUgFnLk9S`>u@LtwyhpW?WuE>FL^P?;cfP^RT*?IgUe0i>9s|ud0MVsqgoAtn! zHn+Mqv6c0CE7`mBd&HOYDq4z}Hw|pHbWR7mpXZ~>G_Ym2@MU&Sry7ZW&I!qY^X0hf zo$j>z?p%esR%j>Q19Fs$aUcrIfd1!J^UjTmdBYoNI7VV)YPWnCx@B+!@6!B>I2ZFd(0GG6;9>%OEdgtf@$%|0e z&Yx^YZ5RADr>&~NpLN>m8vIkIjn&{iec&0d!4GoUni~8}r>(8Q=Q(X%4JMdF)e%0p zUGID=Yw#{U@T{uA<4#*$gJ+#KR)b&ewDB7JKBujz!QXV++S;+L5Oi=GG8_lIBeDUn z^>%KWiB=w}Zpx;jiNCWD#~8{dlTI}Mzr>C*KLO7-lB_syo~Q8c$OrsHD`VhMMhYuqO25Cs85e5i`zHQ=KZJDy@cu?(W&EyvY6QRGdgtC|@c(#Q*~*yD zglx06_B3VHeDJ;9rY?=V)g&uh+DgfDVF6Af2vkla{`KvY7}nZ%q{Oh+z9S`ul`&yl z>|uN|M#oq^IrZXBu8eQk5uzU(>mKx@Kzh6#rH27eHIfDb{0^tBs=-$~ZFLR4$!TLX z_|6{0@f!RPr>&{MCpc|w4aOHbIOB}(JD+^E-ted;v#yN6_jB6n8a(5)u^N1~)5dG? z|90A%8howO*4AJ;(QU1a3HMDF30aE)$1DSy6)!n(xcO1|fP|;vqkw;e5BH#wkkT=P zl`-1<#GpvmBhBwl1w0mP}_kt^9#NlvZ+&OW#cV$e&kFzw>0i`e$ z;a`r;>J|+zZcROmSx0*3=mN=$rY?mOeK1;CgU@%`sv7(Wr>(BRKXTew4PNd8&v*?U zbK063yxD1MYw)X`wyp*fOkEih&96J(${PH8r>&~N2l-&Mx&}YNX=63`6sL{X;I}(% zO%47hr>(8QzjWHV8qDaTI;X?SAS>fPWmD0_2Q0*dty$SU!~B1S9c6w3zSc;xLcQ`V z3V##%fFF*0*PKP+^N|nuoyfQSEDHY-`GCU~25I-Yvnbrnh@v0xu*kRLEDDc^e88E= zcjH+Uo*VgqFNu6NpGAS(k#puP2}<^@`d+-alAo#lfO_J4L* zYdqGDGLQmadLrx6N#M(j6jsKRJ{K9&X5<+&6Z~awAiI|pDjk(GUTA_p<_&a#pD~gI zd|UQAS7Gt`P!sqpV^uex@&{TpFd}7>{fwc^VPW~YvoiZ_{)c7k&Po<-FFGXCwyO4c zPKe&D`>t>gIAxND!jH^kjrMM|xa5ah3+h+!3!Ek&Br^QhPFr1rzvQ&B8vJ{wjo0A) zJWgwB@FShJwgzKmX|30*ey7^U+Bw?WTUmoocba^7$?&_Jwz>v?!)aqRxZ`?_*WiPk zwx$L@)@f^Na6kPQxyK_{{&Hc7EARFrnJgKk(oU;onu?ugm3JPxWocX)Db_5t5NO@! zhBSS#9cBCh?s&eBKfs?FDU3gq?(+g?1m4d`fiZ2qQ@w=do=4T97pm&?obeB)#J#-P zE|BK?j7rZpfnPBx>O>5=i%C=(7?IM?PhMzL+F6;mJu2<2WYPBirBSJ>9%CMVpGS8B zc$JZctCO!!LndWvMz$r7$_A??y}jKloo3CdYr*ez+Nv77!)dE)@SQzWV>S43P8+Ym z^G;h+gD-X3+8T@j#lcDpJtlL}`qV`-ucjUvbz6~NTx^7S3}3#~nvzQ@AWg{!w6@k1 z5Gg;=b$xZg$f|ua$B$&qFEFwoDt3TX-T~-Z<&mXSGxY-Hhrcj%?Bney;|lQIFAAr^ z*g)wcMioZj6YR4yXSjV795S}eo8 zv+m|>B-0QbYNuPHI5k?MxZ7kvU)^RjBN=q8ViZAd(Ic(8xEg?IxJt*&LduRh6Dky# z(&pRcb3YgsaQ|#anI(X4{}9)6n}EMGQt0lK_W!Um0xvRBV5D@ZGfo4qa?&Q?=X&Z= z`dMTIF8N4%@k#04MwPJ@cytdVrKd(l;D>q`+kR3^GWS~re$@Qm%DKA07`oX!blFrE-_|9l1c{+Wl>%QK{R)f@+mt#?YvM87BZC3X zDOrt)S``~HNNK4>N<(puJWN6vgV0p#pekx94ZVnp(!l5{>Jy-ns?W4=XjL%k%R>9v zLzw}AimDuWQk?P~X+nF!y|cEoWuzf#pF@9+VV{OlRo#(x$wwx3)*K1Ki~mAPLgfV)_$bb;KPhl~kHNRjrNo`3_YLMAN z%1zL^d1}w3DJxc`(Jd^Z^jotCBLc#Pu=g))y!O;Z@*lm6+S+~YZPgy_)o1BR=p;^I zQi_daBivAhC_BAII1^S|qXoh{)Y5;oH3Ca7 zF(Y5;WDgu^&G1M4TYMGQZ(+wOMDjLo#n)3z;e}4Xl9XnD=FN72Xrk9wV60Owqzy0R znS-p;vnCSH&~aEP6k?8Fs*3t7v!pu!qex$I#Sv~cZ^f4;EF}wF3(wH({Y-sXVF77g zFXzFiqFzWFE_r68N*9EMq>M~2H7%A_!#nIJZK8()8m<0c_Rc&&vZBcUuc~``?%|dJ zMY$1VafVC0R$Rqnm9?w8x}DKJ1YrSXS55(iX%G)kQBV|A@Ug5Y-WMv~H{c37xZr&t z-iitciWmGMUdAUgD>J*O8F6?2_|2}oZ$?GNm64J8^1ZIQ^8F5d$*yuwmNHeXYwSa= zg(n1yGf69|6ZMgUd~MdMhv;8+r(*TZ|F@XnciB}-3i#dLqIn+i#RA`FPv8zehTFpl z;B!4`3V5`U+#MsWlRV=D@ZFv?1^lchO#s*Th@Z`3g%KY?g;}K!iADX-NO4oQloGSn@#X9}r_@q*F`pMK(a#PK2g(RRtY1J94XXj`CCW%zh@PaWS!A4 zph+B?sR%4Sl5JNl{RX0*XLR4SocftvhpH2As%ZSdh|A^6E)LjMD`WE;WRMq{A^P!? z!pD%evyV5CkC&`$1qMDKdA0w(;bX`LTmKb0C8N)wlTK3I8L<Nk?vwm__0y={$kPg7BcPuMB6=FkW_PfR2Y)HRyd1EDuwJ+Q; z+l^?RF1AU(iC?BCb}+bCAf>S@w{P0qZ3^34xT_Q?;L)Bm4gBnuj>{D|TK99Wu1ndP z27Y6kn32}4MioZjrrXAhw4Q2IVFX@!|Co{1hm9(Xz_0Z%mc8CsD$%;14^0<%($>yC zS;>H(GLlBCThqEaFamd38GP&3v>s+ukqDgXVWf3&U<6*>!$|84AOCUSd!m8r*0i?r z@gE0n9}QHurqv0Iz^NWaS}zQYz}NOL()vnZ1b)AVk=Bm_Bk(spjI@^d92p007Uf8{ zrnNdS0w;PHX-x-4;GsQ?w9W~PKr+`Q1+A+CBQVb6;@5ym)f(hqp0gct_ANe*XMoIU zHLp|CdZVA=GeEM`G14MYc-vz?mOWj6jmlG14N_L^Y6sb&RwaTVVvo!<_#vglydGXP|YclL24u zD4W|T?qpY8`oItIBRmRxmDOrl@7t1=1EadJMbBVyyqu zkM$Il=#73HrU6zK@u*$==3@KK&L1w7D`CV&i#$YMY)_A_kia|Rg#4H%f=ke-7~ zu0eSoaX(k#A8S{69}@U4Mp__WyeePFN^>%B0-tT9g^qKl7KG;pUf{_IZyUntffsmA z!aD@vb%7UnX~H`U;T?e&_>qKn0fbKnUf{I}?+An&0x$4;3GYG(KMB0R-z2``(zzf_V;av)0_rMF>JKUhEz6b;Z{gsVw@hRZ&~!tQ_c6$*aaBRfEMr*}&|E`EVmu3E6<42_eZPt(DR>XRa~lPo=t;9c=4c$Du(r?UySrJY=<{rC*Ph@P`1O7i z7`6bjOk{R*@(sDb18kU882F$4(9Z&&9e!yoagqI0`gyvkNQa8ceRf(IxbEBEav|AKS9x&%R z(iO<9mudhX<0sT8kcp*iU?!Q^3*@S7EcbUuhJY9PNjAEfL2l}`D|n4(n+7s4 zur&5J_^}@a?&!yP8puvVb%LpRq5w$EQ#LT!AZ(OBb{fhCUh3=GB#<&FJ%Rra)hjT| zv7`}@4T&lMlYznpjI#~QRg_XBsdz#H_RC3Oi*rtKNWwcT71(I1gE?X@wJxmc7e)!o+PsO~`KyM98Rn)@2tbrf1qN2kF=4MZ(0+6YxY~Y~V9~tzkyZRE4 zJ|^7I|LKVe3H8tZ#Hj-$hvYaAIBQ(;=h3a22012tz!L&ryQaZef$#y(4tzs34UP|l z5BTQ5H(b-;L_zp~9}Ij8Y8o6e2p{m8z&BFU;M_s@fZqyy3u_u2MF=18mw|6lP2)F4 z6h7de1K;AB1_u_x2V7={0utvXH4V-%gb%n~;9FYL;8;WWfO`eLWi<^>I)o4Sn83HZ zroo|y@G&_!=U5~^>3B@F<4)VxP)J=qc~Djq-C1*0F(;^BA|A-%E8m#5y`K~x@r&aa z5M>QtIwNU+*5)B+I5MG`XCL$;M}df5SRGeAUw-ethJfq(>y!F{_>2awHUr%}ys!Qn z9;6Av7nTHx858)?KHEA#4)L4WN`t8^U4dgED_b=U&h@2pyQabXmd?N_s&Vs*7|6{xEc2RMX&bf^=S7)1c%? zXW;Fj^WvHY&ljZgl9~o}NICAa$*5tTV0*P-gTR=+w#ZD{Hc4Jsm) zFx1HFtnBc~gK8)gG(O2|%;xU?iju=se>HD-*xgGtzo5r1B)%&GbCs8PM%w;>mZGa0 z5e}j`W);qMJG6Uj>v6rg=jHZ9Il&x|I!?+n$1KVT=6=<2()w0(cLL^q zLO6%pH7%|x6U^0drZ*qT$=wG#L8qP8g?4YOoM7%#9A|pk;;0NB*DYGD(h;Seu(aE5 zY@5@TLB=+I^^0TIej^<7?_zhRJS|th1{vpA#vr2|^A9rSG5;VVAM-QDTub90^AC~* zG5;XB5c8)Q5r0NLaNTmjf>K^AlH=`>5tkQ={UasjxB3X?Dw%i34uj75ckb}F%=x$M z;Lo|3=V}o+98Zi7GWcTn+jsD%tW0th2xe%7^T#`6le;wF!gA`hazQ~}eI5EA|_nk@4 z5TjRq7WzZu?AIaPv2OmT!9V$Wy5ALw>O!k8Y^2#J`XsUS}8J~;N{j95aP3(KOeukCMKPj|=DuFw~pScAnaA7X#P zixbTWZ~Cl4GtWgP{MY?m!QY@Hh;qpNb+P*|HghN?&kNIKLP)F)$`+xlG|LQmwJ6A^OL*skG7`*79djHrCu_6s>`YZNR-*1OGY`-mZ>W3BJH+a+JoH4SxO1AGD%X z)er0{;|2WXAKgc?QUl-mCr8r1MwqB+eZ{E42ps-%%t&hwqY5MNBR!0?hW_GJ1CKS5 zQ%&oTzj{Vsbx*9C)?P*x)xg7h7-=0J7=iEXVWf3qU<7VqUt{KMoPQ7q`ii@-z6*Sm zCrtrwi9*z^X;nT%Q@~h#{+B+@pMcC`({F9`cQ)->;K2{|7L5Y0_oPYS*F0$gc(G55 zNiqfFWljJwUR8q6@xDz0&-bJW;FJ8=PXeFpNfW>?`eB*`Uh7E{KtflTtl{sS-Cz-` zgQ8f0pX{SB3aot;rt&CE5rxI(ov-PmLP)i%3T z6!-?C$$jiub6CriRz~J$e{*LsckSIyvvvjl+-P#Q0^H8VL)lI-{PT#m)TUMNG+UvE zanas!!^@vVUQ)#V*^kIf$w&O9Xi3EY?j0EgKG0~w1{^Va)t}UMrKOV)+k5GE*_?cN zlxJY3n3Q}VUdh<~d>wv$!dz9YVEmK5K(esuOCug*29%srd0?ia$O969MqV0$hS=+> z9Gdg&lxxJ$FA(?lV>u1n#gh&N5*yh*_KVDKea~s&pFHVMAn_4lz(GUxa-aLtz}I`y zVL+lM3ewmW_P=gF7lo^V#Ozg3@_;W4MG8ou+SN%F5&Dd|u44@*VdTL)5xUE>om4ST zh>MB?4;mx9*S@LyN=yIgdD|TEoA?EGoGBX?nQ|tbpz7SAgs%i`&(18B_M{aP4Z(L73XrzZ)B6TB`rgtWx4mQxF-+=8sH4Z>Dczc#kJ?OJfWUEO}~OhXmx<14~qpBk?8q2rE*$Lcm>mmzI=$Ad<gfo`6<)O-K0FfKpZ!9g-05MC-mnyNX}7!L8Lz!`fr~v{mysZ z=x2ELfS)sI%)Z7890j6YznT?{DSC{Yx>r70=0xP1eJW^+9WK{G0=25!OhT0FA$$SB zR!RWwKnvf!5Cl|S6F0jP&F=_ZAr7-oPP#yIijtB%F z{7v&6KImDg(Vq9qJQ&1#ofP>%57JY2uUNUSH*M_?4E`dJgt6zJ>fFOV-mspklOEi- zMX^P9A-1aX;ij`NDt&s&n|HGKFyiOiZcKM!Y=}A4Q`&)c`xW0&^f)h#`6R9`NL*cz znEyVi+*jPkHmc1$Zkh1+>NC$XNEqh1@eh3;WgX<3GJams`-GTC<6I*ysOIE*1&&OE zrtL=?OV_SaGlAGB#o^XA&f^|R~FN8}I zlb%QWo@;^hENX4HN-3E6)#Bk5iCQ!R|N3QaRq=QWu7aqgL-*JsysvGNhxISEvm>h_ z-?;CxNn&$p!kyMx5{!9vkWT zKq_DN7^$?RxwANaYDt)0UaC!HTL&61}VX7_1D zw)}Rk$d=zh4iBO9XQs3;&T_MBA7WYIo==1DvW#slJw6$Hx+||KL)-!eE3(M8tN+Nv zXF+UNZ@qV>1r^p@Z_KT#a2D}7`>+p_%j2&ZW5=I}_$OLTm+ zE^lb|CcKL0+1m&0YOQH{uGg3`sdzrV%(Knr;`3^?;27gS zJ@m_mHc&1(#hpBT*shW;z+ZaOB=FZpa_{ocdhiRJ3<(tQAx3hHv>p{0g9QQQwsf(D zo+>YYizkSvs$571A-8ykrhvGhayvDxJ-nS$KwNN)v@omi_MV31)28tAUhydK%bt|I z6Wf-PueaF8-?ppXdSM+(O9$mH5+AW%D3js}jP(A|xR!Wtv-@s6g9}eyG3u+4QD6)e zRY2^GZNJ013LEhEo-~nKq&@RcXIAQT!L}9VOsQ)rVESxtWBclEc4PaxsNP_{6EX=4 zQ6oI%NQveF{%!geH!*j&t4wa-%P(Wj&H%4?t0TENOY0j(mDLOQA8(5pX|1~4O9Y-%cW}%e-^bK>T)$v`8V@Bm?6pZ)B_l1~9<7-A#k>Hz+CPe^9n#f`c zBovJf8cZz}2foN=Ps13ym1CSb$B*nJE-`RoLF!Os)QNroCxP!blBj>*DcJO7KYo+> zNM+ABlHq9VJ|!6w2^Q8L<*gsjtsl>=A7?PG4S@%q?j0HjMh;!+9lF#zG!Dc^as2XA zaxb$RiV;~I9&cX#Ta*?U%s7@7w0tO)a@7Bg7^TT6Lq#4CE4c{+ZfMx_s8RoEl1K!H z)5O@WIuiW>(e%Qu<>Galb&{)-cGGuwTi(P|qD0|u`OR9CJw?>@FO(3HGG~b08wMnl}nzNcp;2Vr4qXQ)K zlnwl@Fh_vz@uZ3O8YJDdCz$#x3V@X2Qc4dkSSVYqr`cTQ+WZ>Vbw;H2%Ib>5qy6q7 zyT4i_;_{xedC%cZXzp7YOSUWWc;LFTI`Qw%fFW+q| zjq*{~SZI{S2w_brsBQV0m3E`Ozy6>25<302sAn`NU4^5np@j>Fh6b<*Gi3h=+?aq6 zoM2IQOf|e4nlHe7duwqJ^W%g~{fIx?SchU6IEgDIw_^Tu0*&Bb^QK`)V}_(WJhQ1=^2A_c zy^-NL@<9U*PgYB~vA)X6E$fd|Mc|KpC7xhTQ)-0^7**XgMADWFW*hVZKbJ>=A#KMQ zhLBO&#$=fYdvjKD2kE(VA^j+9@@m*~U&@jl*uYO_8&V$u31P8;WbHlQ?y|m{orYrQE%zI|H1a2A;j$rR7_8#W#9R=dTP<8yd z*)4_U1g`f2qu%RJ zi8?lLp5E7#dS8?GmgGbCi9UqB9+JJKDJZw~VA`@0A?ke1$aC7n<3G{N6SrL)E$; zSBvbPa~r!h#MICABLw4qHvtMH{?4&`t)g4z$#isx`#6kZbYhoV8yo zQ!EyydgX<$lj~IRJf7TQk;6VYIo&jgU*Yvtjb7e!H1C=1EYyji%!$Pky^&RWG=F4f zfx>?I=w$l{61GOYRBZfjvD~gL_UW;=5B{neOsHj_{ONX`j=S#9V|j{~$oG&h8AxV) zXE2E5rE)v8bRfxM?R)kd$XYRY_^USS!?EZn2Qpk`a-5%SGw?j`KS@6hPNm)eqa(-S z87flKYp!J$Eyr0Z%6$+p(sH>!*yK2Fo;R%I`&%2Oxu!8f^K5^ods2mVt}=CicbY-^ zddzA&P37cJX&f1HoHYMyG-^<8&p3)W$Cbhdj65IwNH-0({=9guSkoQNpY|?>(|O`s znie9l32*Mq7$Uhwfeczg(1Moy&xTb?uECEB8j9)ceEwewxMm*K1*ZoKZMpAY0dpB2 zbdyE*bwX)ad8oRf{+0U<=AZV}f9S@);p+JHRZWXIv#>hv%2P&m8uibcILLSGw8%hV zzr100I`aRfTIFtS)A^Kcnkj9#=h3-ow(dCXXgtlA#2FyYN-d`T@Vv3`VwV&5XcO}U zFK!gbD9SC(C0T`Sh-o}@0YM-U*HVEsgtb&Y%6$jR0TwQF6NtZW4$PVQM{U~NvDtc2Z+-^vJQd)nTq1i?&XRUywr3D z6ILm|z>6*DO@wI#+sCmT|5Y5A=*zt$@DnyR%|Or~X2o04b~Xe{WD9ftu=}F>D z7i1nFjGpuD?y|l{p#L&6#?>EMNR>t9ea)hRRZlf%9Xl;t7xqi~u0g5RrvA*MbkjOj z+HlXKv#sBtY^T4|8?bf^xV|sBz#)MrtO^JY%6%t-8f> z?ay|VA_62nB4d3;1KUPyglGrDq~hQ!28vK1?#tqsSEk0I$f#X?0H%QGky)B+nM$=3 z=due2j&nB?&u3~Iw=nT%XvLBEGv+_HH1TInYx3WyBHnHTKtQ#Gff;?7;=qF~G)*GV z2*H`eOd_Jbv8qxlC3=YbW7sh=4SW0vU;B9UvjT<@q{5 zw8)Q5&42Ha2Dw@JiTGc95={b8UMi7=?Wo>(pn|S)`#@|kah@9wdXl+=_3XLvkQdO9 zLP&L81QSy+9r!?tWD{N*!S+dPC-N!|Oz7pI0FW_nMuA4~yOYkjc7-sQN^4o#YeU)x z+Fx3n;s1PO0{F{yZjQ(%3b@6bBk4QY6E&^w>7EgIv?omfKk7--z^@s}iKF%XzzAG+ zMy!|C*+vxuftU3#(t1x|1b(!Kk=9j#5qNzMBdxmwBXIGHVjF4Q&!}P}aEBg7S_cJ2 z;NhM$0eoIhUs`8+#%bW|dl+ebJum`)-@{02{}=lq1wPV9Zm?*b6BvQ7>0#WEWZZb( zJdL}g@wZOJl_}u2J!t~C`ZUi4B)!$)u21$S*c6cR1AKKfE4nqUcLzq`r+XM_J;CSu z6p(4;RMR@!Gj@SjdD0Y+Y2^CS`f*?cGL0M~tu1_JPXSj(Q=nVZdVOF7GT)p;T2}-{ zAoI;J(z-S<0-0})k=9QFBk&eang9;_WS;^u*_=39%r_ZQ;H2-{1s>{2Q$XgQ6G!Xp zzzBT3ksKqft36{E_;pX30{*_IFRgpd^!W(jdfB+X?t2a>w3FD=qf7=a|3 zW2E)nkYm7`JZTb03c0?t7+_HXJl%%SG17XkAJ|D?JPi3CI4zJwIN4V3AK8+v+YrhZ zgQ>K5aB_T}NqNQ#$*s}D4c-z+c|{o|l52f5Mw$FXRE~g{AJ6wWK8n+4dZ)9uAmm*h z{We_xjkvkl!F_T>T?KzEq!94?Mp8ELgs=aTKsG&bFv&L=Mj*+hY|AVF1Vq??1VY)s zB$luN?=%U@24*iIY(PqvvVlo8VFQwC$_6Ip!UiPKlnqSU2wNWVmi$h#%aOPH@Xp+6 zs~gvO-ppwYJ;GxBcpvkr=UZQ{^YpE%|F#Tga3rtNmk z15<)cD92k*LNvM7ABqK7VGz| zzI0^iraeg&hE00r!=CjVs=jWu1`7+>JTeHA2JLrN16iEp+n1QNEC+=zWYV7QU*5m8 z&gCK}kj@GtP5=p?TSL&qRU;SdZu_Y^3d9xtrlwSJ>D!x}z{*X15#2G7R0FY$$+VB( z{!X$ZzA%v3`%){U;|g2C_wq~mWTCP#kd!Xz$Oh&xzthPQfj2xf9N0`MHKhitDe4U| zt>z7ph*M%4Vp>}pVp>TXqFNCD>t|V9n=njisa;A-%~D!wmC{n9los2gSYIjUUm7jt zPlKhjzqd`2a?Jtz2}#Du!OY4!&8CK!=2JsVGpZrtYq+krO#Ok+*lbCus_n9bEihHp zxrxQHJYmKDVJ8%HJJhORBGF1C)ox*7G?7wK+J2gCu-1l+7Vt1nDxM-g(moDsv(GnD zn1h+)?qLX%6&W&F5rd4u=C8UiY+ASU_KpH~Fwz3~Lfny^o~7LJzmb*}ER5OCm^GeY z43ri1n6J1ZSErW7pT*J@%Oo1QE|EJzU=Zm~PQqe7m22@gyL zS0KTdqU%(uc%HS(uUl31GgHD|RPvA&i#@22Sg|NDLSlKMAPXt2eL|wla?33wmM8X! zLP{eMF9!MKnj~BqwIB1{$%l5m)a*5quk>br-huI`~Lrh~l&#L&4 zL}1}YtEvvPRWZzuY;h1KTUXc4zrMDrr`dU}m?2*X3kmRgBlTSXG3GjB)_8(3 zFka+ROXJVfp7;|G%7P3@ZVQp*sQG~g`nOj$>*Tr$Py6JX$V}Lm>?$kSN-&BF ze`Ta<>55(L>e!Xw&^7xR2kF^5+O#1;G+^(Cf(vmx3>SJ%o=IxA7~tm^bE!6k-NtUV>*6_yR2txA_L1Je zcWZL9K_}N$%-j=9*crG~Fx#vXQvzWODWje?5o|(0p4rA7Ht&frX zdT1ss%eT-mxLL?tPSJzonWT1$0Y0x!=8C1szfCW2yY$oSDu2-oyu_2nf!{Zh=ITUE z>m3(58S>H?aFaJWl4GQ`pHYPo*y&-UH60j%Lv<`M@xnEmM+rD|thc@kywQ^;G5w8i z!1PJrWk!;Br7oZQ3k}m=SV&r}=vRvEW&cN+rgz#^s|c8@hys4Y8#V>RK-r1`u|Bjq1LPvMdFI7%Xgq*y&BI z+Lon@{n|7NBoXAjOperxxq+{-#sj6OKOc(W&bnYNbud@~X zKkQoi)|u*k_TeY`F@4!S{KouD@~eS<@=V&~k?#UqcZtv`Qg4DO-TifkwZwtwDLtV*xW~&ri3G{}Hzwb&=yH&N3 zkCoyo)^RPI?X}zOij_P>WQrx4(JoYj;r8P!4xwLG4cy`PQ;jjWUfL?4E0o%7wl9>^ zd#$80SM9o7zb5Sb;idn2&$f#$+#x&kb$fC;p}#rbrv4M0hM3w=JP9ugjrSJFR9Y%h zX=$?ROZ1iZ4Kx21i7rYnuqeIOuFI<9&zEQ|+J5In+wbc4+*?~A((jY8k09YlZ^zX9 zR&`ciMJc~CPN~1Le#cmaj|0XHq0-m@{KV?G((W|8RkZDTh~a))F*hO6{4l?^_+17{ zWaE+Q5K`(4^E-BDkr%oa7(6_wA|--{Csla(UB8U2O_l4eGtoK_!_utu( zBB9)5J3EFJflu{I=UTRk+@{D+VjX3*}JR|3^atH$a zu_{2SS^W9qL2Y1^%liO#q3AdlW#6ph(I9(OrIK&|a`WhH%2!sL^SZ5eb*@Wk&E~H7HeQBq&_eW+IrAPt~ zywg6CEkinFh2h!M$!lg2PM5qHG{pChvI9&O%F8@&YSpy*4aR29s^%@RzqeKK>pFwj zwz;!Set%70-~W4AN9^?X7#>j5!amt~0Q-fJU5K+-|9hq-2Z<{g0i?3YRA;JD#)Jz< z9tc-jsf2`46dCCVq{s*tkRl^oKnjX*1*22+vdoDN7O(a-xPvW6`Ks1I@u`6XJkRIt zsWv5o)_7UDG}C>b1~8woSsYr`qs-RGvtX=4@`E|XghY9}BCC1&oSosn)|U-mR#~{E z(x&pY{bB1t&k=pPeb2Uj)A~dk3+S1QMZb7!mQ;%?iea#BW@AkmT2v60YF$$0lRe9U<%2M#k~gURc$f5(c9lCc;Ip2< zVZapdpZ?jA+-(xAX`{+q1|HhONbAt2c!|KrJS~<;Ys{!35qMM&BdwPNM&Qh7ERog= zj4Bd=KkH$n^`MTo5%@VHIj?Db(KAi}|LjRq!0(L3*3i1esA3K9wDFjc*4aiCM&PS@ z7-@YlFap2Q!$|Afff4wF9!6Ss2S(sfH@1=1CPoz-f%orW?3<64cL)3Y>jKF`sY*a% zuOrc|X?@9uy$ig~lcs^OP5HNVg`I23+E1BvM;}CT%mQC)q@ikVuD;zGcl)U`%OqhA zG<-CE>SxaEGMgI@eX3W%Y#_7c$p`6tf=}mJ5_cQ#^6VJ~UmHkoGf2!t7Ad-|PsUmD z^R_@D6VLSNFiR@k5J+jzvZd7+_Ow7g&j)hm9D^tMn9UHLgMGc2Ar_Pa*^}orV21F# z%!g-&@a*YhF+&UpfXKq}pL)k*&U)Wq-xamW_x! z(;}lw8@Tq9VjM`cWMc><>EzuaV92XUAo(R+z!4v%$sG+I5J<$5Xo*H3fm2(-giF}o zW8t9?DI1vTB5XiHD3$^5XVEOJ^R3}lm76L($H9}?< zkQyO#zE#s;jD!zJxoG&(f+2j&2gb7DqrqqjACMZ-@G*0!A`OwjrH(X2rV5p$A*QvY zA*R)&A@<7-YD~k(WTVP7#I(*dM3Rc^(R}!dWf#?_Va#)Bc92|hUwsk=pCNxjG#SAx zOLDsn3=?RYfD!~*w16x?YCQPcz8Z}J@l|@_F4Lf}FK^06^v6|t0_heG`6*Jfo>fy7 zQ&QgO6SoVbvM9@J1swd}L|cm+~%fp^+NBG)Q5I zGV!CrG;a_SB|_8?)6s7Mf>;8d7+-eW;>hP%a8f+2Sfs`0N~NSqmoieg#Rx@;AqP9PMP^Q`nDcu;YL2 z;ob5raLk}Myvc#j)ETLCM4R-Air+u_#cz_`7}ZF)^81+VX|pP46mRgOISLFavjNtg zms^i3Lr>thjMS`{${YV{d!66$J+s$f+rX}4Bny;*SB?aQtl$f_b6*1jhN ztSAj10cA@s@^BJ6g+v`?J1?YkGcTlcD=(yUBQGR2C2ZM+ln(TDJ&J*lZp-Ia)SLt2o|uR9fWWh`x@q(}6W@u8teuIM8)eTFg~sq`3>78A*|cPMA2eb<$}uq;S*b z;MQ@|;(h{d5}n&o=-if)9nfiW5bLDVB8T8+L(33Cr_JH3lR}HMgF79{X0&CjpJFqJ z@svA*ZEQk3(NBy~MvAL&F0D)3&m`trx-r>8M!4=yCII-Qcitqh-vw1h&^K? zjjiO!spVdQl)rvgod078nYBx+Q-3VK47{p&&kW)-ZKf=erGC{v=(A-gY!w#EC&yHK z=ttx%H{*+{6RTCtCuBz3l3=O(Gi;{|BE_o55Qx-_Mb)v@s=ZVjl!uzkU}CyY*(~0t zI4{!8O6bgV;n*NJk)~JVIU|3B&GH`qAhJ02_y>{tu)L`yhcOP+3YN;Az7Q!SNnaK; zmagDqnhZ;=sta9Fe0rI%y0;M>kp!X!=*(iEpAyY>@H34jiyd(5C%OqJe@6_QGE#Hn z!(eb#6%51vHYJq?ev;8-(+gyyqipG{RT>+dtNcyH6!02Pn)s4IuG*79zs3e#X^hvb zO>(7ykM{L`iW1(&C@857|VVjjj)i2?}a}1XMluU<&*nFUTI+FgGggQ7zBki2AFJeoD~*AVM;XjjUWI(!kRSUO zMRgBM4hZMVhI~eRF5(1}B~B)ZvRhO)!6b~6Nvo6u45|79rT|Ls*9_IPD22)iCJ`Jb zslebV=OClENj!SGlIrMXE9(Eo=#?HLFmCD{m@$m`p)q>O4`w7|{z1kw=HJ*+jb#in zwlV+4j_{`O2xd!YF#o4bu2x>jqI-OzA?(%d-uYHOg#wm#*OX?;Kl1S0i!^F|y^B_kZ96vPHq|lhuSd+eWiH(4lynmCaJnSq+sh-P$RQqV|<&XP3G< zzjoOxZJ()ci0R7Q5K{vhVroG{+#nMUE17UuwmA^Nhh;Hnhy@c4%f`UnMH7GC4U%+B z!!M-Ndm*JB$=|zZ<%P{>9@QqQ$Thn!_|53n9ByvQL%}Ax}!4f*=sp!YMG;A6xZgj zC7T9OCVKKUk3;W~Z5E*;G|;hyi3B|j67wHVCO#jQ@jI z+iD>8HzEE&?zH8Nax{I^-*Zj@xk`bYt7#CL$fA3E*9jnjT3(%6t&;!WR`i^%A&RTad*Ivs zP>eHyKjujtATf~VTZ~SK`gooP<7pa7$20>A&&u2vJgPUC$FywD&r{V65#>zEhM3OD zhL{@A5Yy1jZ^FHeKL#jYs$XfTdZne>?eBvN0r;QLUR9(3c~;mu40$G!vh*iJIoDQ_ zva99mFZCNRhi>|=n`b*_5y(3hYPwtVMyxoIoXrZICSF5KL*Ee7*q4QB+*6r@j%Hb+ z_>&48Y$a<|cpMeW)C<}Vw&3jTEBGkza8DWoo@^vJRXb}gw=RDa)Tr6QdIfVjz(az- zyVj)wo3lU+?Y-tlbMEu_h`0IiN;}iS@Q<559hx5-zRj+Z#K1p!(wfCjaw)jEU0c;BoWydV7TRbB3r-f^_GPrFZ?QW2n zEU)tdxyoz5Enh-E6x|hoxl<^Vtg3pFjXU`+yNuqv<4JN=@lY?UJaQDwUHnJvSWXJa zoGFeT$CA<<-$lq)H|wx`~q1gm8PPoGP}(-2dk4UvH- zXbmxqnzo6~)fPGaly{}Qd+<=ZLNCb(QoipKXzI3Pcx6kUT3WctQ1Mq-&(C;a-CfO! zN7z-WO4*PfS)X6~z8%Kl3_sW%;Q77=$cz1{z*e<~X=4lu_6DXtrn!7a+WsbWk&fud z@$zyxlptaPi0Z(cnmJVA1(T*Q<4D~z>~RgxGj)EH4(oY1!ZSnVJH%=VPaR70a6UcF zE-h8m5K~PJF;&$NQ^))0IxKTaBpl`+`QTMUEa)nn%*b7s{v&=|WljV8zo%Jv12gr< zj%%U=8$_SwAF_=BKWU_)>bQ1ILIf0{clFZ$w zqox_)s94OE^Bv4(3UT_9S_hrTk#x{gtU^Rm66bG@t z3$X{1L9)NXwP*Q!m;!QbPH|{3K#@hS@F_9@#K-|paWIv*-`Ax}&ubW4uBzj|EHpRT z_1?~FqSG40ywgW_oT>U5PwD`1Olk@N4}ly{(@40|3=&dr(p2*07U3V(FsYg|lT=ef zOs7;sOlMR>Oea)BOzmoj!48M|SvKF$rgkY`YL?PctCW@+rL@$haAXrIJ<(GBG+0Xe zd)ri1qznmIxGNg+Ok`{MAO}%!4SbN3c9gQ62G4DBwzB#}GB+zXxl4I!i0Obd#KDAW z+*6rKOGPTJzr;}F$}487rMQi5Rd^l5W%s1m!8YOHzL1XsiJ9Dbq@ep<)AUKZ>QMa1@EvxQL z7x>;{@WX)w{8Z?=sHSmk-~-+e_!ieRZVr6FUk1JY8vlzEOQ_LO zLgxH}z}q7Ykrja#!5Sht%e5?24`Wzlkg2p(Wa-eREK%;yQh`EBUT|<`Hg{$gXP)A> zma_ziE4PS)DH+d|jOR+SJr>HU3N_f>tQKj|8e*!cA*Q+-A{k388)8ry5JCHb1(E}s zt!&f2n_Z!Yo+(NtNd-pebtYV_xNF^Stnn~^Td)QgMc}S=_;rvUsO;w})P(n%xGU`{ zXFLxy$%viz*ykqe^Gn~iLx?Z3cLU{}7~ngM)OeA4uXA?COmEqt!JE(F+0mgky zRXE^*5}cj@64t<+S};`M922r|52&}YX$GZkc-($e=cmBtBK^n!XCz>#VI zCjGv2^#9D~*9?$|>z|X93AIV?b1HWh__mz0Gw%i293E)FKX&U$_PnrN;zd0SVKm1RFf}KD2 zc6Nc7;l3S?){Wl!F7OAD_1&5lCQEq%VzQG+3#)|@hy#u>wfWv6-67JS^0rO^aYH3{ zYFZd5Y%LMp=X1}Zx7tTG_8kgEt z8F3p|l$JW6G(32t+1dz99Z<&9R{3&5`DTmWe^;8tB)|T}+CDp| zcdQ|iT#Mz^seN{CK7xcZOEll?Gic18pbH9fDAEOq{0yC-kfxCpkVx0i2@0bcb?Oa_ zyrO2oB1C6IV+9W5cc34?t8H9#2*4y$yE-r%7X6b){Wpl7_>FMFiH?%Km_PMz$bX$+ zKh0;E*Rr}^zp|!P8&zu8AZAGCt5#-?Yc8TX1Tsv75VSm(+418PDamY;ZRU^7#$EkF zF$*L=gbT>5laml8-Q~W#%mP2@No#&+km)ELnS`J7RitDcnc}DR!FIpLQ1U@QfifuBIONCr-u@; z>JL#J1BWyk#nOHKv>7Gjr+L!aqc(L#>ukHq-^89{@I!$F{F9NId!*FKhKQSg_3>E? z+$OAZXU(OKIx8F%2ZJ-SIP)kkb~X=tX~JU+RaC`i#-gbRD4u3KtcjWW0k)H5mYP6)sN-s z$8z;!SaP>TN`H?tkI+d~Zsu5O=6pZpsrF6T;1He>+5hM})v1xtvGj5?3wmk>bk$M% z_v}os`vjAkol1L!>Ft>PvfBqv_(&hOX~$+`m>8Wj?WAW}$ql9g zd6=5Ygq{k9UY34WB3*7h5qyYWkS9`^g*X0G{Qb;jOqCqZduFFG7hebfwF?+qLU zw*5*o0Yq@AP!-aT(f!=tQ;B+#n#}Y{iz#%x=Q>p3*@J`Ae8^S5?2t`)&n+-H)^i(6 zFRt#Z66w!fvz#EYUB^}>St2uo3g7Iwq`Cb?+yT)>D3urAXd|$6PrbCU)NQwryJI95 zyr0ozt^gnANfTItgN=5J>1jT;qp61_gPI>XlRG<%=_fLF@=d-Btg6Am@yBNS2>G3^ z<~ZTL)YI>7wRvSuegyTt)F-#4f68x5bub@dW5ZaLhpid==s)d>5$c=NRU0+}Esj6p zdbgF$0wGpZ%oLYoF3z|_ z<|*svi34%Ic1-c8iB4u2_qv)y^BW`&p81tLXdcD>A> z1x6rh93zrTSDZqHY@vYLdAXCo*nm#KfDQ&c%lkPAjBV;q|+Si9}$%k&8 z`_L`<(5-VHx+NdFb?!sAZC3ere)9ASR>D^F+7URAM@s4?fo1B-snk_K-^H*#|lF=mOC|>J2i$=dswc?`71C^ zzp<>Uw%YFdGZvU>Z?LP@R{X+NrGbBDe9eOX)T2&mR>`ix6^4pPydVlbI1I=> zen8%`$aT~>gWv9H`_$lm8Yr^hAzI)Z8Km=4i_ze3@ zwg^w#s-|_JQRPr(5aXot}_DA@lKMN#7`$*dGMLQY~R3po|F-K7oQ6 z(G*F|i9SlriarYFq$o8n8V#%v5)gx=c&3I3DK+3;9&w@iF*XjG#o#a|qlD>1pF*R# zIWxIAGr2k0pCMaysW2s|okeYMc{bNEo9oDOva0s96bhoUqjruDUt&&vY$5e)@A^xI z5u*=?o|9yy(o$RcKS)B;XM9+@7n>rKOR+%rckLq~q2?2Qj&y-vHIgiO`9nW455+;t z6k705CRFO+hE2PR%_*GY@lEO>bPV{Wxd}b>6*|78*SBPP-Q$~FucM=v@N#II>+Sa# z=&Ppnm41*qz;lh%u1?+bw>CPVY-MSv{%mVq=!#8gcj##hT>BprDRNtYfIs@gnOI_* zv0zg6p1+El%7k_Ep7T6yxY>fUsmTySfOsguS&4C2qO{aACTUe6^i~rtCyl^S)1yyj zz-t0+6h(Jf6qJvM;FQu*vLRgU;JAl1KIzVWr64D`!x{p77O z3y^m1EiSP?ZdWOQz}3{x1ssi{(yeK|HZTHz*uzL`@o$~wVk2-1BRSQy z_6m%^xAZX5x+*XN*Y_~e`i2dYs0PL(H}A33y$s~VHarZMtP4PfOEdx*E9WdNhU@>2 z+6&}Ha1M@`+j!EcleqpWW%RTvsOg#wSFRx0`K;u$ptnkxAv2BlJwZo&#p;k z<^e`h`CulaEc`$cyl}JG``SEqlcy>dTzQM8fEX*PfZGHvAodFv@E+q*`S^m7N=ql3 z8%eDDVbmLpMER4|UkxPEog@w-GG2ZLF?L~N{UDNMQF`W<16ivgsV52q`xC=Yf*L2s2~o!gUSmB;Iw^(Z%->QS$r4v@ znHH>3q6EkSCkFb?7%(4x?2OxV~d116DkWz<$B$8vKMS&DX zAfxCQX)#{HNGg(tj*%7xQW${@t7D`U(s#gG>5`hD;doR7gN>8e*rzO}yFeWhgfk+# zyJ4Pw(C?LeEqsM9e5-0AdPhV{gQwz%(}#RDTvZd2#l8-$s=@aQb%>b|%GIix+$5T% z{aBuSM<$u4y_n26CGV}KJ_%_MmxS#IvpQ7n4v?uUTtH^1nvptGc#EGqg)mz!i5n;S4er_7kFpty!mQC@3>1=bc#KO2RgBe{ZC=Bj~*RbPl zQl9K5=X6@BMShwT&9?xO6-+y+SU?KgJhhJ8A^96|G^pr>0yxxsA7gp!WIZGbq_~jM z3>Q-Bi;(by{1y@>lHNi}vzyK4i)>K|<1x-g_6uP{izOk@<9Hf$WUoVWpM(y^zS)Yg z#d(|8;`b;)OSZ|Fr@nu{gnZr$8wCb0iuL`_EQLn#?EAi6WiOUi6*j&iq+S~0z(i6O z#z8wFl2QnN+( z0N`!C$)mu-J!u+<-P#kpwKr{g)*x0Z8~6o*?M#E`deSHm=d|Z~`xr-+mb%%TH2ZJn zh(E>Iy&`A9)84ZwARe}>V;&6tdejwsd*})z5ONp>Tx_PR$>0#DslnnjMVu~)q=5;P zC>PeG0i9_mS>XFRqbl{Z@j~H&HfrCersYk^cfg@Fg zD@3{!bveSnIkQq3Q!^Vz?8GKzOpQ`nu)!gBO7HL>R>e;N(h!!6i}^R!#`sKd5F6!r z!fUn|D0Gf&2W0^*pqwYU11U|tOj7()XxuUz1Vtjmb$ui-P$HOb#hsC z{4Le_!|vC{e8DG*i`}p1$q$ib!dewYV%R+E!%RY!%5G^=P%tQk8$LPFL~)ZM3M2<5 z+No|KrK*L*@UTi1he?wWrI-0iI+cr?LflU+ZiQ4+Vfqh2Z}$R6fx(Mxtr3C94kl+w z=`_fn(wgibFk9qh#^ioX<44eu%}8|E^)|Pi+1swNodRC%Nt3|!Msk}UT08xo?bIaj z;hr=B95a&ZOY6!%_`Zo@Y133c##_||Ugb&SKul9*-I^BG$ukk){@&0o5Yt>=TEWol z_A|BAw=Z!Z7 zm0ioKz4R-n{>2PE+OGPeH%|&5Lq0Y7_<->7YmH2G)ZY7sk0BF{6sswNVy^dGb=rORhLidmEp^Gij=)($lO@t^c@*`i5Q8{=YT)V%sL9 zpYLq+$$36M-RQ5H=kt)}4!PA)F)MX#i74lPE5V;OnrvW6h+#isqred(wX5SFoaTi} zE9$misj8|cn2xESe|zvTo_0(HKFiadzdaZ`hpOjaQ(-A)HAL*%CzuZ;SH;xrb5rRU zajioY+#DA+^v1Ora^^P#?+`y9HAMw4YdhF;sXX~7*sMY<{!jHJ1Lj<>%)Fy z!{gQ+#56gLxOTIF0;h)xm)n4`y2)HwlqRau(x8WV>OT37$)RrR9|4h?6ji0A)lg|^ z4O3cLmz0*)BBiDEM`>xzQCez$ZyW1x_B;C-j6c&)%$d}7snn^NLQ1U^Qfj1-QX7TT zYf{?6#IwDL)4=nLG+do_<(!ZDk>2p>-0D5-XA7$6VDG_$wZV9lZ8N;6v z5y!*K9O&5e2&)RvG3;t94bah(U)f3o&F(8W(LC)nJ34JFT2ifBG;&}ZJxwvjFZk|7}tg6)}@NssPH4VtDXjiAL1mmI5MsbOpR=)Wn zv!97S#H;B7DHZK%-AbZGXq1*ZqqJPjuS_syQ~XGow9-yk3dfbSR5jDSp=VUa=4XmZ zM$S}KA2utlw5u3YhvZcq`bN&sjQ|z2yBka=@4;3Lxhc@4Yv@krF1vrFy~g5BT~Zob zbh1%tWF*5iUDFRwr95njYORLYIqGI~ZMJwMaIJ{^iD+-KXzukdW6+t^r;pz}>7rxW={1OY%i zlgX4iR-9idaLmLYLy83uQzLPhS`eqg2oOE-1Z(IHUHioUv{=wLa)xdMXddm4x8$j; z2*^7x%pm4;@imyLdb#x+PBvF*_x{QI{zQtLLn7b;KZ7Tj%)zAW{Sytz`b=0i?>X;2 zV9a_SW>*pK|BbsvDKXzRBRm^4{ucr{}{>YlFeU}~VyMu|*NQ`!eCumPdQ ziyv{mD3(7Bw-o-NpAp4~%A3ZYaGejfs|*nEUyP*B5GHC`YXW1c*0pnq-IBy^LE=1P zmrLxFBz6iCvu$!)-h?^d-iEr!u3E#v7aOe*)mC+(eHfUssJ7*70XAd~D4%c+RX3TQ zEkEFBGAO`Dd(!w*4W1cD=NNo*AYE$k?SX`%(luAzO;rz7r=4752S#X;bZc5q_sY6J zOmmF1f>ra3JvQccb#lAbmF?;j?CO;4>eSfv8t*^{h^g+88g`YhxwT`twR5dv6vqnI zj+Lw(D_A>LvNr$Tz+iQ5=^89$FxBBT1*6uKj9TN3B3|;7NI{)Ly7l0HXxrIGd=f~G z$%bsMM%f905BOpuHGBl%4W6$9#3K3q-?{9RXOW+EH~X@1Y-+f*Z!?aAypAb?_0m8h zmrz@HPr>af?=x}D;~!3?xypAoqJUUyK>`zOc_{<9PaIDg42JOGD?_5JBo0Z)m= z(O}Gkk2o=MDh|xh$tDFzL2E{lMu>4I9W(igO!+_D#f_!aT&0h{nxh3d?@)icbufAzzjtq9(pD;(O_u2R&2rx{6S+C)w3Wq}d+${t29IR(arcsW7=BHLAA zT4#GrU0|%K&v$cVnmQ#-9q$w3Wjukgru_TEy=$4Kv67~-f~K*OrgBZ(CeyMek5N|6 zoQ>OA-*LOjbnhB`P9Pm^5U&eG0hf0%){gHziNGTR3HV%3n#grze*&PDVt4C79HmeX z;H>uCYomI)Hx$q|SeP)V5GFO`;bzEz-uWq<@6*#6LZ1x|FXO|tsk+rcX2MgwDFcoc zV&dz$Cgc(?YyxR(lj60X-8lA8AoyUN2=Y0CKs*hQhFZ-_9jft*z z7ud%*By|uNYnaGZ=yr>)Xew;dt130O@G}-wl?J466FgM?)GWoUqBPK zi~KF*6!0HxG1qQW~sNKWsm_#D*hfCm(f=+wCp zostpds_Kl%jTlRfkl#7|#N7GAJGF{dj1{aHD_N13=Qtd>9c!@TgFeJlKpfW)uPGR? z1_SO0eSz`ttjP*`f1B1~(}%p=X<%&A+Ja4MvFZ1rFEF-gZDtd>D?M7;DOJiSq@u9}{JTGAsh!OHLP!$;0<(oqtmIpSp8%PX(E1Ep?ggZnz+#P+x=_i#kKcnM5{Z zd`!EiMmKHlhvj;N`G<{q#|dVXkiXh#S!7pP2!N-0(k$>P*Envs&!P1Wqe_^7U+rN` z9f{heV+*gV3p~k_rhq7PD*-KZ%KZZ{RzJ@sz@$IOYv};v&izV#m5CTb#M8XgaUj;J z?PE2qm-x_)17r2`*ZA#C!#{aVqrm;W%o)@?$CE~ZsF~+YBg{sal$dwToo{03+YqC{ zY~WCJyxBz7=v+y;T#YGl(hJS<)GHmS`FR)qxSXUk_s%v$%}`zxD=nfqQtllfZxQq){MNxWYzj zZ_hXhjBT2yu$f`l^c!ze2e_w~I|alLIYtCxh1%4qY3&>O0%M!ztCznuD}Lv#8Eu)Q z1zzIl76!Ktq&Uoq!`|cu6U9)=$^~So|6ZexeMC=I9w5=1H;}1Au8l-;M79XPAaR~_ zDM>`$y+)$cS!oB_5FF=+q6_?_kzBIU`chy7UfaVsxTa1?Q>V@~bxNA%OTm&)VweLNNz{>*( z_)brn$aQ23nEsJho+cAGdvy?oHC%NPA7LMFSeUfu(Hqs%9SEasumIyqA;4(kR2LZ1yD7-GoP6~r^mgqM3$1{`O^^j_DSm|u8t6Tk<5*|AD(1+FrZTTy!@ z(L&;FUSb!xyO%f#j3v&u%pvi1FR=rBh?h78j3t&T#P3YXpS`r~U|YU8;lG?ao7uH+ zFjrL%vJZFb$Ha%b1xtxkxaLgR9IUFGsc^TqpV{*0el|VDJ{<4IbclU;R6nMZ?8CW! zOy}5#uj|M3pZ4K9`!RjOKKx8Srt9s)8~ZW+)IR)WKc=esoqb%{=ruPuhIjEJT6k%7 zbNlcCo~e*!ApuC*7kc&y;ERmp<{Yh82S(ueJ&d&89vFci>R}8<#0Y~9_1(Kjd}|;9 zV~O+4VkaHBcqfl)fVk$ip|sBP+B!fCag4Oy9TO;4t^}xUg#A?S#>mLInF!muI#C!LlQ}Urx@S#)kq2qnn#hcavVzv6v zsc9V)7=f`5c`oU+yE)6BHF=ba6ZWSY-Sbx))l(i&v~ZO?lOzT{!Mt}#oDNUinE{pw z3yeGGV;y%UvNB06%O(%QHn+Cpt4`GE;zY=Y06$&O}yb3NY@R z2RR;lhT}G~RhKn`clDT0YvFaSyDn=6m)X_%No$9|2wc^}7@Lve+^lZNELo|{$i-e; z7lXm=I91%VNGMGqsbZw5x-?LCaNR(#c&AgY0HG*UTw`o01G_BD|hE#I)a zvZm3o4@YFPGqKak`i0iU@P?VjyA$TrkA^w*1j(2auID7WWQ4+pplgf?u|=k;I>^}Y zN6ty;@k{%taCFkDU?S4x2Zw0@%0X9?SJ|*U$&c75aLh>U>b#@zF23$;pTj2y@`oAe z--EQchho0>3J1uKC{+;btVTSt9Tg4z(@GWo#lpEL*aSrP0(pgRWT$5-cl>Xpc~=5M zms@|0I2cRi%T12?iWa-7s#AO8&tmC{7a9Q_n@2jp4-9q#Q7aKowH05SV31)hFa^sl zF@0a~dMAM2^`vp&_l)F5h1M;B5%}vK#-J`nsJ_m3?*fsmdb%|&gi4`}mn@l z%>2a_dT;N0cYsJyn>#hFmj^~5Y8)eyx$0zigmrqV?>s>aW&(*GT(#$8H@fE&HmaxI z)17EN82}kt;48ef*;urEzrd7*Jr+;+WL*H#vm8m{qSs5zkZ*f~CV<1&J4Tt?zy(Hf z=|^j`zzE#mlO}-wW#8}kK>fj@cX)FoagFvkKS}@unL^BA) zO}S{Ui5`&kr-GLjHF#dImwivkX+At@&BrFC>H6b^3W*7@_5;2mM4Qb;U(ky}S=sC6 zDWA0;5Y2KWtsH!0km(a`D69)YcrD;Xfi(=gUM$~?jD8gaTfohK;q6-^19uLr7I5#t z8U`L7SS{dQHw9b3SKsVe_93UUk7sa+nC26BZC#GR&&Bjfs16e#lH;4Nta(66=XDuv7fRFwz9F#Y0rwQk>oS@f1%XuF3o_a%6n!4>@LJuP zZANE@s?P(SE0%o<{l4R-?Y4Fs#`#eeSf7mimZ~%>l>fX?uR$Q4YhRNA{y0dD0GR`q z@L-scn}gsWkb>LW;=tF1`V9i9m`MSTk5WMLEWgFxWpN&_m`KL96Cmwn%?_;R)e3pB zB25=aGXH*ybHH{%|Bup;yuD3N{=0_OoeN}(u>Ins!hSKguwR^1`1GK;?)$Xngr2iK z7|7hz+AoHeeag9$N-)O`VuxU0)D4>nEWcK%1=L+42rtG`Y8f=3Q>s+Yz7REwR|DVOn&|hJq7A}sV0~N-jrLNId)pm-L zZQuGCNFm0*0^rT0aL9>d+!n`i^fG^M#j<_a>E;9RVmsZ!Rort^PCsS%h(TM)qQ!)ooN)xA0Um|^#>#$cyg^RRpCYJb7?$>57_TYl>i0*yly zblWp;y|fOrR;|kj;u&>W>W7;un|@%;&)J1;F5h3JZDJ3J%@vjYy%xE9@(RX{ZS<6r z^;vo(jsqrb&9MD7fDhKU5~k)$p&c7Q+;nCQyJKjlTO8+uYRk`rjjsXRGXyXSBqcL^ zTBzJ+#$`APtc7`6b{@6ZEXXYt!^=Y~4PY&nWycjvE<0{a#@?R&7nA$T zq?-%yH-ek_eM(^!(JoV_zwL0c%J(x-C;eyPr(Q2QPCzBbKqM9mYJf)kwP0GI!rAIMV_KT+&Rhd)C4c-l!miEY<5|hwqbhqW?=dWIZ*HaKhme;ioZ&6(3YRxh6##2Ub;SxE7lk{?&7s&+cSIjO4M zMD6SH_RT~0b$K{%&?~l=d?jD~{r%P25`bDG0-w-JgI-`Dr=nBsZ+lGJD8Jvc z=zgPQW(0dp;M0MX9h=?r3^ebT1-Iaz5dOQUy?5J}eJif2P{C7SZM(|7MgdSs6Qg8} z5L?4Z*8jO(p|5(g1Q2x5fzJ)fbMFwmJF@DwBF5g~L2w9onpifCi;m9?7FM-4yF_bx zjbHk)o&SLA1=b*NQ?cBVZM7M_EeN(^teC?ALer|hopO}D`I$?0I5I^Hp|_mdcc^wY2xOQ z;ARAfVSg216y0RIW`E!RlNGGmW2Bk2Fvh_B6z^w4+$~`1*Iv>p2An6B?+HfBZVQ5A zY}W?3xhA-20{0DW<^eJ6b7mCXWX~FEo&v-9 zJ`LKfW52<>SJqRxw+v;U3w(26H9jTy^}w3TG#n5br11{H;{t0gkQuVC>*v#wtwq1p zRMjQw$K9hrAnsRm_1R`)Ym5y;XE1rT%7IKpT|6y}8&ko(X!y%U9E2$m# z6W-W?+Dx2x{LM1DETq#+b^EK^dl9-(g}GC7io2DXmK(dJM>%^dSdtrShVAb@&179% zrghgYnu6JimO4Iq=RGKf3J}Kb5@qKPNDNX0|d})3u_-s5W zI3@VZ&WKL)QoX!5h_&t(WZ~J7#Yxux^;a}hO|LHC@sDKbSJ8MX)L&h8 z84-%z$pVSP3o^PaS_BfP7fhpLjQ>{z0}bGR2G&SkxRERM>a|e{n<;&cL=Fm~qZm9h zvVbINPem5?ksrx)`L&qTV|~0#E?)jy&$WgD{v)u4firIpQo!d2)-Z4_v3y%G+A;{X zfUgX!Vc^Hc=ra0x6a;=_j3A?{gJ28z^S~Mg{%VXaqyFEK+%WKYfz<+T8Cc8d@L1)% z#?8FOBYBOR)OgL1!U&M6`u=6~(jeFbULIH@K#Jvc8Bs4=O+d-nj_INn8` zmxi90w-$hJ9nSCH%48;^>0J zuk9lj$W_d(m3lL&)RD2G)jIlN=AoH;C^Thu2(24!$>_nN_5cY;1#OyUQ9U*v#{-kz zRCf{GXjYn{6HRk;ym}NV{!c~o;SkjjFh+Guh>CUHUmY_GT#w4$e9faerV!OJg{c0b z82%Pw$<9jdc58D@_HlHt{k^S)!c@=w4X!j*KSrB%XS)j!gSH2y_QrYBJU7_FAXgfD zvH-+~zhI?qJhv41flBcGqSie?Oxm|DMoOwxh4Ve5G7x18F%72h1j&`(zKJ3;*sxfD zgxQ-pXDroZ^%KoU90imY+>Vtthy^;L(xwNx`p17VxsbY5^}7%X|2lM!yV#BfzDBH43~tuu8jM zzn@}Dx68)_DcBc7b(+8%18ew6!50N*qrj~Kt3?gB4Xh^cm4P)(0im{Hfz;GJPzUcD zG)I7M39KfNDex6!#Dq9|mrLoVL3tQR!JTrm&FHsL5EyIS1l}VlughrqQr}>OV>OR( zya46DR|R&Fg8vli-vCl{vkNTL{}jdKjM0ch=6K+7qU`Im%khffGqvczaXF1rF}k#n zwafOavhwYi7n)SlwjN)X_+J{BZrmtN%ZCKX*R<0qHCCQ&cKmj8Le*>bd(dVrefnO91X6MrWnkvrhvxu|6QFZUstBw1PQ38u%Ze;O9Wc8*w zlxvpWdFwkV^EsGnW{J8Qoi5GKh`MD8ju~W&BPvFr{4&sYpRC5jGfRDa- zho$)mQCAf(eN)){qhb^)th_vkd=c1NJIv;j3c_Y}Wi{J>ho;LW+Px{1YqoODqEA}9G^F$(=>sX07vk*r@OYV`%KcaImb+e6?+V)?y`(Tk!W@Wo>UySul)!6U~%4*@iR z>jt}Xfg1)^14tD9s=#RTAUGFTk7@iblo8YQA*Mm#2EpzKkU(t10TP9aX|T;`%cu*i z$CUr{M}H{XWr~Ek`KL|OHF8Y;b_D>=i0OnlYXD7V)5-&kn%R5c17=~IWTR$w%=fNu zP`o#VscZaR@Se!}v*2GNs}{K+FGin*CpNiImQq#aLWSt3s+`eXVQst65TO6;`38{w z>)MKWmUWA)GW!GpFk0-g;7S&WkZq&u4pLHfyxFS7zM;ihz!9ofrKRjk7I=f~ z;Aop+;-YwHs;b8&wvtjbG2jctvgeBjr?I*5{Zd8Fre+JN%#PMlO}8rDKT@a0whaL> z?907|Y+>7Tw-aY0>;Jb8>R zqx~QA&PtyftOb?F)GWo+Y!lOQA%G?jmoE5bo6&hu5J*g3uoguJ`ej{JbESxR+YraG zxu^2#Zr9L$_y?W1SeP>SDZq2M7@s+dy_3=$A!fm07 z4d9c3H4J1&n!&j&GEUuLk_<_J00e(EN zTEMRaR^c4)J(d5PH$jsoxHL4uTp-i#FD8t34>g_(WS+brql=;-ka_ZgjF>9Bm;mpt zO>eW!Xx)(aTp+dd78&gm1%Z^)3o@dj<{C(GyBDw`jy;v!ZM`=z` zdXAS?!SP7=v6@`J+G-_HCkI|Dv|NKGUs@9bKODuV6piPsrA2YPdX^iX?N|NWI~l9RQFxfZ%* zKu@y>9d9)SOZPY)d6JOh5iT2xp)o~uwt_5JEX zdbhXz%S}@LuT(A?*N!~&Ef=AGr;{6N&C*C`z*wxbSpU*7jrzw@Pxf5Z+0{51EscjI z&bQ6bd~<=LV%aCzmt`~O?rJdiQ<*ct`zj39wC~Hbs{ulQ7M?7b*1+{LeMgA60gRg2 z)u_KL?1w9W$BX3-?5#GV zt^N@Nfv*$G3o_cU^JPl+?)g06;bM6~Mi)jw;2eEg(F=}E!daAtUbsc++#Awr0N)wX z8XG9OtYcynO2fP`M2kiH*xp90b-{B}sy$BWQnQ`8E@ zsl3BlP06ekl4=0=53FGz)Sai8%w|Y*7}yG|7VxuyH4KD0V~h0i<)V%Uj>R3mT`$ug zw!VSy4Xx4w9v@i4w+hB7DC|zIAdhMio*$BL(h5wr9c=PRE_^nmswS_=bYX$sv(^E| za6%h0B_@?e7}}5`niLhHJjKrZy-M*&C`nd3w`mhQfw zV<|a35prt)V=;&GGG!I$JTX;wPE4~CkTf?HwI|ZK&(X1=SDibjN*bF4%@&&Mn6{Ot zntj!JxySB8HRGvJe}%i)Ls_6vXxx~b?GI|9o+|1#0&rAr0Hf1+X=Kq>6v}QvtLn>g z^j%R~-MOWbSPP9SrD{_t&&s6{d5P<+^4FFsrY3vWZ;m z6neQyC$bA$a`}E)%$K+w#V|S8u8U!Id}9Hludw-(l}V8WVLY2Vc-%{f_{E_V4ItHV z?cKhet~Hc=Vwz4H z&Ambxqq)y)i*biWG>3y`3(dbrmh(~n*H`VS7i%8t0uD!^n(G{rt+5fr<+e)YXGSI@C@kJzS8c**9O%h;Dn)bd_a?`EUq$6eCwfRz3&z zx9#;ZntYWI_3!I-_^FL))q|2?YqR>LLQ|@LWJ1|v4ENyh6T13vvUT+&f$L<#@lpqF zeW$v%Go-48o5883ispIp-m6!)!qJ^*#3kL{BA(VcI7iR*sK2iat`W5}6OaJy_@9=g zR8c;TMSf@1Y6Jd8^a6}thEp$vn{4+DEgYa(FFvH(yffPN4HY66MEHW(mL*ft5g zF9b9SBm@^wv&|?5lwBcWP=s@42xky@Yj89dh-v3&FgRKeGM@{?w-=1=#v+_w7Mu?O z9|+Fp0qf3(f^$3-wt}*=zXoS}1E0GRQ#TA`0$c)nw;3@9)|tS1RC|Z0HkuhM0twVx z92?u%5ix8V!fF5sq!z&4p;E)da@X^Nci=;T)c_JuVVQaLPE>Za9Veb|hY*J^Q5@HV zc;*uiC2-4roPegkAcPHEDX`{`t&u+hdihlq1Vx%sEm&N&84==?>b=HIL-O1-C~tv6 z5rmgb@@zg4XBp66qCB>~?Pcyrp|ja5ze8xOSHSv4M|-BS(c?14`U zyg6;~wSl*F8~n?_+ot`c|L}2LC+h62sovR9w7;6u1|Jf5TerU@Of_B1)NTV!q_cO4 z@YR7gr~L=v?N*^K+qA*E1m4!|D}`?gyxDE=9|F(p3HNDlawrPXe;9L#jta=o0*V0$=@det2mZ~3IUBG*&59|U9JSeorF%|g6DE6S>7Gdo* z*ePfl=K%cqD3-1VCq_@v9~MX27RI70w$rQ|i>BB!vgi+b!`TPZC#DIcU7Q%0)-kcP zbBslkyom{~8gCPPXJpYf(>0~0NH@GJveHR5sdVO;W9ILtDrM&_c8YnP7Eg!CfD*dY zz;shbFm>e@0^Ez#FkG|j??eOHpKT)tGW-9m%a@&g`-pI9xWEn)Mk_R2_H9XbZjQRw z2Hge_bN$u(rl|Pg{df%-IhC_h~cKM+6x#p3s2Ge^yB~< z16Zo4wu$=`Ti3TDtFUzywkfuxU3IClmDvwV?X+x;N8MhjrPYxWzNE%WE9d0W(m7sQJI70l=Xh!L953CL9glta zE!u<~kB#}58jlL@GVaB8o9tq%a#_38YN+PRYiQR#wH&SIF5uL#*FzTF=Qf4BhI0xv zjE5o`a3Y5yYFIx2Q7;ZIE)Q`15R+cZN(UC2uydv9G~_y}64Y*&ft%{3DbWxwI&CcbbZUbmk!E*3qAoh`)iutG=FUg-93)5uR<-WpL z?7G*+-IsF?cM~Sn+p&?=Le)&MaD-EGfsk`OYxg3V$29E_s%GRy%dL+zPq)s~M4eok zsaw-&s!o?&ITt%!aO{z-+iAAW9_ey(p1o7c&Tg0OMN?D>fG^q_inci zsdHnczKxZ-HdgA{SgB*X(71p7{q7>;sC!OgtF`m58gL^oQ9Y@S><`=O>^6ACz?;(s zKR@ucZiAt&1c&PN<7#qX`q9ae{S!4g@Y8`erwyK_j&&;r{2cK*cXJGAZRccrwd@|@ z!G}F;5S|x!bK2m;0&nX!_`QL*P5V>A7X{wdZ7>VR`DKRA2VB0BJj3u zgIQG0UOK&<>uQ(9-YEvvr5GJ11E?!y+HoDhwC6fZaw4t{GYzbBbJ=0C2eD22XL-cM zM(w$25S~jET&O)a4a0NOI64O{>wWyuMfPD?V85DYg=)d{X@^zowqej+CJUsuR+^7hjaBH7b>C0MD3Id{QK&i!?4{{i~u*C z1*-+TB(O$+|09-r;?im}`uLjYW^a$ifC%SjA)F?#9URRCV%j-s21g$bj^+aK?FFN| zu?Xkw;Cv8xad18itUDhJ&hb>*`Nw#}+4qC9A>i7pQK?ZN6W|gUYBORE?2!nt9@S8Y z>Q5p3Q6PbOi(^7d2E?#k2&(}kkXitjMpwi#e~pk2@SwnI013!!B?0KMN{4H!X`Fa& z3n7jkr8rIw@ysJ0O5k?caROQxVjKmY7+9s_jN*Kuf}lwL9TY}{IHfw)-h)X)^4v5i zZ-GJ)gqKZgW&2%?^`v5XpVqQV8GJ(E&1qATO_iXN+d-IU91q`LtI6FA*1B^?@qS?z zpwq2|)q&|PX!<(iOSM7tc+_p>u!l8(>xA+iQ*9*t(kKSpr6%@9;ki)^cwkNJ zP~pR)7;s@tjQM~vf6UKcH5Z-Z2Loon)dhUImSjhe>7Y}JhZnzp;P~rm2=+_6>;c&u zY!d#2^HT6KnyqbMgTCHFT4?uI<#AVt&KOw{ff&}7lJrlW`_k;(6(CK|@yPEhVaJPCigm+IGp9}DZ>#axq)w>u(mIbHQ@o;4^7>{S zW3sz!`G_&iF2ppuoyU}4eM<1(UAR;Z5k50lee-3sul z0MU5iD_zg$w8@%FmYWf-L1gTBTwIt1$4k9)#_*H~xCC3@0y%8B$EiJDWz#s#8X<9! zGZwIZy(>i7XA$-hUkoN*@;3~baO@@s@7{+%H-TRGfTI4#$pp_Xx5aU8FtS;MfY5V$D`sx2lhzp02H{ zUZnCpCe>PUsI{2=yHnI2RRHe|tYP2-fz<;3Q7m^7Y_%D!{tj=}%mKF$%L_7kZ4?B) zF|hLIytVN2$eTn?6wXyM#I$a(+XNDY7i9G6C#oA2*tlX#)C-|e^H*NIx&0Cx$jVc;7As|DOcEZ#^xshs_?5sKcW2KdZxT6CxR{!4M#lxaO(0QtK}MgCf5I-Q~_M=%R4*DWN14(u&!L**->VyZD$A8mGjB$q!9wA@U{&DDQdmH z>n8KI^?M`{Vdoi|#2l{6J9{ow+SyYn+l5c*whK?IQt6WC>6z3-c6K)hi$Cml_nSnm zb%4JOtYP3iV)<@jwC+c|4ZD*Ct`}G>;6{Np4E(WJ-W;Rrf?x}HLtqU9ZyuxDX{R3k zlc(Fv(;Y3P+ia8Wo*|e~U?Z@azz+u2DDWeJ)dZdvSfjx2i{*;aY%{th3IeH@7i2_T zN_Xul(62O$q-hUq$nBvp=MCV2!Sl$mg3-q~?-nx~Ps${HG`Up06#}s{ij^`y{1*-P*4h zi>@Fy5_Q*1Fx!bOSRmVpUG#uImZnJo+3iXf;OAtn2WzguhX+vbbQ(b7bKfNclePPmqcoh-FCXE?RborI z=eq|Mnf2pPyO)9NF(GW@WF`WAtZ_!2{+4BH@0oi`CxuzlaRhX&;n+gpC zAx<@=@BdAy2%BYUdroR!TV5*hRZimI-U5C_EPo_tbXgPxUOPsR z(Oppx_|O=^dKld>;jI{qHG#VZ)+n%1v)^np+CK^c-#SK+(Zx{^NY?%+$%quKk%6}b z-6pV}ZGOvK%9w1K0rx0Uc3&Ipj{phV#WvVxba)g561Ep)#O#?9;E$p%ko>$Zqn`!A zL0~=G{DwR^yjk)CGC_jl=gJKGFqm0#{wG!-owl)wkrX{@*Bc-iSkDkX-DoUeJ)>rr zQ@YUvfy|;yz1e2O{Fq?(KnXHdJ}h~HbXHqo0b$*98PPO$Vglmc3#JiFtIax&+(C+R zpj|p#B?r)&rI^KdYXyHUvccf7UhRL<3QCJIHZi7#rui4@pBN}X#>)S5`lqitUwZ~E zSbU$pb_);g##&I{YxFs<>W$inNDHDh3Uw{W%PzJRjfx8C}Ab3E_| zl zp=arbRXXW~KAP5xkc(nlH4gJ%Zg5xAXGF!R*7d#IXLy{iXCfqIOvUu73(=)49M+#PZ=Vdi3-l zh}m8!u74O@H-T7oewuAY`-Xs;z>8`DHQS8th=RcRr}`MZMMejSYb^}?${0aLS4KhL z^FL9y$mo^gnnmFAPOA$t+Du#%1X4#IV=pD_E|V8`kmCM5)O#36g`MZYLcIs6_oqW; zhk+E`>oTJ5cD@8sbT7z=x|<-7qT31rQgo97QgLsN5k)sa;DNP?8f-HTp_L_ zmIpPquBTK@`Lwr(fK<+;UZa*fE_NeLM(!pxHl)gaYc~J)cD2hBVP_agJHwum(ipdd z*hhfm&|e)fGwlo0Oxwa(|KVOm=@w-ZZ ziM}omk1U)#m>lZz@W#u_K07=uG+_r#G&6P_tL0&9v>B}s7E802G)?)CHNw?^q)G{z z|NdXTI3vTpCwd)C@CIviKtbyv-zK~a3 zUZY!Tn_%BG)qHu4vb?^l&a|Bm$c3rnU~G!+Loh_iwWP2xozj14nqp)jj0?g>mVMW$ zuex3@#+k}L;8Bvwe}kYTwRLtGC`siPi(JZSphFbL*A-lEPupl#C?8!LUPwDP zypR^CsxH!|gbmvpbD^gtM6VTvs%i%X${EtcIH8@|eS_<-5Ta{KQ|W?QptW~&*r6N1 z69X%I4(&Ae)yq+A_$;yhJ7{K!4^%y^cIRLVS$RdY24tt0YR_h-ZM2`0uK%0X`56!# z?Ie9y0x-ebUbx_T|Gs6LM98B4THU(CJV?dI?lm9aR*V~nTRTao-U^3nd-x&~2p5E0 zKfgsya%#9WXr)Wgp2Va%xbdNhCV!nFRfnJ2U^nRPPUM-~W8mTTkmD#@;_Bh}GRm&T zycFI;=^pZ2404gPzj>X9JU91|eV^HVRd=e+SzMr8`yHVr%jzs%A^HaFDr_A*P`PWx zuaz&Nl!cA9ze>}zKlQy`cIg|)#QLk3W>TF`#<(f8e>82q2bdk2 z%uOin_fnM|4@~9l#^K1mHlz21&3`aW&?$Gk*Z#Az!<}96*$9dDwH-2iXsDMcX1XY* z`V-Kz5eLPv(tKsjLTQ@41U02PUtM{rXko8(-|p8x<; zQa0y);w-i2c&WkiPob3pbib07TeM%SOF}IDnpU?MXBRA%pVhh9uKz1rv?dC-IBBf) z*V35luhqSH%zWGzHiEr-5z2m>BPgBW4~`p&T8{ufFP3`-+iEkqJPHE8H%2g6E(6J~ z8_YC;hXvL!@Vzz5%{HS?M?oObxmcSa)~^P^CXiSQCypdu=~4}Qunjyim>mTYntxu+ z=-em>tOq(60$mgY2Z1rr?3C(f%sv?>t!;vK1Nff68UYfNT_=ENM5!eC+Hlin>g7|> z%eMq$a)pERM56nGuf=Af*1f=+#PZ$C=zpUi@Ubz1wZuzMvKs|6P2l-~H4MC{X4&3$ z)9Csr2qZe+y^QV+f=wW?F28%FOEuivGGcuxm>mTYn(tmlzlefBLi2)*?hAs0z!+%O zz3v3@UTItyG)I7VFC1swcgWB@H)>ubNI0c)LY&K$CB0cN5GsRhJ6sb5wvB~(QnZo+ z$H_K#OvBh)n!xCIICngZW17GefzfgH4u-$^bMB{P8HYuJW4}mJ-=2$m){Ct%Anv_j zOw}W{sj7OJB4~x0H-Lu)Rtrcc*!coTWY!eGI5XKh8!?bAC*+uFnB#(%hh>YT3k^C@ z74%{>2|C{w=tZJdSK#Af`MQSD1zy1frwFbjTAqN!UmVK(8o_fDxNl&M07n9=3EVHR zMu6vv2zsP2g7pYXtb<7;}ssi-N#VoQ_{c)TMAlja3+nX2>>`uvG@6 z5@roZB}@uPB}@uP8UE#q!o%AsDgur8?Du5-LA;v)%Kj30cAGc&xG>$rCkTEfvM4T% zW!FR?jb-5j{}>hNCYr?*f%Hx35;FE{-NemQI}Px{;A;d({I+QTKNqEdq-0XSYb53D z6Zm*h`k5rUMKx_O7CT?I>BXdfu+)pm`h9aRmi^PlUM$<4uzlI47n`oBSh%r`o6Imf zr!8D3S^Af2hmH9qs^>G@nEkaGKkJ7^XaEV^eI753y!08pc(Hd0Z7YLpRz2@qG#%^6 z6oITGs~hmEA?~nk(_?OOJsQGh1s1|zq3S`%?V*P$!}0gXG}2zii@xk@c!#KMqQIvEYZy4=;&3Pdt|*pY zB#c&%g24U0g6=Tz?P7UdMn?s~7Vxpa8U|LEV6GLQSl(QpM*Ccf;4tvOz-j^CCYIM_ z^t(kt7x+M6wSa#V%j+`wz}JFqFB8$54Ab>kn44yRq2!}|g3OUEV;~dcVr{k=?GbdF zz`a7rM}bU`*JX5R5Nrbf7FeUeFh{l%Gjp}+YPOlK)p)fU1%7>uAfsD@U=#R)uTt_+ z;2Xs9F*8~a1e?Hb2G%I>p)tCQ)(*`x3f!#LJk2(vor7Q#I2u@^KpN2I2uSz&m>HcI zbeq77LNAU2H&oYoT}H7Nvm12RcXZV^Lsty~(RB9mPh9rav|j3mGS2p5chtat1ivFd z`qiZJCLN?n?+krAlDFd^?f7_T#}Q!Y!D^7kTRHU82rc%Vz#0Uu8QNroW||vVgTU_v z*2v!l=@q-m(jeQ0865=f8(1Siy22_!D;yQ127$DMnLk&rZWy{_gg!VZ>`5c<5Ii=r z3bWbA?!6#Xx<%fnha^jH%4VAGDw(R5uACM{-?s7=z3!c=+FvzG<8_OFCu!0l?j#M4 z)(Ri}M==WRliIJURu)%&uI!@;-X7|cyX#x17h@4KAr4UI$tl~gONq^h?s7a@fcba4 z{nP_&5000n)mP!6ww!Vy&q0)6>`_@7i?PyBjFm=WtloVL=RSsWAH%ti>_J)dd9lj+ z4NU2*0 zn01LKGe=p@4wr%vn(&D3=Im$i6=ZC*tW(Wr-%%3#Wyq<;Me*TqQ7mrzsixcFQ`K(U z{#lvVy;IdL+x`X8gd0PBa(8`8^!(i z?&2Y(c&X!fysK=woPVOZpP{R|byBjO9Oa(V2zwFNW0kzi=lhO zv&=k^5fWJ%$~FQd`hjY}!oED{%!}K&X6kIfk;hFU7jRsaCbpz&bxBpblxqFNtIcMv znO(D8Z8#GXuN5!XEM$rvo(qAwloly4c2Ji(EyuyOR1Ozf)aItn(gI@8-z%jiJ=Yr< z``W4+J0&FGIxowp9~PS0|)RYV)+9{Nx9COd51T&p{N-GZW36-z!wEp3%G?? z-W{X8q9E|lF@lUvh=RbA18bbyU^{L|jBxEqB#Ij?Vi;^QIx#8(>%ory@G}o}s1&OG1qpe1Q}8wf zBoG(YP$8_LQds$KSjPtqRCE>jBBJmSIY>5I7REb>e%RfktG8x(`0oIlCUstPpW~yz| z2iBGI$?Sw50;llyC>Tgl>-}9fnYXRK(2@>zo}o$1;ktBz>92CB{QIi8lzq-%l^cE3 z*;#2?!DfEPJ3W&!n?3)jiRxazvp-+d+6K50{0yw$mp;r z2s|dR#@*TT$eTn?6fUM_o6(zt-6oJIyda}@ML{4jc|q1)7b~?$fyjg2b(XEF+pdc4wXV33ZcF#cpCx|hzo0|&4^fRGXU1Z$~S|2 zXP=S;7q`tc#`@m4mb9p3)Plq0*LHSTl)ApN!y~i0GkCN~bOwjyYdbqE>QOg1W^!!c z_E$1uA=wfIwv?=^eR*d`nG9`b2iBF#J3GouwM{0luAEP1Cyfv|g|~$Oq^R}&uA9u; z*6)!-gq>$-5_7mN@9eo$X=hKRY!}|3`_7(9mpo6eQmF~;>}fBJJ6`-wU*N|?t;v9= zzstX5xA?$Y#qxc}Xp03w5cpoPyda}J4-108d4bgeUKUuRz{kY$<`_*sJeULSD3%vw zv`-WS9y~^n(R-sH@Psjfj82V$z;nh3GWuc^1b%IdAfuPOCnN*hUM!ysqg|pPaBz$u zqg9Ux7J(yTd5etR76pL^j}c__ks#Ot-Wyn>z{khvGTQ&h5Y4y^nY>7U{yFq#6ZpZ< zpCdpz(&g7|Gg{@{xE=x0eqNB#UZL}vzz+r12=LUvng{$-V2uE2QhTrfq|5By9!O<< z9E{!*irNHHJ};OQsW_x^Plw740-IsM&IhtYo&CW!BMQ@3%?IuuQXK?R1+UA9WK0)$ zY{+X6_{mzc47M4Ot?8z@`D1J3-lz1)&8`eUax*Ky18V!yv!3Q8qK|o06`9cAcF6|P z-_|)mn%g%7Bl_C}f%TN_3y3NJ)9KY2(e>sUNY|T1ATw;O4W#Q$3P{&aWC5fV^wHIe zFeW-DKZziXX$!ZFLEm@vRy%`Fc&%V3*;haQb20w@^7^nO^??SAXhjq$cT%a zSp>4-ctJ*7bg!6q_~MMrYU$eA@P)Unp@u;uALwnvo5`ZJOY?In2#Bhq>wI;575yVQ#)V%w>0A zD{z|Z1uT5WW94(jbv$rf=X3LQK9@36Q~Sju3L4k>+8_6DSTd)_zFlLBe z!2VhS9p`>=Nx!<3N{u(BBm2~SE^;u-+ui^N)*F{fvA&%u_|b3>XaHIA_CXWii)*b6 zrlrj(@Uog1_z$7IhiThS)FuSXWSKSQ>oSQM3;39Y1Ix%ous@Z!`_UAbK)hGU_ai@D})6Hvb3Z^&Ruhr@0UfYyL zG*uw`p$nMKDorW#=j50`%H(*x)XB+FD2n2E>4LSNRO2VO?Ir)5EtO$RrCwaC6!;Bc zRn7yJDz!pbTl0Xo)s`UmcR{QHjH_~_(wbrmb$L-wR;A;yEZIUGk43m*Z4rW5X4Z

SJ$Ug`XqrrAl>qwlL~bs#RTnqT3r)Dpjm*H&(`@=R4vq2~(%8F!o;h zS?;V?uQP6E(P1{b2d&d)M8DZhS1$!L<+Ij#wwui?rbXjy8~Lki=V#lu6$~5<7lmOK zCZ{;tvw)o9OcBVn!K6r@V~a@vIkuP-kYkHU0ojL4Dh8dRwX!4z3Ga!J#2~Tk5caP@ z9KSKLfcuMOUo7fuVRfJJLi@7J^RrsMx>JYys+AO0Es0d9zalM)SNau8zh=zwYBaH^eL8{~jKH zg|4dpP1A6{y2HAo>~{8KB~eXdr3G-~5!L^A(P`DumHYkTR2_b5W5wsJXcc77g1Q}< zt0C0!IN)>MDJ;!_ss|xHdo-o;|4VPQEm_Wpbdj+*B62)57AHhbhsH|pv0dEhEwzd8!USwc)QcJXpFc1U2t|ZD8DJ+N1GBIvsN|E<7#oW^Ob$H=3Kv zo@e?m-Vxo!imtypb~^T65blYOosPlphg1Bqao<$per8gOQ_bSEjTWRv#ZK*totD!7 zB3Ie;!DZ72mrWm>nqIN8BbG7K1GQTk`B5gj5wexf@r^@nVKZ2%^T)6-$5q$_IZ|?D zteIoeFPIyscF_T!t4Kk}rbG8K8-{zD>}zFHs~Od6^zz&wwohsANDJ3r?UXB~LQ^aD zE#7!6boTUKgnYlAEteOBSbKbSl?LWl6HjirfwthdkE5%M#bua|Dx}cO+-PoYG&k2} zaS~l$xSKn6I`)1O&Su9>$KV&1yEs#eT5hRPu~WO_F3z&)gUhB5E}PC4rz`81v<-1N zwN_`BWaSmQpZP|6W!1*sn+C2cmVNhnv)z4rVfcTeG;a+>U)gudU6fO#F-z2bVQv-} zN9LQbp#4EH3YC6myzeqq;ZaeuMPxI>o35F8b5qc4<(kDG9k@F4Ih1Q=(Yk8fD9u|% z-DV1o8DtMiqGA*({3gJYs&Py_v((qOR6-Ai3CW)w+D%M9C+_!1&faAQo+?)P*xesg zk#kuxu{9dx_{gGt^ahBk-6YpEI?!EC2@Y}pH*IDyJSD_jn)xvXPy4vPW4lPyVgTM9 zSfjxE#d4Xq+Kirxg21N(s|j5H6z|DW0&W~wP2g#Pl_l=uzFwAp6+AS)ce1y=4@?IyHl?x=df=xhj2oErrUYn2 z#pgGOXDz;N<|ZAVOZd2+suyeSQAyKX6w;Y2T_{Sr_Sx-JwbKNtU)MsDi@2=Wn^zab ziCLWn(})WvPnYYd(mYGl)dU=SHalEJ#VC{=1FI?zB5T9`iXM$yN7no$q0Ev?#~yuZ z3B6I&B?LYoEUyMII?X>*fHy78Ue^mU+D}}2N(g-S7(qt= z6$OD`8zac*H$kuk{OcG&MlbzjNCvpQSUyHZ>z)||ft!ov1sOG>AaLI?f{YINRImtq zw^-gHqoboB@c1!;6$=_tdXXFb?F)S*(SLm|{VL#RVQ0&!st z6~Y=Sg_VDo)gMag!JVn4OhoZpzi^n@`d545QOT$Uhsm#fF&P%6u75EZ9(mTC!J|#0 zGdLt)`(iRIrm1eQp1;F>qffb|F*RX}vn>a>`@h|8x2c-?%Fx_%uMuQ3v;2VUWUd2S zZANTnCJ1CF^MZ`n%uEo-PUZy}v6-15ke$p6GGa3`K_HXu1=9%}=o4vh2X+EOXa$;Z(V)lk7)nbQtVq{IGjt6Fn9WRZu^I-`0AvM3${70wx&@_|} zRM(VQgjd%VA^65{^lSiGpVnnSy2V8WhT3EUUt4Q1@Mu`S4Ir!C9_s*UL+9Yf(zr2d z0+|QX1TrN~lR4R{HYea$hTWh6WV*~6kePGVn7Y{LBQ!YO?Zm)rC@!|7`JGta{Uh|j zx!PQuSiX}q=x}xtC&s?GT9Z;SFz$Bt*!i8OLZV$&ePL4T>w%k#&qFZ zYE1%Wv$q8Uq$6ypT_KI{hKAT1cv~=bR5e~lyrb3;VCLMM0>_{Jy~msW7lw;Q0~q(d zaB1N_$$SDoDn&PirH)ul8{Fn$quV=e5~n)(E@@1*OFExws_#WibwZi>=hS)$ys3Cr z5FqntGY>2+@(pWK3T7Vdi4btSDRp&YPMIvnW34hpjt6GCEV|NcaVp>>P@kIXHG_@^ zW>H(jLkGT(ofahJDZRPXw=&}lT)~Jk}5RA1j z_Or0b7Mk>E$=8BNtJ_y0R5P9nRTU0tS3B(Y5Pe_J8#mDC@KWXT4N=#>;Gc$E8(3Qw zScAZ6YNyVJ<{8AO2lJ?lA44OMs5u|aBSWhf7R_ynh;X`GUUIP(8V`rm^Y!39vT%sb z67g}s2oGGiW3vY?v7{ckuWImU>0{yWRe0u`eF$a+`?|#BG^^?cbs%@_c4ohJSO2+- z>{(t>dP(ong`{2TcPNB=!{TWGr^e?8X}Roqy*_8X#>@&kc z&ic9A$vks#+ebRJ10`FjP*r_I^Uq@mYuzilH)BD1 zaqrTF`F8=Gr4T+J`m_NgDtkzhhTd0wD-XSEFh%Kc5>0IvLZ4z^O<_)IPl|b5#Ql3g za|LU8G?#>@(<5l|jzK}w7r}kw29HsHZ??s^hX;~-19`6H-k>Ki+&CU*ANKyj-<)$_ zDD%&IC-3?~MK(d#Q>&@drgXk$M7H;Ys?Fmh19fYGXK+x*W9e-imf(CKkC5zQpLUu1 zDxLfHOF67L?#&>NrQ%MKb#li+KQ*~E%-*;kuUIBA_YQ6TsR?4EQOVSV#u{qS|#@ZW;}mEd5-tt zbYuz5PK-d}ay5AdQBu6zQ>)~uRj5a+RFC{O^u4Dml=Zb?mPdeOWN&W#TCXzkgYm0eQQcEsqA4Mp?48~MAjvO(Pwr<^AGQGbMsSk1J$v&R=L4!=l4$>Um(xD#dl>4 znOTK)GdF&G(O?#zzl=O<@pUsd>G)j2uj{FLln7eVbXS#hCQDbElCFE-QGw7?ohHB^ z)V0v$A}(w8=GA%MJ*(4T8gZ9Tq7O-PzNo7SIQDGeljtZ$p~5H8^B}S|?62t2aTaGu zD6`~O$Pbjr^|ge+cZp{^H!wQQj)zr+tteFZB>H_a`e-m-czTG?UxH8;K3(MK%(man zwh*;%ngMS=&%fl)7>riLEz#sg7q*`oQKsch1F~m*7Jh5CXhh< zHH^{LQ4m-UD?hc24J{9BuoT!}2y9C5HwausEO*NUCOjAHV4KnQQ5jedHb1e~gUv%7 zDup@}LVa2jZhwjgNFXk(p+ZqB$*2W~$*+CR85X6k zf6f^mdDfl5qfMeSI3!>DoHHz@scx`7IS%)CK9EPg=c*!p6cx-UmpyTV--{;g zZ`zC*V`@b%rM&FZ1rKaKX-|EfQ_J?MTiwrOYvmfqE=0A@Yo^xigo^Q1!qOgowcrtf zHTp?Gs3`(3)l04-KNhAZ?H+{YIXrAs!$%386Inpow(ur=r-wUp;n3Deoy-%NObKC+ z>?!!4kwsF3T?=u)5YGr9el)UxgjxvE_gW`V`%hYIS0G~CTmd;Ac&iX(14yvu3rK05 zCbcCb#{-X3$!YdjF#eBDgE}MB3#aD)R7JD#+?nDLo8x^)ym8{3 zQ5E8#y3oGP??qn4W?0*HZWoUIFq%(m@mB6(X+AA#XEZcF85$xxhx#*LRjs0`#NrKq zODxuh8Du?R*jSV&mL$6~bR9;&)a>`5*{N4QGsVTwPU1i=boDdGs>;@%IVd^Q-)23_ zCNYO=*DE-L4pg~R>ET~0HU7iDRJ!DOM&`NKhks1!Z$bmLfTx`AHx7TTX7o*Q?Ys@V zVT>T7d!it4!3A}Tl&wVbu$rZ?nr*`RUhvig5{Qf69;-><&L{}1hqb(8bRO7XDX_s1 z*k!@rAnjzPIR5EJ8Ve)IoXjqiGevF1ko^@yNXp`s+4$0S!(XgmT-C)}2 z{uoWZZ~8)gakMldW4{Rhsu{w%=cac3F*>#D_Kno4My&Gn!Wug$bFs9yCxLb4{CHGXz9e`K2Z*|IelF-t zbMVbI+)n?%t7Wl%RH~cIPeA_kPc5+X3{7GV*RI8BQRqOGOO;OlsnqzV|5Uo#9E#RxZSU-+1I!IhQ{R595Bgp7eQ4qNPm+BTNTZ!gjHA`VN+l2M5;H?QH z5ZCg}Hls75Ag~@*-ri%w%L5xM1vVH0J0SQQ1Rf!lYiTgyxnKuFu;)Z&U_IEp_v^vt zp$?To9SWh225&>adRRk+u!c%u<*VGkZ(I-V2=yBg#iKPGX10EQhDRl%791wOcKU}! zsq3eIc;s1k29Gw0&ft)I?eq_eX{sBn=kKsT{gdz0s)*mAr(Won3K@Iumo!6I_uSO3 zKmDh6-M*1pb-dJOX@BALkIg$2tCIy2zdQX;)(@xuUi{Qg|C9B{>Ax3$cKZMGDwEF4 zpZ?EL-Kg0!nG@GQV;`cY*6k=xVUAEc8SC?cHwV_}p9P^N1zb7oRrVEaVS3Vz)-=yA z!qzeTE5Ros3rO1*j@F$X4yXS!k~*0uGC3fGJ#wkwwI;tJQZKte5q z=oci5EiHC^DnF`#91r}75M%>Lu;vR$X`LpuB_ziKk5kF9r++#P>Wok?oSOd!6&=&= z#I{p)>M?ysJc{Y$9u<$+9B(aM>Bot4MpcM|>O%eLe?vw0s#;yau^&eBX)T`q2W4ec z)K2DT{y8*6*VF$I(u&0!UPD@}4>QPmz_76>Pb^9C^iRLk?DwGAsaHQU#l_Ihyg)8= z^)ttjirb$#C^^(0qn~Ayn8UT}6&ykbs$8mcj83J-KSrn0CC@W5&*L4VKlC*paY|1T zpM0Qai=WcZb&>zW|9H(uL?2J+QyNeEIv&Q-KRrYJRb+QoLf7u%FO_55O@24o*;jO# z=u=(nziEQv&ca+`&QT(L#x7X{v$|Lti>Fq80R?$O5@tgYFS+7r4 z{|V_oE!uav_b^j*Rzla-coWeyo~hzbR)583sK45`d_?PrZYH|5Xd3U;;$JKJGtnDF zZxp>%G}V9acRc4<(bGgP5KZN)?|RNu(dnWqip~<%Gb!t3E$V^lZ^{yY&B+;@>QKpXlRVhK}yeNObN zqN)8`ukoDUi{2ypfaw2EKWRKi>GfXak^7kR&K5mi^vk07 zP5pgPuTNHg|LeTP{}Me(^lZ`8-+~FsA2~t!+a&)x(K|&S7Oj5fBbq6i#&_=o<^MQA z`9tLQU80AJo*;Uf=y{@PeD9s0{C`bQ{x-?~PV`REhefNOtA3(seD_XJ{*M!s-%fsC zE&4jqA<+e*$BAAcy3+M&q<;KT@plwmD0-IY6{5coO|76esMnW@KHfzh{$@9LOGBau zh`vko4AIozR!cnR<)S-?zEN~<(St=({nt)VewPW#-y!*XMIR7-N_6^-KB8HoX?zb) zQ2wzA$}f@M*}w3f8>0J(?s&83A1<24H&b$}ip~I?+_W`lUFcQ$(L5y0Yl{qN)C0#eYh4$}L`EhUoJ||3h>Q(XB*x65U-iwg3Ob zzf!dED=+b%qN)5f;$JIzz^z^adh@TPaa*eC$2Usvt}gni*29upNq%OEt|ywxUm^a3 zqAM$o*`jBNez{A0*Glg;(Yw0X+q6e}&r>}%6g@zC3%dB9H9>jozFc~H%PxM>`fMq= zUgZ}`9{M4TPZB*{bg}49MXwjF6c6)|#=|`PKyr78{!uiQzf64O?_ZAmmcNyS+dVx^ z^diy4qSJrpU!N(urD*DZXUQKZx=<9msr>P>^V~c9D@Ti-B6@}BFGcSY9ax%L^5gSm z?+2nw68%&Qx#juC&hq^KPJZtay;t-R(bWIyif=>FjYKyQeUa#FQSzR?G_~Z%6SbFG z*;sa8BsxcQd(nnyOLRd(kI?uNqE+(m0`b2rdRaohsqyzkmx|sa`glU0(s=dXSH*vu ziT@JOtwmoax}WGFqUVYJMKm>f%$=UINOY;_6QZg7VRv~>N-q?Dk?0c9Cq=8fz24_U z|64S*{{hLL*F`^-PyMVcyZa^-zuoj7k-r@iJ?tz`|95l7y+ltEy`qaeeCU;ud%?Zl{~DtEil$Mb2StCG?4ZAe^tWG* zy_NsqJ!~g>n&=gxKM?(?=r8W`@=NbeBlF{RB$wJdYdQ9A?qV;sv%I*{s9qz#dyBqJ z^f1wh+FR`b?_qn<*NA>jv@QB2(f9q)%YRXH#fSX(b)sp!=q-}|*F~3#zEO4-i2n3{ zy@kg`E7`?QY9G5$>|ZDQsXTrw`GdY*WAZxWPhRtQ(Zxwzr#$FiUnEMLslN?mH?@DU z_`Az4_EUZ8u#)_&E_yJ26NM$J*G9|y3kyU)E}Do}$gh&fpVUP@wR@iAmWVEWM1KG5 z=|a(yMK2QlhUm9MuN8ez^eNGQh_3Odx3{+Fn?%!mUi7f%Tq>H{P34b~osWnv5nbBF z{s|M5$L^Jh-F5$xM&idii2oYVxuVC3o+i5gW4-Ak|6FAMD#_Er;++`YKQTEOwt~4>@58SiJdfx z*XZ?L&lkN+bh_eOO|;j#P=~K{smH~NbE#;r@hwzb z`^j!M``D!(i=}s;Xj;Ei{<`JJZ>`sQ4y;phU4wT;6iJ#Q| ze7)YQ{Ew9%^hS+u5l!viDgHbE?q69VdhI_n7M;`i;hI#ts?h&m*?ClSwZz_TiM`u3 zK3;#d>DKtyo5naHp5J3ndgzZ4w!s6E!{74kSF*QhkMXP}`v)g}7D@jKQR+vW4~oC0 z@=W9ER$u(BCx4sZ7b?5^Ptrbh+DH0_C-J5AC4S_Xw{G#zmc6}1mnT1{y!IFUnBw}Z zXc`Z4%m;GJM_T_>f1>i#`NN7Qo$u8CCzJ<$OkXVNlFv6K|6S4VC;F-VL$of}c3=Cl zf8Utm>6M~C6#bd#M$`T4vqe*TpOC%BMVBYPtNiXGdaUR|(M2nGe@jGDf5@FC`M)a8 zJ*RrTyQXvg`x?UtZmEubK zfId#`-O4&wobM7{D4NR8lb;WXo+|n&{3i;twQit0YP?&Q_0$yqV9~~N{JJ|>G%;Vb zB{x&AFA`lWx>R(T==#s~_VyP|?QI~rO+;TJ`U=qt5;{@+RGz%vCA-A^Q;k!3{exQ~7P}fAgIz_LaDSDCUQqdh(_VdvaP4#bG$-n+v(WRo> zJkRsziS93Ykm$EW?-9LU^g+?}ZBGJuedOy30HbqYoJx%mX(Q`yE5?%a! zuYZf^%oq6anxczDzb(4UD*p8oL|?M1AMYWW)@M!SLp|CWlmD^G<1EosA3f@b9(5z{ zJ(W+IH+f#G*T4B6KHh6ZuM=G+x~b~0o#>9D^F^uCeHt%T9sVTxi0B4g>cPBSqkPv^ zT+r#NGxLzvj*w)kz)uZ!M?{48JZ zRYg;OPp;-)|A*+n>VEuY(H+RcF2>wZkD}N|0wxCS@fQSE|ea1O7+iFU7%mk_|k-4rtuQd zqu26vhWIM(kH&r8McMqjSi zUnTl_(ep(YiGD})TG4wGI%OSSpP8aZh^F!52a3ND*+YN*F8U`*?xUi}y-4!AiM~m6 zuIPNxgGCP)P2)R5c0VUdzQ52ol}D~yz0h0QML(@$nn$;|yVdtY%BveaNw0re^a9au zC-gdv(|m6hzZ<<(uiq>BsOXC8`u>2frSbCYWAFE}lge)_JJ2~Azb2u}G=^@vo{wic z(ZfWK6g^6Gq39dd_wuR#V`TSyQRF`^y;S~5$*rr`mx<2qV*gcoy(Rid(F;XW`^fE+ z$Sv(6-;`hIJdNLx(7_FS{`-l}-mqK`>_EHOdsC10zMwdMB8vY*rJv?MOZ=CJZX>## z=zBy@6umB?f6=%iKhYILpDVh7=q94w>M_xHo^Ais0ZJX9)ZvPx4%CG_p=rHesr*y= zYVlt$y7@+0Z=zomovghV_Gs@Y`TxA=cG7!&7yrv7_ZQJ8MW;)C57AN4(?mZd`dQI# z`C$i&orTg%>v5U*-RKp1{c6#hMIT7$lNzV?SKipq%c`QYM7I}B5%+oFp_e=a)vrCx7|=(5-N@s2xsx=?jF zO?25#p1=Oio~H30sQ3;SJzDgWqP@z0tcyJPU#i!?A-Y)f8qsS-mxwM>xwiVq$ zbh|G3EHC~YrMI)_TSVzA*3(|QSsLFt(!XBxH(l&u7klT)Zfb9R^)>W`8gC}L zr6}>H`s^Rj(Ik&le&)7*o{rhU(}w1Kf#^AVdj3~L*B|ub%|tJ5`SGoytMBE z`z8D4`t$tjvqiTNeVu5x_`bcJ*SkveN21;0{hZ?cy5jnd=ygfF>nYAnMYkeu(OtX5 zzgZIhwi-isSWZ5(w)Od}FS?uPpy+X;9}&Gw^h(hOME@+hzUr~L=&X^4MmEN6ap=rTWP|Ii1&P(MI#(U`g|l0WAC7};l@Pwg__*n?sx zrD>nB58)@JY2RI?c!(pVw|9w;IF{#sdH%ZDzoN@Lk>7{9%oF*1T5)%?f2HhSBl?pr z{$^;u{;2$&F8ZnE`2Vc@pD+5Q<;0WTH*K|#-$%YI%6%pGfoVUkzKfSXaW_wQdxNKY zh+=1;%l?V}<+1~vtUdI$kbnGg-MeqTkMB{@ec$58hl>7Dbc6jpe^m6NqG|s4N%Q{U zo4tN|UFW`?eYx9xI_F5PyX@2S)vb#EJjHdP=*6N>iT1tK$1zQ`Tl_Cqy5X3RoTPr!bRPe<@+SXOzgsOD>QtSI{49`mD4N2*>YCX~1@ls)L> z8eg4I>IhBi+0D<#Q*!i67p~pV*N$D}~*kNBu|Gc;FXRdQRcRVz)({11UY?t-7j`pR7=;8ytpW8*#ct$1n z7SV%64-s7;dW7iyZ}avRh(1$$ss2Lw`OX2}&w%1SNAz=| zo$9Um_VM*smHzuh(NFzdCp*tS#M^_899p&y{~*17lIYo8ufL0!L-NivW? z%9sKPwxFw`Sb`M`n#IPhEuya2v#ceyHM=W{x@ufSv8}N#_W!-leV>`hA=gP(xBUL| zdVPK8ex7sAJ@?%E+^5VeU-a|f5_rAGeslWW1`dF}d`5HJ$FUrr2y@{fm2Q05a5k)k zjj#z$sOr2P5?3hkOXx@Zn~9_AQ;FR?cpAJMw&BZ|7XVeB77aL zg{M}#c|QZT!_T3Pw;6f{ya+Cbw-;kD(>xGe+ZUtP!y%0OFnA=)g<14J1P+Ij;RlLw@|+9LfERf3 z|EcroZvTffUz1=SoDN&4!_!dL^9$@Y=XhW0A-sh4jWCls> ze4BT&)91r=@B{d%;@7l$p5puthdFS~0;jKoI=^GEyAJj}-PsR^4X_b5!_Q$xy|d4P z1I}>m92lJG+V$|~zjo~+sPm~NkA+bBd)?EY_7^`H&j$G@hjimr=7EeSoADIExm_Gz z4t5jZWGHcTfA>>|N8sb|H7N7C-ZQ`NV0ZYbuI@6gbE&7ESDD8d%x4C1Ghq|?W~q6+ zz%!p)(698b*8AnKRo1@> zP>SCTQ0(vV*nfbX@CC6WPZd7cmw8$abzX8FO5L>oQ2eT)*e~_;_ZW442Cjy?p5@kC zGt58RwRL|VDf_lG_7Zmw?Dl~}ppHKbU3eJnY>$04dHPt(@iXD2@OO$2(AN2UE&4gs z174^2yd2j7L|5#t|HkqlKAoQV7`Y)wj3D1DK|6%Aqha;eGeA@pr?1kUb z?s=}O*QT&H)c!w19|+gOjPp7_Ut=790p?>DhYhe1w!-ZebskUp`5AT+XFlx>@93Lg@>PGu^tS|N(BE*_sQO<)zmI$R*YU)^nK(LM$#XpQ zk$Om;Qjc7f=d-liRo+rB=~wEtT;=Vn-yY;K6iQw0_4KF5BYrX-osYIpH(qTov25Nh$vry_PoIyWAsqcm8*FdSS<_8=XW>9~j zjC(Hn*@`;fbp7ji+W%bYa4EbB-Uj!lzF9C&aRu!MU=8Dwy#7M_9oU=k2oI($yq@-Q zsPonN>G;}S#_=fQk^J+?SMrkiki29*BriFSb^O=KGvg|E-etl;P}^^PwX@q1?gvl0 z#_7V_X$v2wy$*f?hb?t}Unp*Nt<#17{Ech>tNEPY&Hnn*e?Pb{%!LitxqRY{j(7Zv z`N{bI&iL1=I&`C&jL&-y^<6Xf# zNF135-+H+L`?ugz%-dSe{B5($&9ATz?YXcCu7Yde7f|QB`SmWIk6UwmE?fvNhK=ws z#W!iU!>w*`{pkKB{&v{y1P8(ZKcD|F?DC=H(IUc*N+KZhYuk@qi&nA9X z?VrQGkn{0C&a3+0y7OcSY=^o(@qdvx;@?ah@o)9`ch^3PxLu7u6#K*AFW{XpU4AmI z*BRfNa60uG&bXvrx;`^F9)&SD8)|!rEAt`alzya+zWL~`{iD>OtMQ-2{#p2ExF_RD zm*3BBaqB7$b8mO;#ZcFy5xeQPI=go4zJm+zaC#%mZ*uJ>sN=mzym3EKym`b~16SVW z`u`Z}{>5%B_V2<^;HU6&_#N!!i6{Ct9N!U29<9_t_&n{u!MEY&ce=cFz8Tb6<|&gp zXF;j6#P|8{NSvKvCe-##=rYfeSAS1_cmIp__v804d=%<@WSz;lWu5h>ZbDgilIIzo zeD6X36KuT8)qOeC{lAFaEAa2|E7*!(o5#QR3KzdGTn{rm_F}gyc6-4i#P4nwFB9r~ zCt`QJ*was@r@yDM`wJAiY>&O@!i~ry1MUMy!+G#z*a&ZfI)8~fiT;m=Q7Ccq{zZS? z-v`8%am0x$c{k9$0xpFz4ju2%d))jS4ky9sFal@7Qdqar`3cXb-3l8Yb;ny^eT!>1 zz_ovJ?f2m9=UiLo=j*?UJm$eu-~!kPe+zrw>*C)AcT@QW_q*e9@|FBsA9s4j6OKz@ zGt7R{>8&v9Y1eLot*{-|KjV%!z~8`|;9c-(xD)jm26cVbGQN|3@8Zh%0>;sYT_Ip3rXanHKd=i^Vcj(zL4tLOXqjBhc#5?&Ac zaGvf2cZG+;qd9+bVIGw8TG#VT{1(CncsYCnz7Mtk4d}mzJsxo9+d;5-m1__9qhmHK zgtCtW?29`7hxq>!ex>4R`zOfbIVgEdBcDoG54Ha?^gG}R_#k`~E`QjKXQ5hOSx-5A z6r2u^hfSQvt)BB);`eya#n}XI1$Dlkl8@#uAs&AjKrR_gQ`d>g(C^?0Pe$5em2J>vS?6CMn;|2F8t9cYWcwm*^Mg>Vk6 zRqX0`b^HOW@5A62m;<%F=uwXENF9Z5vcC&^Q%7N(c0F97xG(EeDA#S_U!Qe#7WUyf zEo`GLOqajTN88IdPyQFj+uiX6j87=z6v{Y-GESk+U-A~pJP9+IKcUQ9iv4dJxD%B7 zJ?*~;zh>A1pMsg}k8+*Y{{O&E*0nybUl&-2XN)Zu;j5!{Hpb$=^3Zy$xN>b%zW zx6|)a@P#z{vpgr3@jRuU({y}!4!#0=IZtF=Yx_<9?B-QiOIz5u+8w_W-v5GY3w`m1 zs5lbu0^;bnEh_#R`bii6$HtR9r>cBUp{@Hr_b+bzqyE~FGiiUuIKG1$F^)apP&gi* z2&JAIuW@k;VKJm_3-~x{2v=n`wvxhk@0Uw|Jq*aI1xXwlX_i^ zpRl|B+Fttc&6o5e^P&BvzQVn!=l*aslsaqwZ8*LQ><@i$wEsoassHnCoyd72>qgt3 zPy9>a?eIzXEd2Z>7w?i+92;MCY=N7-?%Fzj7J5u^mdAc6`i<}r_%eJAZuW-jZ_(c! z8{TqU3IDma^L#SjcKS5M>9lqJx1-;ehAkY=dDq3C1Djwo)bXcu)4l-vnXsgr{*vd5 z&Dc4!3>J`Del`sQZ)nn)}gTI{(4g`SR2K ziQNeNa$r7`JhMIdmS9&7Yv2Vi7r%Uu|7F-+31uE0qMj}AX*hy<3Z<^XtLaDBOk1eO z-`)PT|1$Ev1!j<6Ce-#~_XzejIsJ9G z^ZBlw2hW8%-VxaU3W~i@+h2~|Rd6Z11!{ZA<0$$c1;={w@!9$Ek#XHjyj$Syp7=hy zhdlQEE^s3n4=2J?;R1Li)Z^a|J)Qrh9{*t;|6h6Rqv$$6U;H^9`-?pBzhxaq-*?xG zg|Np5uDv&`hq@l(zZrg8z-?h)xF1{s*TZ!2#r`H`KiHGcEh@g)`SSk*_HV#+_Jgt0 z^^!bweZ+n`e!qedsO^1rUF~lvbl4=_-(su>-?o3 zq4f6%{fYl@;%NUC?B0cv&l}`3ElvN2W2fyiKXUmFhray9zgYD*i+)@2-UjqJO8<-K|4}IO zQO~$vq<>$$6S3>6z4Wt={={!Nadf@3{UYqr**{7AXQ1?_<4YW=_guz%s%L$C!g=63 zUv>PAKX&U}xE<|3z*czV7tU@Z90zB>mH+Jg{9ca#3K)Fq>^6fspI5M3|B189!R|?z z@tM>2fYN`QJepw}Y=;@-Hvk?B>*0k^=d(F^NIpMx{Ap@@dOSLxld!)T-UWXTPh`AN zsQrC@QeWv`$C3K#czx)1ceoz*WPY^$0QAe?MxVR+>`lH)pwzjm^X6NBhpYZ{Je}VZ z>=(eZ;kj@J*2zwu_2ToB@k;+Xj;u?a&;F`DzIE#x|CsfzzHffnk)ytH?IzgkYu6UG z(+<9I`sT0!ey=#`J7;$c`~z%<>tXP{v&&R0rY*dX_F}kc&{LNtZ09k)yP%Axm2qjO z6RwNYh?lc&O(x0~1cDlcG_TyB3KKtXz z<3yF0w%2u#w$wx0OFcAw^;yn&`6$%qnT{{};AY>teQgW)Gq@W(1ZscnCw3FDZ=rr` zJo9-1cC(?_t@GH+I?Q8TPGOw+a3-vUI$!O7LO1>8dLoqTicnuSdb96u@7e#KQ`ebv z_V*CyLHHPa9li-af$<*hx^ot6hA(g2`SmEB|C)6E9N(m;i=PSCZRFY+^g96NLtj4P zzc+CPz}dvBhd*`vEczMh>F;m!oB0!sNBS$Gzg*&{tB;J|mycfmml5{~PyX6|lTF;b zZ3%aP2g4z7By5JOVaBG;fB(%Lb^LVx1Je0(d>V|y;k{gc`LGr?L0>-NUqhT)c>iWD zUMu{mF`W= zG0fP)&CA{}AI{&Z^Yxa_zc!se$8UtqaN(A&zb4oM1M=|YBmR#Orv+|-e{M-Ro!oR>5;8(C^YnOlR zwvLUkc01Qz4xfRlyFkZl`;qb9!vAgfA?&k_%O?wFlV`EytMYH6y-tp+@vQQUN8%qs zKf~a;8Po^zV$EXQI1;or_!HLpI2A2{)BR#>3jxn@7CQBa6FtY`p)k7c&Pm!!0vI_+Sl2? z47Gj24tud%@3C*i?x;R4ZvIY=r@()Z*LQH+e(v~za1fjZbv_bzJn^%M`%9?p#V!x~ zzS#9wev+s5zYss+!#{KRu7Xd%XW?1YWeHpguZIih_bM2t4ps1EcpZERzUJW)>a-L- z0srEu-+wy)booeKg;K{?si)LU)~VF(Uh1dovW#&H^?as_e?4&}zV??qg-ci;LdpAG z^3P`8b76P${X21d@pOKYhfw@JCywNi|1akA590XZ>3nXYKDWX@TujW#88M9!J0b2cvKfl>U0sPcQlr{@8fhU;3?~e_apBL&mTDPs2~@ zsq3fhW!)}e{mQzOeNWr3VEj+Q=b`NL+WsWg`$BjLlzm^@uh_+{xBK89;InWw+-X;5 z*B_4A%eC9~bzHxnWB&e*t#H5ru03<0V+mZKcpdH5gPmP-mSg51$BPC#UJU=B*fhi) zZ-vu`y7uw#T*dgI?syeE8SXO7>3hKwV8LNduYjK(?%H3%jehRho5StlPH+}1gY~~~ z_PvgD>azsu`R&U*{io*h z2F};#p`0ICs$RLQ|5jBG-+EigIA*ZEieVP(YJz8dN&jt}r*A@?&kFKuh5zmRfLZU651r7n8>(y!ic)?vS;s+Z6HGuH9m>`$`46s!H?3f9$f z#w+VO-T5i&TJ}>}*R`^bssTv<`*EE*5YG4?%O{7tCVKK4`CqP=) zWB)$X>si~M$#cPNQ0~uiSm*U}Uj}6z%l(qWvG3*<@=N)Z- z7S|Ks^QyL=$o-G+c~#rXKEJ{9B>TU%m*=?kySw$>cYtFrp4attMf(rWboL|RFJbK- z9plLJf4zDR((&%XZ*_m?FYgEBx+u?0@_elQgFT&Jf8Ian_XYa-S^LX-3(Y}$yST!U zY2IrDyw?!QIOILXJ-o;8QSz4SzC0JTtM>x`srLZS@w`?t%GKdR=&PU9NqA5f>-GQl z`iy5?R>QgQWOy2sx(T~mzs0Pt|JT;fv5a3>KzlYUh3V>dHg*?5siUx8H`ikw^?Zo? z@&8xO$L`kaRqC}49>=~Hh2`+tecV1E`?`J)DEpq?uk?PgmD*S3K2F{%$$oRXXTOp8 z%p*=Q&ovED{4VqOKf*ZPg7RG7i|6@U@cVrPcPP=^pit>lBe{m z{kO-iFYE^oh1y>B)AzYg@!c28dpQ}WZ-2j;IFEYby-1yW{&$h*O85Y5_2e)8yh(rh zJ+N+=Tg*=LWeRYX36go&*=cyWstB71aK6UvUEK zL*D!69O=%tZK?0Rp7khx)%c5FE&k&73y;6}U4p;(t;Aparh5FvZw3D1w;q4-lk-}S zUw`lOCExQ1_4hiy?``D$hs;@a!sg;QPoF8Dgs`JXV>+2zC8a2`Az zW{-DvP4uVx-<*E8g?-=*`i-i5{^ZF=`ma{~KSuj0_*baMb1%B^A==`v?bmbsYxo`9 zbetQnP{!Zg@#Ijqi7=`dqb=(tPTg*Ycf)(3%x{*bevQOyg|B(yFCkuU;s|wp_GcXn z52igB9ttIY?JxcK#-r^|ev=@Y=>XXa_w!49d-N<@c$Tors8S)9glT!&WCHsBZK_c|H>WDI??ej5yux{A$cu= zi{X{X&i@2g!e84Q0GO!dTN9Z!0*Yg&rIi^%lW(jKE`>yQHeW#1e^uS zU=2JO*2DW?3p|MPVyNf*=*K!f4mOg9-e(RWud`G?y1vii{~~-@#nblvSl9XRF#2hR zGLDUAyLxE+=%g{29tT$C&Rv z)NdG+aSii~?G55}x@?5itjjau>5S)6xIg0%UQ2x8kBzVWC9fv(le`+q zPx6xUM)DF$Uc$XtU&2c2C`{M?V)~W-wf!^X`57EXy@U@?uVy%ceB`{=@g&aX^eb_M z+J0JrTle`;?gL~W(e`t&yA`f0bpGE$ZC^*;=fDe~)K}ZfIHlgdQuTg_cDrXiKS}(J zsgu~R_SlbR-#QvjQ#_XT2Z}qDx^WMH$ERTf$AwqWUhd&)bRQon>wLdDlRR&Ql3zCQ zvhZ8t@n4q4U(Z*ZIH$k`Y2r&>&(M$Ll|z0yeoyqxVHMPMlzM)`abb7kX?y8c=3Dv^ zCi?NzQ?Cm>pZ)NYdC~m`9N!vl55-U0zsB)(ibZj^Uh3hqC%Lw;rpmR2#nrBT2`s2_ zZQb9`%AI}`Y=>XLpwb$KmN%4y4&BO%u6wpaX!a*b^Xr8?rzx5dK$oZo0x}Zq4s|nzt>#qMhFjvt=uxb=CCcfdcxPob`ljCcK9=a<2_iap~CPIGn(|IOojhH>hAGs!at z4j`Yh(_LPzu%7&uo{0{n{+X)&aZmkq|I*)q^m{PO|1bAHoIHNv$>+rXa6KfSIVzv# zpLjk#r0#lr(vO}$vHu=FVORY#sN<2Up1%HOvrey;^NanW{baW;Wu40TluvzR-L})t zVBg4rvY*I0mi(bOiEr&qt&&E&atEcwA1ixoI_1E_OxUS^DT&|A;Sm(J=>eNbm4U}~)*Gu2^ z(Rclj{_^N|I=u1>cRn`3|8_q4Jea~sjcuo^ONW0bZT=O8$Z^9*<$3i);(hp#(Haq+Wu$Vw3oQE z)Oy~aAMQJ4y>7{RmAr+OjN>%Vc*fDs(Qp#XgNbp`-*@c0(w`o0cjIaQ6Y1ACer>-5 zd)Ws9@|5>B+Wsc&g?F(Jw7}8SQTQ9`Cg*c5=dJL5_1@+g&NpF(I&TKk9tLBI=g=0W z%m25GNA^D%hwNuE4%x3HZ`pq&PdWc3A32XD58wHGy4qJ|e--Ndmt%h$Y*PN(zK!E= z!S~@d%$K}Jo5DQo%KNf)>b;q7KkRCMo2vdYJ@2oEp$jFSzy6E)NF3pP#PP+`i#5t5B$XbAdmf~*hwBj$wTPNN86n?K?Bi(ES&_GoZz;mXCXoprI}>6ba`_-(}Bi}(`nUE+#=BXLf> z)Wtau-U1_@_#YF$pNii~d>yYBaeVP4zmq)vdVKS-lm61hUyS|TFrEEt*h#%cQzxmH z)JNjz{7%6B44BS-Hg&9lnauM6P{$WLSvO*r}hHRM$f--92*FJT7jwie1d{HgQP{r8|h>0kFJ zb&&I0>d-_TWSm0nFXw-M?4=H^j5~||bD;L$4L|We2S4%G_LA2<_%*}F;mOR?5~%&f zt`&P(ms7CMhjA50_BT1tgaza){IUJrNWapbjwgAqC4b37D0v89B0r(5gPoX<6BKoS ztLaDj)Bf6C@@{7w!hrKe+c&cR3U8C_5V>9^RH$+=fE3a6ZFNGd^9C5VY>Ja(T^U#_-p#&Y5xTmIYszu+Kb>a zxB_bb4;MS-WB3K!PAz@uS7lhaRzx>xO=&VCyG9S4ix3K-DuMo{-BdF64u9A;dhEnRzm^k2YQcs{%i zJ_etHFTi!Txj3J}FX1M)cix|lD{=loyxvQk-}6vM5&b=mZ+4}#xc_Qx*-@9{E!aH+ zUxpiB^TYn>{QBWP9A0p3=kY|Jw9Fl!3crKeYjC4ej)ddj@z5Pj{#TCwlHHd=A^EiH58vCZ3 zo!>q1A^0b#;}5>YDTl#gc#Y!fTb(|A zs-9u!4ET~_#?>5$XDRks>W-fezq{78b-q29IQ>|dNk7A(w%;7P!OC9zwEbb&je`58 zi7$Bwi|{LjI{tk0OQ6)tm(Oe1{T;p!<5#*m$hc>aXDju475*Krh3jEo>YD{;c+x&*^RZtHFN4dVwtpS{UHAz+hWh3~nFsAZjN@Ik&+exEE$lZd z)xNU@>qzHwz;$lDoUXW(_HuZ9qq7rUNL#puwy=$M?r)sm35u7}7Ct~**i2jJdzi{o z@~;0M%~$6q^{Z9&TjHso)Gc4ttFepqT18zZ6aNm_3MKBj#M5zg{of|u#`xFcC;r-A z?9%lwankj_2mS5?_k%;B?qAm7j^x=F?gV}IJ8)dsRsUD;J9wE}_ri&^XTUA4cgKZC z(iSeHEo`72+~E9rD~_fuoI_g}r>)2Pt|#BD|IvJuKz#N?+frHxEAXEWgR}wcw69; z&}aV`$Aw+>Uqn4#SNxWCuN&R@aKGX|XbXqmnC+iUl*P7!RwFX68o z#4cU`5+_~%3+VT3crLsQs_uhq@|z25VIB0@*Kl0eRsZ@sT|`;G8By16Q2eUE>B8BC zt}T3ywym$94&@)I@{U_E*px~;qYY+<(T9>LB* zTh2ydd;P{Cg1wDy>yWk5wX+?9vFLGhsdGMh6Z(zV+n{l7x=F>FEhw|Qzd+BnCy4n_zMv32c*5z=VPA_b``~Q!MMm!t z>=fi2ViGeSnXel|ednN6&EsvvX>D=wWxk$5&*nsz^X?t7N6)9<9-FxFWI0R0H`+-IC%_ZRy)UhI`#jh^+avwPJcxEMX-Pfj?Gd~QT>(rF4v(?_i_$r8@)%6 z5q$oRTYz*MT!cOa-893`QuM|*oc$Q|$I+YLa{4ytucGH;Pq)FQo4I~7(dB$R7`?5{ z#o32AGte8+W&c@#p7o})m-Dm{Js(+~Z9^o4IbeRK40&@+j%C;HxI z!P~kuzwYcOpie?yxz_2u(WB@M^t&7SuhHv?(;xjd^lbEj=r5qh8Sl@~KSQsj-!0L5 znSt0m+tqjnpl1+gXY9wJf6BbOQ3Sy;=mGi2yv#>0R{dUxUaRVP9eSL6cBkJzqW8jn z3-s0K&9Avk_CWs*eYvXhw#Lzpw~=+2f&G5yAE|L2g8qimv(Z0P`qAj`EB#pXca zoH*um2tU`N$5o!cN8gq><}?pKkD+g&^yksnQwOQ%+vrEAJU>G}ROvm)~MZ%ZMZA z%Ms`eN*|BDPUSfReUY+{p|_yRIy?zIn|T>R-L67kg}v+#H=&=c;@^e7Kf27zAJAVR zPg&2c=(*~AUxz+`d6Bw(i@pTiG{aAZnP^+*HRxtK!cTwn;q)u(X9#)*{r16rBKktr zZ$A27YFy>$tt$ShqN{OTg5E-W(+od1q7P8>_LcrF1^UC}BkT5I^qDHpr_rNIUxOZSUJNGx9_GSr>oWs;soU1*S!#bc1ikrH zcb_2lCnusmtnx2KzgOueqcyb&pvPA`{SC(TE_(h8 zPWT>un{8d3{1=_jzy)9!db@q`Vm|8~g6X2a;)El(QJasR^_tVyaQ}ZXdPbYmCI8={ zXQIz_hl4ffjp(PLZ)I*6!skr}#PEVF^x*H#P@YG|qsP&C3=SgbS#LV~O7dKY-t?B! zPo>{m#D1+44#55q^!&G-elGT}qqn2CQ=hNU+un7C1zZ67nj0!RuH28D{w)i7km#Q| z{ZGU{20in0CyXSYD)jglPJaabGW0Aa@D%3vHuR>ioqaFzd=$O;Tc@9d{k!PdJzU^7 zxWIg4bo<_*k>_r+%)-xBX5$UttBi92zcZYR{YU6cdpbe#*?vctXRw#k3$Z^C zJ-)XSe)JJ;U`0l^`(E4MT;fkM-YV=f2)qRs{%g@QOI)0r81K92t#h1y z3UM|y8-BRXOP$WP8yth4RngJD9K8vBfjb*ND?t=i*#L{@du@WD3bRI&EW zY8?(Rx*bzArfom1hBkhSs?S^KfzrPtPMjB?8`1IZ<^_=*S3MWf^BLD1^o-YCo^pPji{5}< ziv6?b!P_0}-<0_1lezBn+{N`P-xGbpdfOFUzAu`Oo`v4}o{N8vLoflo;R7d>5x)pM z_}J+y$#Xt>^FN(Fl?%o)^h{F?`zZ?l8wAfue00fwqg`G8Z5um#(GNn;+PtIwEA;xU zoPG?~k@F?ac2561sXUw7b8^TN%(udW~K7NA^@jyAfT-(a+} z@5hC+EVSP_SfkeG+1O|1Ir|;Veq=vap=Zx=`sohAz39zlPFTkI`x1J*#_7A5{n~!E zGB3nzJ`McuV<~IUUv&O=h#wIr*XVYgx2o%S33`jt&p~fidL#Nur9W)+aQ*YYH({F# zUPqVjDUWmM2VbMh_my(rwRNV8Bi~zoZRW{-_R4hglF#=D_WLmVIWp6YD?^>9)6tvx z-iqZA%ntRPg6vUlekINV>>E^^M)ZYBA8O7IThDr>pA|l*>>Si8{Z8Vm%_gnd2Z$`0J;W24*pXYjklPnq}Ldr-F{I>y;I)OQZDRh%(me|Sgxnb@~6 z@6zvFvFCg-X@s9!(X*A_qd$3G=hkzRLog7%ncq{1o{t{Cp`-mmqucYe@i3RCoTp3B zgF~I3O+I&`XQRvY{V9oqzP_h(cr(;@4l=1vCUHK-K9l-np>MXQ%O{}D`RMzgXCCSD zk$%UDJ-WHvho2aFyZyq^d@{oS2Em!=nb}S^gAYH~pw|;e*7H5+%_E(CJ#kvlgE3B* zeBMNF8|`$-=UenvbjfGOz1(=4i6im%N6%OBj|_G5zMbb~IUgsXf6Vhcq0U)D3_43>s^pP=bLR|oNWlsIt}r!}^u%6PBC?mIKxA|Z?Nv*j(JWpde6YzOv}Q-AZeWpi0*`uFr^v=%HD?Rp29(|Q3&Z{2#c8|X0 zex29NZr4)t)YE$xkNrU&{YZ~K+320sq0nQ0ibp@+qhI6Ef9ug7@aWHb^mjb^*B-t1 z{+*9^H=}n}=L0?ZD35-OM=$W`zxL>hJ^FPXeNXe8+gbiAJoc-M-r2mb_SnDe(ZBcT z83%Np&n_N)e~&)GqaWwdOFjB|9{nn#cXr+Ut;hZzkN&Jjf8C>h>d|{1*!jHlF?wh7 zyRSzd=FxLJ`UxI=wnsnDqc8F3D?IutkN#JWzRsh6W%SP0^Hv9SUbo#m`avFjj7Oj5 z(ThC#SswiokN!K4zS5&VW%SPK@V3YPbC15sz|QNIVf1ay`-evE+c)N-bb`me)T5v7 z(HD92r5^oukAA;LU*pl&di1Y6`lbhWUY~v*{Xma?q(?u_qtEf^^F8_^kKX9f@Al{| z9{p91{=P^5%A@zn>b#yidGvie`p-T3IFCNvqgQ$KUmLx%>&3Mm`@22*V;=oAkN%-Y z|IVXtGpO@=_V?&RJbJcAKgQ_hmDC2GQjh(7kA8tizsjR8_vkA<`ZFH=Esx&r(SyQ@ z%GkidAQFk!)kdO~mC?FLBvKkHk3`VQVr3PTb#qH%^CFR1vFb=cv?|ugA&*a0X-Q%1 zha4+oGYczf%Bv$41+!y?)m4#_@<`}JAJy?lb!BvJtg~*l^)N+iXwZ&4z{{39xExISrI8Li+3KWC^j=%Q(A5N2_52*axVu!k$kJy{o(6jqZ(Zr!AsvVvG;WPEw`EK1wG>vw>mqgqN2)6#Wfes=rHNUMM=(vDD6@J+?XZ6Bv?hf}b#Y}ZT4c*Irz%oY z6)Q4%{D28r+A1a1dJu8BRacf2#foftRqoFXL%B0I60NE#nPpA~GZj%8cy8Ua@)EmN zBfqRDDaSQlXGR(+G%1>MtSo9y{gU$PSY^C2X8s!~DH=HFu%W|;NIx)jM@Wv;9JJGv zJVnjoid7FRsj7?)%;I3m87X_phDYp4{DW&dJj;`7J0+++;y=yp(ax96v1a3|s5I3o zjZ7w?+&XirL`K-{P?m5?M|Q{Pbfd9-%$b*RmaC;3=APUG)KPm*ji~By)=iC7A6p$Q zD2;Wjq*))G$rEFhvtsT*RY!+W;T)T@uB3ccUbJ9DdC~atl4{qM-Dr+na^^%vOdU0T zyeWlUs-|TMQ&dtGE3dM%(T*mRE&&Cs%%GoiH3Nb&3?3 zgu{^*m6(FrRphEUrnIyqUX?PKF=g>;v-cE7(Q>;jCOpTN z7gm(T&7N=8L!_`cX7-etvZ_c{ZKO6b*D%G9IJF%?Ek)+Y1B&Tb<* zLpL_Fz1SWTSxyY^Y&xdtv}5hvj>)q!Vy4{=Px&N|yStXeVSDFw@HI znQM3K!isWp3uTtDz0#SsO8eMoX^rv?hnTEJBHhT~ls{!_o)d|r{CQ~7Vp!tOXo1{h z&WVKAJ$swsYLc`mPcDXNRb6>uiOsyyESi$?SaRM{?m*|5TR3wPCL)9_dz)$pnxYzi zdt+%%pTbx{v~W)HP(^8}Sw7swxTz~lYLV2mO%bb0X4O=fdy8m!ky)i3PAhfPoXGlk zWz4RPl&;NfZ=%KBlFOi|q{_}*@}Rx5v!}C~w^%sA2{W@~k~f2MA~AE*8>@7;uP$z^ z!?rlHG&(C;I&(Jb5CnA(rnESWzW;}c@ zDXOuLNs*$O@N_M&NM>ZFJmC~iUAi{Khtr zJ?%2=U{X`=`c1tvofGbWbHfW=!q{B5W+h!KV|KjBgJF{^j#g8aMrCYPNtL-XOqiJ4 znT|<{pksv>fTUaM60!H($s^U#l!a;fvd>X&V$JhlYQxp*`|c+uyAYQCQNen%_X`fWp}ra`er*e z6`NUMBIKH7XYSv|mQ_dW1#VPvv@)+^M5%ecF!zJi1I?~mRUNOah=(`%cBW>U6idU6 zP93z7M%kN|qhodRDk_VnhBu>Comk~Y&D(~_;e&p(6zfjy>L$B~N_*qnS)9Z(&lvky z&{>En(UL0j{-whx!bFpA6%r?l(o>!q#*UbpH)_O$36Z1695;RPl+jZuT*@QE4_QYh zj>*fJJo*QnCQTkOWt@#`Yb?*qW?SUl5WaSb^2|!=c=MlIXYNZP<4Wen$`enO6Qk8; zAF3J{Hz!}tZWnRoP;O;~y)APq ztft)FAK1<~8m=0*T+9JmfW*5aPnIc#w;7o$cj7)K89|=kJuz}+b&ZQvk59QorabwF zCndR#4=<{tE2_=C@Wk-_K_|;XQUKh=6mv(yWbd9&~yWB&vofuPX zyBqNKFD0jx+XAmmc|o1o1{sgnO71Dr*`-|iy|Jol3fya|w7r`B)VzKXvx1tEQgc%r zF$L>*XtKHjBEIpxmUl+L}oO+0eqoKjP>%i3qP4G)AbjO-1uy%`Kfj~_QaFOoZA z{FJGYL9&=q!kCcf9 z`{-lt+BXdKg9p3S&!P78{-J*S2hGq6!Z!>X<`=P-Q2VmFrab1J*k{T;tIWQ7k{8*Y z7G}duyZ}k5iMc-t9|6rBN36E9mw{s7=H9*EuoqhLGqtwoFR#-}%qyJ4>-3H*&)qJV zo~=2~X5%tOQS0Axvi1+?4!*Up_AIC1nt)OGFW{PBXg8^ zLhS5|oDQAo?{REJQWuR(Mye*gOx)nDPfF-;ZfrE)uF;)=4jvqa3tve^<$+Fj<~`c2 zp0aFDaylh$%FHMdYKJE^v$xni*M8Mwob07EakF7>W!)QKyHmSEc0-9wG2bKDE;?9` zGq)!8mD1GG3OUPDmSDKm$V*+PoAvG6@Jz}5@2HYxb34-y8pqA~5#FY0uOZ>U!*R>| zO-V1|4qW_*JNnJ1&f)8J6| z3^*t&<$-X}Q1eJwQC(rasWC6<>~}ba*zboUgUZZ{(+;mi>?%mye$6bcNW3{pN#AbT z;Sz|OZ+w!E?Q$Z9_q6IdWv><;_QRBL;jY$UNtNjfN79-a*->|Xr{ESyhqHpkZPxTi zcY8I-eO((jV@)iNi7B%<$Zllen;Tx1%VO$q3q5F9)?j%hy5TLfJvxkRwVV0zf=jbg zw;}dTtUeq0ZgWzF6xJG;lf5P`shXP=`;N-KG}FiE&3!9p?hovJOZc_3tw8dTCfp9H z&7Oe0OlTzHUhE~VI_@1%hn?BFadM_^&gzwGB=G`#R;=8-Su7094NLesm5tfHgr)bC zh$(Z!K{D82T_gqjY?gYVP6?MZ>KM&)?d{aFL+HqG^M&T2gJinP%nQKoEl)cS&g&;U zm2J?(@=lI9;$7XH7`q)Py@%Uey>{+gqX5q_$ zj{b>`%-mOK8{f^9xm}E!#lm+pDXTzMVtBkP8jsso;mJyNIP9)|8y+RU4G%Dk4G)M% z%C9$6hN)+mJ0!_%c!a!C4@d{8nq-rz&2itlC2n!dmohWz6_H}|($aq8GWxhl zBPNa?Wz=z#rbWi&;E*$VijndrjuO{#6DE%wF(EQ}?AWPe@*;U7Mot)G0@@CPenAH|Wrq-Dk&}D8T&#fD6U(4XkyQrC! zu~_!F3FAkOiVPk&c;HYI(^=W~+hGj%YbEQJeC^|cPpYUkZ;VP~_Tes8B%Mrjzn#hp zH}~;*6U}!NGI?g~cIwQR_ohs_b>qfQm}>7I&3&Qy9hUh?SZ>`|dm9km6_`d|_(gIU zC^7UzDNJ|9FZ_j-F%9c5qAK(-O?jtkf8I4c7M(LCHq)HMCSv$g7T4*ta`V2ba89hq zT&#_Yd*3zMY^USh1dK87r=$nxXROACzYv;ao=1&`xoI71%4hx@mH1teIW(r$D2X2{ z<(8WF=H{K5(MGx-0whO^kvmGxCL1om_RA|*Xy+&ec5mq-#>?ewBiolwCYg#dH?8Jf z+0^h0ibN^Kxr-ptr<)%K*lA9y9~?T2GHwnm4b;!IsBe)TL;40lMsMzQ%S^ zg{h5st4q^_OB|L_j*5(ql_t#1*M{cXx>(}Pt~o$$CYoP&mBdSJC|swM6c&%NzacQU z6{hm``+GYd=1qtB$)Q@xl*){n>2+gHCSjMfeN$`h=L^lAQ*8F3Xh~@z${{vGa~e%C zU$dGYMaT@;F?RYY+M1hVX26_YX3Zr#bIV5BiF4R?kn$4F45YHKxH6H0J1MQvX!9Ge zSYh~kIXfF}eGqP9_$>?R+S!y`r-r|tWPTH8+?ew4*MQ-haQU&6J1tDD#*emf?DDt& z37330^KwTO8D-vwnQuI+jF~$}t&`bj0&~HtidC!B?RjGMr0|Dou0Dx*<_*4yGkI#H zsyuGK0Ir^CquLkDBkh#rn9ai;PJT%;wxm2#iLyw5ZWA=v$ zxpnUAqbae%8uJy^+?ah--axJ>pHNa3UIg^|wWjhLxbV%2c{sOUXGP7gSM2?Zi9gnS zNfa}y&wbA~%RG$P#ch7K5i!ZQ*;4B;ygN3@+f&}!r0kJKHHuw(lg)Frc}ANj%PPD` zm{VA$y)a&vsNW!a+Hn3(iP`VQ%_YD_wm0skSS2${%(FvcQrT^cptmt2+0$uqp{bU6 zO0wf~SC`Q-^P0~L)%}K3zFsrtOj(pdYgr9^YHnEaWH z{q?3Xq7$khOG&oVi1`T?C!yU769XGE@Q`pEHnYSy5|=#omat-WY4P49{Qk&38ihZ~ zOnq&@SI4PeBb(o0b$n?cR~WnYQl9b?BQTTdu8J~Olg#f%%-MPF9n<+KVY+P0x0yx#7uTm*?1+`5My1m5!2^VIwA;%$Z_Of^ZGl z-+m|VDa3EQeZf)Q!8;s%_@$i8YglD-#)RixZe3zamOCHoVNc|ef|}~YHGm|>S52)c za6fi(%W$gsJ%UXuyrkINj5C+I4K6U@PL&)a#T^xmo8Mo%D{%7Q=veq8A`{S-M{Zul z))X+8w>f42;pNHgNVa>sgUVQ?Fv*h0eNF0~Ybz2&?2V@9HZwKMMcZOUW|&QbGaL~YbQScKQP z#98RJ7m4Ib#%XTv;=>f#%PF z_6KI+A64eJIRmTh?l3TXRvTDZ5&i^aV62!2z2YJhO`6Z$Go}(=M!fRkrte|F=@wdNRGP-Mqze-_}g~FEW}P;-=>R z!jB{j?fOdnNFJh{ZT?90&%{p{mkx2rP+YA18)i5IVJ7wh?SGXyklKF}{=)n;{a>&A z<^O+7f@5W7Tn5s= z;xGR`R8trI-!Z;6fAL?*zt6N1e?4E)uW<=KpPB#KwJ-ki?>n{N-)4iGkCajTCGKVB zSZe>v2f9ehcXQ0fKMZ32BmTl~mB0MEQ0sPg{yA#G#80@XiJ#iP{JT}zdpZ9B?1$2S zru+fzKPPNsIqM*(=YRKJJj^Nf|L;rcCo{ES{@#}Uvy?9W=AVJ+@UgktkI?=z#PYX0 z;{JOH{kNxzDSjgF=kY&txXXW5lZ?!H=)Q(}{NG#WcEtWtXgbvX_TLlMnl;_>W9R>2 zFFCV1?|(A>x_)1N={g>81swzFOL#o~9j(m2H@|rEP@4R8#{r0+*vCBn@$>mt77p#` z(Xr*m-f@I3a(tCrc#VTydoP1B<1E?OYmxofEIZCnCV~!6*5|*kyKwT) LAdCA3bM^lLvRWEh literal 0 HcmV?d00001

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 LAdCA3bM^lLvRWEh literal 0 HcmV?d00001 diff --git a/talkingface/utils/vits_utils/monotonic_align/monotonic_align/core.cpython-37m-x86_64-linux-gnu.so b/talkingface/utils/vits_utils/monotonic_align/monotonic_align/core.cpython-37m-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..d9d6578d592244ca763ea175efb642f8f188dc9c GIT binary patch literal 1323528 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ë*lck}Ori z@z=P-S7?^64*pEErciU`!|}p^2fJ&eu)kKRqJTD~QLkSeOqq9lhcbQg>0IJW%I3wQ z#gnNP07JgQg4pi=ZX`5tL?jP6-P*tjI`omor)GHyJM>u-8BUH{QbVKLYcVvKeI=K2 z$bwIj)G#}EY2J{`T_<9X=YHD4Pse^;dg;_ZG#fue_dep5(vsA3!=Ax_Ja>b(0=a9> z?_8v9Z|9gnU0{Fb+26VLSDd?Zk+^T?B5~->MJ@U}bz0}trp~ETI;T$RoI0^{ zYGdcrc<0pG&Z#3hrw;9$I=FLcRp-<}ol`42r&e@+9cO@kIT8gYck9Satx|np0n#DX zGKJ9}HaIS`=WuAGM-3oM1nCcd@Kw5WJodEP=?@Wou6^GZuG~qrb-CluFH$h4tJjmD z9pV{H@$9JT1lu?+>cw*pwkQLapDXIMzExWfW0dx#NQ zFC=T$>4qM6pK85ZSH=2t)a_5)bGo5t7xiwn%X{gk{~z++1w5+i`uk5H2?2={6$CA6 z)YyVbg({W^Xhwq0;6zbT@s0&8t+t{hs8t{~Gs<)vq>5Hs`YWxpwboXx6csTf+_hc+ zZ&<71{T!o$qJWo@|L42*IWrT$w!ioHzR&YM{}&%K=j^@DzO23W+H0-7*4mNe0;o$g z8|#pt&J8jmVPor2mu_3@M+V?;&0A$;z}V_BJnXLsK!Pb{8^k!sS8rl<6;JZjyUbXM zsXRIM0k58h(d5Zl@4D(iJjq#)AZR>Y!V^)1tgfyN)uhN2b}nl A%^wZv1T4;d+ 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%0Ar0y`qjiz{i62v=A@d8sEO5(>%af2zgk$9IW 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 uV1>r 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

24Rp;A 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⪻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 z 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≪JJIxtM9tl3yx#ZY&V7hb3S=C;1W|8NF&v!04cHLO%Tyo-f)0|((Pjpq^ z=v;E_ac#GA$tnJ|*6$}z1V7|la_oI~PdS&I7vE^kIr5$GOU@<7K6me)bICc~OLHEQ z?}tBiE;;tOdr{U0|0Vck&v$<8tvNBsr@-SnmmGV4%aqQgp9`o@OMV=l$+_g%`&;I7 zE;(KMXg>wX+rf)DmmGV4%MYDP&Lz}WB0mYQ?p$*0alD~($!XG8`)NYn5Z>Im| zJ9v;n_c??5gqA(fjq2@lLVI)lFs&a<_4a5H7z zxW(Oew%+dmvx(q^*KuZ1N;^rS5O@0_&iTuwIT3?NPCA=P7R!Q#X!*HM3oIGVuS;au0GkF$xA9AZ78iB8i zz;{L9ha&J75qRv4dfaVZh0teGxaD-Td(7BBJ7WGHSU&Bw5 z7nz`ao+Zx;ze@fBev|w>{2_VANt*v3`4{lFmfWY`KT$HpOCx{JQaDZ zsal_oybL@$dHQKupPM{ByfFD0cyaP0@Q>g!JGqX%z`m;O>gD)ez`knkT#j$6>Do^# z@|N(<@)_FyKjcZ_H^|Gt?~s>*zaZ}qe?#5_9%HlYsPOaU z7Ca95C3sTux-+%^l;qXmnVidUPgpfHT%a&qM)&)*Rgl56ElH(QzM>7lXeh|9r02N7^DsBz%81gvTcT zA3Q$!5qJvnWb-sX4S6hhR`Q?WIms8o3z8?AulYsEm6y9T<-DYqF~k zT{o)9E(m^Zr*p}li=4&ev*D}A_rcea?}7hH9$2L7u!H;!>i>XS|F_Zq30EIFkI?^h z=hA;JTRmnBcNMEk5j{si?k$cO%<^>xSx!yCZuIKIGf>`2}Vub=lP&)q+? z?12$3U)CoK$9=`@hc5njf9K20Q`zM0gVN z@8D_4%dXJ;jO4}Pxya|k^O4Vn7bAZNFGYS0UV(h@O6{jI`Pc9|5&`y^03bT|S%oy$JyyIRNXOWqqk6fP0+xX=pc*H~8{y8a;lN9U412RXCJ zXTg_{?}aZX-wj_!{uaK8{55Ax%b|HrxXpL30_&t>w=@H^z+!XJ?L zgg+-g0)I_@03Q7}={)>AO8<-Y6Pr9GJPCP6cnb2i@U+hTI%IP$>+lombCJ)57b1_h zR{JbQ9s^#MydS&*`6uuip_IaE6geQkfnjH7NgC#W($U?pf zUclwZx+Sck^`)K5x}8COdGf#E)yOk#(s|V)PXljA-UZ%-yaT)y`BHd0@&)j2a9f8t zgLGbfUA@e=Ip#asxy<(|a>B@;z^9R?-K_JSNuCzrVV?vppYObtnG_`6HaC5B5JxCK3FaL2f?}zsR|i+V^L7l852@ynn!D9b}!4Vx7-9mv!!o zb+}005q^uj@K!x8_sFxrpOW8(za&2ckGfNjqaCj;ziNI=@@4RN&i%ZSJC}J4|4nmJ zlXr(_A#cA;>vNDdfEOSyxn1jvkQaxSCT|8WPu>(>4KAx8$JdTyeOE8@?OHSVAA?`5 zoy&YDAg4X~Aoy40&39=3J;-ap2axC6sr5t1)4)fQ=h&t7VdTl+)5tUJ*7}*`3E=ab z`*m36T-G7-9?e-veh)bt$#0;3EBR6Q9`eZhH2(nk*}dw=oJ*hOYU%Mh<6Qb&uwU!{ zAs-9BLB8pL*54r?4u1v@Mu+xKrQtemz7d|5e8nGH zpOJhzJQsP`A+66x-Va`ke8FL@FGU^(uRy->h}KsoUjVP++^<6e=dupJ9o3x1} z$hBi{i}PksxYnfwMk4|$?f+E0G+c<@qi zJB~v~>pD~)0(_`*IgZV79LG49<9G!1 zKag*OPbVL8TGwqB`2hH0@-6UXm;x zWqrc1KDV9A`V>OWee&G!XXLZsugJ&4qwSGS!q1C}XSM%WW%8-;I^>Vx^~rC+KO-M#C!)im-(JS&M@-7;A6=P{-gbjC(i-5&xNr2@a^!~RKFR%ggoU1&0kKQ z7`~3Y6MPeS2l#K!WgRYH9rihwb@&nW2g!ecABP7^Lyv3iv9Hd%ddV+WPxsY*=aQfF zqR#6Pc|!Or^7`<=UKug`e5nDCMSd7=@7rhV|2sT6)yKc2{iG(34bMVe3!a0#8a%Ia zzYay6%Q}okeM$16@DIr!!z+>Bf!8K)d|BsJkGvkdDfv=(bMkrc_T{Yp7yhVJSY4o=k47(tZ^>uFcJ0Z z$w$Mtkq7SUxVy+7qy7)_ai~8^J`#S4{5<>|`APUS@{$jYf`15p#f!j`lMlo`tUz8GUWa@$aS{5qur_&+tv;i{U%TU%~g1{|7(lynV1A>+`sC>2use?eipgb@)Z{ zT2Hk8DtRUNJ@P-{56M@;0|#X%gkOi7Kh=DDA5d9m>9ZI-0qW&%$#tpdq~Je-U#VP< z%(uWN>baduPU`2H{~mc#cyaRf@b}5TfLA2n3a>)G25#?HYWt@v`uv3I+r7{}KP9gS z|APF#ms;PJ`~tiy`L$PC|26pq__yRGUu*p!^1|>@K^`0vjBxc2^AmOt^Wj{CQ(mwp<-FOUZ! zM-5Hv3i-20>UYV%LjAww&Eap!J4Ml)D1XRGhMz~3;Bm?GMbr9(bIa6gefk52|ylDhJCIbI40$&(`AB(^*kuO7^ zci?tj7ig&czjiMBBwZX`&q#;fJznwPvC02}$0y$dPeDE=uI8s9{}!H={IhskpOd^M zJfHK>brtg}=3M5LC%)#CB2NadK%Ogs)>kG^0k1g6T-hF zZvpR4UK8GrylrC5A4pyvK9c;~q*_0Q{2TaW^6T*F+ElehSUsLH;Va`tRh|P=A>GIQ(z&-6=Ka4EY-P74ooDT7QFl6#QSfT~9v22RFt% ztmmEi7M#C{;dcH$z&_97T=w}n%eW0tUy1x< zcy00t@OtE9;4R26z+01_g?AxOokr*N6?t-aU-D1j1IX*bN05()k0u`tp9Ht#cpt}c z0eS0bdL3Tja%7#$HB#T^T-Ny_@^_J+f&W2XAg!*$QS#jIQ{*Gz=g51*uaQ?vr}?+Y zE5aX<&x1cDp8$tJVA0x*;f7R}bj-oyd)&CC9N?tC5=I10Y z1usTE7hZ~d47>{5_Cwq0dVCv_*ZWbuh0Bq37>NDwm2=q-12Sr#J;-~*2aq3z46}b`g!Ev!0ml`?RaI&qT{Zl`b6-J(DgDfn#i7V!DxpTn2Htl99)Rrzful&rDtk zo(FF0QwZx&gghI(Jh|1^BCn15FPzKIAwP>3ntq_abNTsI`#IGS&gJ=(-RI0Ae~ib+ zW#mmT?nd%H@I%g}pOo>npBv77KM$QtKi?rI+A%$jwr;8CXikC%JTKg?SA((s1;_`& zOOh{!mnL5buS9+rUXA<@cs=qMIdoq&B!7zf=H&ZO-->(#yfb<4oSNT_yeGU5`D}Q9 z@|p1A?lkb90g4^+GIZuz*Z1N#<)wfd4TjXpfe+@rCo;8=w_Yiqz_zCjr@YCc~ z;r}?7>(T?eE;*O$&oI>AA^!&cg#4r2+UIlfqVUN7lNAfUUOk0JCw~G@K%Op-<|iRf z15Zm{0iKb(JUkCvx{~v8{e0;z_`0d9m-Wer_v5YPT-K)(a;lNHf!8D732#Wg5#F5q zhNp5a>u>?>Ho^C8buRgrkyDHOA9zFZECqBOnvkb~w<4bjZ$~~2-i`bm{2TI9 z@c!iK3Ti)t$y33HJNN4l=3LgH3F;@3*MrX_-vysbz6HLNJXay@a|L-e_y+PX;9JN) zhwmo;3BI3v8vIZ4CWW=1zsMWHFT-tLm0P9z=K*;Ec&xvqGW>j*g`9ZgGvGe@wm&{)~JRJkkl-IpM$e7j1#=hlCM$YPju(?br`_oXc^EUtH&vpFAeK1o>z1 z56BzBKO$cVuS&icUJEX>lk0hG%&QG~RqX%%Q_%`wZ@Ll9R;eU|lDXIBK$+N&ukxzl2BOeF92Df$l80+)E)yw(V74v=VT;?04 zl=c(pZ%GKhj=e>GZ1M`Ik566}o`QS;JPmnYcvkY8@SNmV;RWF~-^Q5l`>tN*I|uWv z;#}sN>wTSX4f1U82IQ^bjmcZUTaq7vw;?|W|B^hx2ii|}@;LB*K{4x>+s6CtV09j1Ww9IhM!+G;jzeng~uab2Tx9( zsjT*ynmipm3waZG4)TWZ0_1byMaX}EmnN@QPWvfOUK?HwE~_Ee`K-8ZH;llWlW)U5 z97Em=KArpod=vRT{2baYxIHc;Y$``7_&EU1mYyC&$r{J~7N7m5#y5w!)P2jSsvOhn>&n31a@32@_JrL*< zfe($q*G1sFBJe{I_=^ZU`f1${*1x?^em3%&{j~p&$RiI>|AM^kVD+x#-QmNW%j?qR z;%og>=l*r+dCp~>?S1k$lYcQ*bB>drf!`)iGfwLxpLus3s>4%}_k|ZAzX7jI-e!X4 zw;|sG|CT(?M6I7l{yuyed97)fFS&i+{3Utz1zMl%?7QLNBu_fe(+zNOOAam&jII>^9$+^kzm2=6leH-(9@Lz&ovTr5l2h_(U9}Z9C zTykumr*kej8R}|3naGpDvpbg@J1+`3mzblLxs02&p03+y@{I5w;5P1y zuXWscu3pCNT1kDGa~apJCmWp0xXqBih5S?acIT3R6#09c`+5E8T=J(N=P&X}@YC>M zX=pvKVP5~bdf)$BayyRk|B;07*T)tjCkx!J&$bTvolBp;p`XI!o8cuQ$gk?^{W>&o zF8ME!)0q4zycy-MNB>`wCx-WTIidZA<1)^ zlE;9bByRx!k9-I`*#$}d|BqL0=W^dTOa>2rRV25cyQt+{N`FIs8}c+bPY1zmKNQ0I zgiIi}&)1tnUMWkcoxsoJpTIYh+vCwba(jF^PHvAE7s>5&+3u0s=d8UXx5tZ^7j>O& zzIOdjMsC;h%;a``&QEUF+tTEAKGuoAzaY2su^YMN3?jGsapYD%o4i_YJzlHH?Q<=E zBQG~b>kpFK=Omsax6c#2N^bk-Av=EF>@B%{E@a$G?;fu@J+z-xiAWvOh{W7_I?(GBeuGzHyHM#AR*q7fuzP7JYkjF`BXi@bh*?SB-xop)2nZG9Gy+xo92xAWpRa$BE+OK$5B>&m;wH+Ml@hZN+t4q3_Vb9D=n+xnCtx9dg?^0#uq4}R5$ zOIPyv*foi0@Hsx!Z;YYd)4AL~w8woyU-HKAfzIXrCk^g6Bdind@9~j-!4d`A+y!=aQ2%rsk}7E;(~P(SA0QkB4t_E;*;mYR*CDl2gB-<{Tlf z2tV#za_-=B=Px*yoK%f8=L&f&_)X`MWBcJbx$TEoSA#{tFMHg#$D?G^jrmx#Ub}qB(=fhrx$CmmIq;O>izb zeVb~|6!Pxy8O|lgu46xu+jVR`xjnw`bS~q@{7lE)Oa2Vw9&|3_UK*(D`9FA&Lf4J~JM#uaev2&Rxn$kDM3ejo?wQ$%wlD<$28gxjczr(lbx97tzS;FK3AtVOGLj!29Qx~l zeB|>BsFxzQ`-;lscD~mqxAV6Jxt)()$nAXWOCGO;_A`{cVs!N}hqI#fERHtISKMRfU@#rNYHIG3EO zsBcVu5#G$XXN zPC@k@Zpz;d1Ts>+o!2?3z7Fb(QN6uxQ<2#MQSC{>O}X z{b!<^EJ%t6xH`Z z{Wm+i@ke`58rkwY&PwJERfVXxo zKUdHW&ld(d_di$gJ>2&5jnvY0@cT&Q_BgVX+#VM;klS^2H@RIW|0K8T$$4_SKHMg^ z^ZgmQosW@j>-yWg?7T}rZs$unaywu0kz4)yR9iuzBeV=zA zxxLOahTL9fn@;{1_YaH7?YOKZx5uv?~n{zq8(tM%Uja=j}aelq$ykoH5?vqP7mz;sEG^Y%CS9k^Ik`t+l z_F3Dx#gpa#xbWpO@M7B(d}M!IC*mb=)-0 zrBBPr;auiB8}rITJ_TODx#T}Ueo^O=Z~c^aF8MLq>3V)d{ucRl;K9<+y3NEoeCq0D z+^!h6qjSmcjQlUj+rxX2FNXIcpAR48+>blTxr}=e^<&A;!Kc7&UTZL~RaBp*y{^w% z@)Yo2$?L;+kk^GDgxk1Pun!+a;EC=@rS2=4S8wDbBku{%47dEin$TYlUyTf;r z$Lg;2`^m3xwtC#&S5c}|@bJ-6sk@J@P2|VU~Ne(|R zYJQ{r#3io`PvqQ>o7#D3|D!%V`7C%2^8N5UrmUd^b@Iv z&Z{2zTjVz-&yM=$rLK>hF?Ifd5B+6#jzzFg*GLnNj%jz5yF_+=LN$KDa#}e1e>Ulk+5@|AOWp12CHi}rUe^_Os5#yOYzu6X@?sdN9lavj|6&(q`k zq&r-_0`>JeD-Oo43Q^D^#m-`lbefzm{$$780=Da4)2#@@4uqgOt z{oCu7@tsS~Nz^AM{{x=Fx%6YNTV`=CIi31wKRL*o!}B_qoS0f3DB)ak0)6#Ad_evf zIpv*8PS=^CX$ERKmzx#ZaMrqRwNC*uI^CyYEPe3Em?vFA;5olDMg)Gs7o1Yhc0a_o85dgqc; za-jCJnLHkRn{&yr=iLXLOHPWxnsbEw$sqOP&Lzj5r(bX`IlYHy{T1@=@SDyh$DY?e zaV|NBQU9ELFZ_*j$+6b~Vm}Q2OYqCChu;jk86`dK_obFz?6 zg6DKDIZu#N#JS{*`%ZI8kavfdb}l(@kyF*VFhX-$ zk|%<j_lE!ATypIB@-%pmLeCQu zUe)6`kLvCD_%d?)KKL(`GwrhGY^D0hxbE$y`fI2^M)mgm`U1HR&PNcl<7=XzJ~*I}n~$-j=Az2sNn z2Pr=b^3Rjkg+FpRe%!atW!(7RM-44#l*hq;34YmiFE%_TT>h)vFSSN~Dpw!65692D zW_Iq!eb2d!TLt-r$ScB&!)@F>7`LXY_s6RVx$Uw|m3@+Wu@ydtCk!s{^ zG2f;xNBY^0ep);C$FZAp>E|WJ{f7Kscptd+QwaTh@9O=0r#P4Vu48pQeqTAX?Jg%Y->=pGbS~pgLH=Ll6X545zd6Re5rIegPgWrO`t}cUqLH72Cxpx2 zlH<4!{ik;I(*FbWpU1iMA9tLtTYmD`@Dk*O;2)3|fPX~Z5MGtM0lb!T-)BST(&u>8 zHz6MkZ$(}vOy|{(ycE1MJQy8Xw?8fh{}B8dO@88%`ec_QeHOs=d9icpb1?Fkk$(+e zOP=Qk?Q1b%`1{qfr874o9+oA6+CXgw?8 z`};4P%j+RGG$xSfsZ@r){$r2VY2fnsF8$lj;pcTO{g1-91;~fOi#qo?Wt@lB0rek} z{|{cBJkbQ5KyC7P@J7yM+%P=ewRSG!)pGP!(Q@7eYBrra9LGZpMa&pFhUauHIT;3OP7&vlb7ZpiQ-XX8ytH%4vEy6Sx#X;vqB%9m7s2Z~mz?zY zd7Ea=B`4EV&1p%V0N&QQ_u+-YN&I`&ofQ)N04WNk8v*fwhyN{mz&NP2!R`Jk;d-r4>|EyC57(0{&gFil zE9!GPm-?Ua{+~sh%Q_#$dX^yH4KEE3mWI}CNnQC<@bSUbOa4r}Ur;mWl3)Kv>|64> z@V1n{5BXD_%OM;TB{Xbcv2(dzeSvje?eb+ER$(1>I+uP1VBEdrJ>f^lufqRFeg=M) zeCQ0F?*;Nc@T<;!pZA-&BzYY8hveVFE0K4H*CziDUXT19ypeO? zXA9@j=clu^&(`F1;a$j&!M`H^9X`ytjC&O8Gv2w3TV;-pJDL1L_-yjY@cHE9;mgU- z!dH=>fNvttHCOxjl{_1KFFe?KXg|dISpF0U{6qDvQGc2IbNC(d&F}~0tKcu-Htsr% zo8*m-Z}%1X=V|{b$n(L|!YyY9a&nX3#dYaJ@_6-hywAu3sBa6m^Dg7Y(DDSnb}q;L z6ZF%Iye@nYc^G^c`B?Z^@(u9uXvYl0SjRgIk~F z&}T04%C>(f=lun`4wcAD!fQ}YJmhpH?*Sj=a^!J&U$xM50^_K@D6ZQJBB))9s zJpw=Ha%BCRqyLNK&EU7lhr#cW4}m`=xB8dlRv$IAYr>DC)yE{a`b6Z*Fm5vPpWx}q zPr);j{|(PW{uZ8}{58A?-1gN{+<$)LT%NaXxA*;X?(dgAC*L9`Q}C-B`4i>9K<83w z_obsE@WpVu-sW4V`*|689{5`F2JnsK_24_m`@#2+_kkZKUjRQwJ_mk=`~v(R^0V+8 zTO58k#ju!!pI`>Jcn?fdDw$*<|M2aZyH z^A0jn@aGz+-sbzrxy)-W`hQA34gSix%qs<+kH?G>e%vJ|-eNtkp%`5N`j$-BZ^JC_{$dB1MXC1*YAzad`=@8eu@?E3JXbIB?Dlg?`t`TOv3&LzjL zCqFuuoW7`^P2Ll}z`5ku^=FlH$=QJVwdB9RH#wIayI$>p2PyOj@jLea?^JKU-+heg zhoJrp)!X@dnd&Y74*3$~M2Z@IUPzyI{>F1I^L>PQB_h8MPwQNA?D~+K-11ApZ5;-n zp9bV};9bZs!Us4HJ>I3z^K`Ux|9CeAZrA@4xwU@2tCtm-Q%gDv1U6H>U6=Mcm-Q*Q zRQKoaRwD99D{u=o) zoJ+o4ACfqi`r61zLH-dut#iq-^E#(<$=QSYyyQFJ1)WQdo!6zEOHN?9&Z|86E96vi zE;)8y*L5yA6_N7^c{z9!=aOURbt`f^A3MRNMOpFl*jIh1-p-d1L(PuOvs#$2quFBII`7 zeMnvv@6%F;-0D9gxBIk?rzVP|ZW&hak zeXMjYIe(%47xF{!jm{+}b$RV)w{yv<@Uxy5`^ihf4>^|{`+fXV&Lw9L>d%q?3cuuB za_oJX?m3s7LMybNhva$TPo0PQiKg?4664+L)gaWzApaH~*SX}_buy)M>1Pw_(~@t1 zXL2q%c3sWqTyn0Vz99K|croXaW7pLWol8#5mAXEa$Sc6BJC_{0?`r5=a*m+B3Hbqd zbLWy{zh}|Ox#SF5rTugz?+gFNx#ZaISqyS6IYn1%&M@+P@KMes$9~UZvUACqiu&o~ zYU?Q^JeneS1|YXtdW_z&dI;FHK7!>2p< z?-W7KAgaHL`eEdk;iD*LBKny@UJw2gxy@@Ixy|dWbGe`Fs)sf3l-xc?AX02CuywQZ zIyw1V^pk~rJG_K*xxYOcPtV_a&i(!EXU?UAeaQI=Zuh-;Cuz=5^1@@(e;{u^MST`| zBK(}jGID!grj6uw-?)d|-sk)n`SMme?my)AzQlLP*Wl;no|D`CSoApI=c8P=?fxnW zx!o^iB)9vYeB^dNQ;OW~Pb!n!<7s_zdwgs`ZjX0e$n9~YC%L_zGmzXKN5+!d^Rl@S z_}U13Uj%-d+@25KAh&U!kz0NAxbGe>t4~fo3Xi`z$?bi^ijvzt{E*!CVQq5ThfT?C zpSLHs&&%sUelo7^=ON_lVycIcujq*Lj=T|GC|^#V8t+rLnYo zUm>rF>(9UBPqJwJ8*)4E;>3IRINEualHAU_Y~*&{6(YCus4TgiM>WXpJZemC_knH5 z?fm+Z+|I9F(o%gp zc|7<5^7LP5{W0>S@H6Cgow-Wh2G{3*;lWFA=stPQJo!`b{Tt%HyHD)>>ykQ``^Hl1 zai32f6Q0hwT<3FRKj(5TIUP1?PCoKV@IuZd$Ik0A&Lt=HX3hDK{Kh8r%FZRnt^@U) zOHQ$^THla7H@vBH$+7ECJLi&f0rj28cf-3mmmK^2h{5D`{hUDF5x=J}+qsOJ_c!f- zK6!HZ66Z2*Gwipu&LyYbHqF^co(cY|bID1aGPHdH2b@bz&mEd`i2MuqG3S!AZ=~j& zcOJ^wsX3R(zkpwNE;)8Rf8<0J7;$EhLCB`3vU%^6Of06yBe{MotWj6ACStR^oHU+-LU>~V9abIED&Kh4=o{xSTZbIGy$+rOPl&Lq^IA^!n> z!MWtv{qP;OOCx>m)yDZ)Bcp^ zq$aNk&){5g?De`l&Lt<|8O_O0KK-CoOV1IG3EssP95P8s6Qx{kLv&ZPV4`p`l+aYOZDI6()t*Q^!&2^(=FEg zgm8O3!S44`Qhkk|wLTO1Wz4G><=D@ce&}3|OQh?1Tq=>jzNTJ-@>ea>aa*{0IbN3E z*}3GGLVh>$67ZhR<@L-5_jG**I+y%*HPuHum;9E<2_tU?p9T+>hW1Irh4QCBV7{xD zaWmczabT@;$)ACojpS3|JIGJK_mCfh{|>i)MsCu6PLfwdpI6CS!yl2q!f{WU_}%Mv z+8cTtQNNtcoPY zSS)`E1WLPlpI_CvH(&%kkr$b}r){zOBdQJo)eN%alJI`Tvn0gU3nwfA5DB z&Sl)#cXZq|N8!7jOa2_> zA8_v1?Jwt&|M6WtUZ=>b!_UKmrJ>^$Wrh4H5O_$QbftRKWa0Zn`niC9;yL&8P32tr znS*iDkxz$bb}sqN@rw{Socs9}b}sq%kW-xe4!n$W$qz$*W#_*Cdd?+3)jeI$hUAIh zP2s`P(0bO#{aa^O@B8oVT=M%N=UehV@WGV-HS#CB`p|K~yk`&9j|5Lio*SN)JSRLGd0lue@>=l1a9g+M=)bh9m;P6w|60za|8dBvOa48)3Hbr| z=j40ft(^ODJ39}p+XG#!sn3pfG;5b8omN<<5pQJ ze+qtXY6Sk6a(+b4GxBNhXeo66Sbjm=XC{El^R>|Vh2xdcxvblMplCp4{pu zlUx04a;u+DZuQH_t$r1`)o&ut@<{jRujDD;^@g2y4R3r|YE7@m@RE`%467I{i|L-NP)CggYEt;j!prups2>%zN{?|^?p zz6su+yzq0)A55ML{yq6J_&D-~@TqXQI?4{X|BL)7c;82U5Z9m6@4|0)L*0gFwEIZ0mXeB+VFgC~aDye^{8_sEmu^{x^wN7iRM`mgF- z#{C-kHOafeKOtWW|CD?w{B!4i+;+}o+&r&zzMaUkz`Mb1zIiaOVdQslKQNWNIO^xQ zeCa3fAo#!F*DubcpD>KOfqWEvt8<^T$GPNOMEwEsGw{Q3n^$Y}d5e5L{IScCaSNdT zXlcXum5lr0YhBM+>>RiTsj{2PB|HAXZZN3{Zukz%{R!K$h z{j|t;qrRETmwvip9lmrf{WN={>(HIN5xkdkpEJn0i~GTxKKl zEsc4-X2)?%m`?Yn)we=@YPekwFJK+=IG28M2lN-8@{?zWmmu!||A4$Xyu5Q+2OGDV za~by{>T8jog4cuFyn16^ZOL0>9r}>3LH$sdFa2cvS9VG8=NFtyKNTbCI!q%k2cJhi z7`}+S4}6((Kki!RGVT@BZzMkt{}pcQup9IGll&0wPp*)sTOxlm`1+#DmwuXK9o{;Z zekw=Sb%>Jw-RoX{cpCDLqiB5w^2+d>+6v>fHx(d8B6P%llO+VC(jc{>pPRDf%hQ44(~($H+%^B{J5GwoO}X2jJ$0; zt)EC<8$Qjs-zW2&%RU(%Uvn0b4}h;EkCZ^`e<8n*`mN+wQNNx1GW-B}=7gGmh&(p@ z1bMAQT7Q~6GyF37f+SjhoqQJj0eP&XTK|~*KI&hSmrSPhkutn{-erKtCjTEM4G2s!f`1@ejHxbxtyn#Q^mRD3`nWRy#{$-cmwiH@W$lp;4PiYxZBbHm(FF}N2u>k z{xAGnc(61eEBFIm|C~(q=~HR{)5(*==aYxQ7n6SnUk$f$GvIh_iNH@%PL$Nz&sp+F z@cR+u#Le{XKFNpqW+$%+FGrpjeKsZk@h6!{AkYSG`|1IXOHb!=T#BI2zU0~A1D(t9 zwVaX8CFf7nk0Czs17vDzokfIbJfaf@yVq(vjzf7l3nqP4d0i zKW)jc!3U8yK%X%;eu{|i4rej9$+x$FlU_pEan zw_G}1w+rN@;5W&~!S9lfg#Sl=1^$BkBs@x%caLMA^x97h@(%EX zbDz`8x#U#Ir1R=WUJ*Wwd@y_@d4KqL=Q3_W{Cvo4=Q8eQ)Xyj12wwsZmWHlBXYji2 zujCVPT{=NISCMm?{2cr;d5g@t4%f+R!vBR^KQnQ@zl^|BW_@=*zn?|((~_5j=ZABC z4f45Ihc@Kf;Qh(N(C2jW+jzde0B+Z%a`?HdbKZ)eA`arM&A1*}6}=hDwks5T<($QJ@@@nkJIA~GVLfu)UOZ|KJ{@T~%H|=!*@*TJ@okM;czK8rK{0_POeoCaAx;`>r znb%=lACi)n)UrT&=R(=={mne&)8W;~e};caz7sx?e5w7s5cxj%cIUqTGvwC)Rp-+G zR6L%(CQpIKg_OC%*GK+T8D4_?Q@sBC8Tlyqx8$YpxG;+Ree9pv&i%YLliR#@JC{Cp zAm@~GpYxd9a^5(XoalJo6est)>#!8(btpIeOU|U?n)AMM$=QkevgFI*6`e~?SA5QU z9p{p>HJA2NpL`L#v2)3}T3!2T?ObwJ=hmF||An+6xN*V(J*v0gFMi=%)~7;AU7t7P<>68Dg`XGl ze5YJX?I)gdSvSj17-%JFDwl z^5d1#b@+rl7Q6{OSQ(|7Co|KxJ~ zxa*wDxSf%|iM&1hH_Bgz{3EVj*7E`G_f9(Z<6dztuL&<-JoEYQ};c?-?($Mjmi1p0u>LuUyLjiI-j%A%op9NZLpH-auochkC&#Le1 zzG_5X9{!p0(7r`}OXq$ax;U5o<;eMpd=b1SJXji9hmm`<|L@7O?NguWa-^RN=x330 zKi@UZrJv^*cRl$N_!hYJW8?ne>iv9AI+y%HALx3XB`*NKNcrV3uSc#vbR660d|x^D z^NN}O-Tl@C`Ekh`z!Sl3USqM&nO(h~*L%)oUQ3WuhN@xH zYUW(V{R{am$q&NYI+y&exDIr3?&sCZx#ZU@t;ee$`A6_U@L*|Ze;&oWCb)VTHw?#X zhI2o!CC+8spOL?u{3rNoxQ+W4#@*@a{k#r4m;7tUIYxd3{x{`cMgC1!FZ0@tc|COQ z=k><9j2o|vu4m)|@9xi7@ECBL*DZ{j($)KUWpyt3m5`H@ydpdw<-bIJ1#-L3sp)cL zzDM!+-psj-`z7*QlDCIJN}FfghusgFE%QcQyilPC2p5>AYT($Am{O`0hT;506cr z51tfm^E!@xa#4MK)aN6w3ok}F*O615>U*QUHhE8Y6Ur%p{oLBs%f3yB>uL|@vTx@g zrw{oI_z?25@Zsbq;9=x>%Io@1B+mh#=G^x=&$;y37WIqBTfkR3mz;8#?^frMvkvv! z$ydYo!h@xu>v?Ug=S^~3=g5V0|5*JT+^5Bb+xNLvp`UclrJs8kHxv0Ccfh-;%Gzye5(V4qr|l8~5S6$j8DjkZ*=RBTtO=Pf+;Xb^Z;W z)w#U>d`8OxrO55|=Zemybn0Hco-}qY-%r_?K>Z8nQoj-Py`1}ThmqU3)hw3E+T(B_`YDl|A||EHn_bGpLe=c1>dKK ze5!7@Kt*zUz3yXjd;P5$xxGHnj{Mv4I_}qSJMUICQvaUnt)D5*<-Dte{r@9*3HTi6 za=%eNljbjXE;%<)zl!_{e4TU2i5XRMb~u-u{1tTJ_K;_S|L$CJ))vs56V4^)6zWft zAAf6pGr+r23=RSE0_+#giW5+j8RQHd){(l7ZQOWngV>y=`+YiZ{OFtDp z(tc8r=YywrE;;skY;Nb0Q@)bsyhol3Uf8+h*z2)nol8!w%9>Mw`~!Fu=aOTuH`aG9 zIjO2>P9ySo@Xwq}j=kR4-nrzgMtx`Uh48POOOCzX*x$M2G^ncm3?{D%AMRXo?DfVl zayx&g!h@xu$I}&!b>Ge<4}-6#9D5yOr*rA^GWyv|ei43<^5-J|qN|tw?e&xUx?A*`mGv_jHKjgO{?*nh+T=EAZzoT1m*vT z{2Q)b<~6679>;&3`+2=~F5{L(ex%~z`&PUpJi2qqzkvKW&i%YnIG3C;$Vo#!5}pwr zEDi0$EjS;Gk=x^VIhP~-JSeL3{n)vTyASyd$ald%b?$Sz!L6VDxPKT=ejGl7ax!9l zes(VXM6IF6cQttczM1lmVjXrz;O8i(268TvSA*Z7oD9hS&(+I1)It9-O1!%t1|TO6 zc~5v!@|*CKywSV5j?kZ-)CXxvd$|}Uz~g~yc~IwS~_k;@;LCSaN7?h zv2LG`H-&#g-U>dLyeQ7!apaxhYsidGZVJ`_3h2J91t+ zmz;;#=ZSH{Z|jg1Ia!=b&a+s-e+0jZJNM5QK7`xzh3s9lzCQV&kJMX`FBz=fh1~8l z`;y!J)d+ICUz$X2_doN?Q`uPIG3CXwe>(gCNB(s?p$(a<9v@+>fQ4_RvpcWMg9~y@tsRfhJm5!22wkh ze$F5#J^4O(7Uz;<$2Y%o$=Up|_EVUA4ZMVN$+6FYt>|2G^3~OxD&%S4HJwY&%BDK6 zX5_Z7Iyjg7;`KDY3wb_xcjuCC`*47B$ytZ`A>_;8Bb-Z)?c0gYCFi61+Rs$-lJJ?% zCCARAW#kLwBo2Q40uPpk9tKCWb}oIkK~8n@X7Kvt=i!aW zPry4mmvL8NeR?^UaqEAo{r4lU1s_H}4?dE77JNMU4ftg8OYqs`MVn|p^T`Xsm&1dt zhxWry*bjTCz8mTfkavV1Bi{=@LB17!0dC_q_*DKB{CNkef4`~r|C+ocJaXxG_j3#6 zBqSe$>rzhgpWzkA=OCvh+|G-@uc0;rpE{T0-V*&ZBX0(8OFjeMk$gJ*Yw}(2UgX>0 z-#VB5X?;$Qz~?)c{$C?!G5K@&D)Q2w>2X<0UKIW-Tw0MMv<~aJ&(%wx1+bncol8IS zk#m;(NBBkOKIhi|qw6l9qrAGd0T1r(uEpIc@=}Vsy99T4cZyqZ4N|1II|O$KRvdzB zky4;o`Df3$_n)16eaTvHSHA1p+-Dz|=b6k5!MNl^YUcWUO&$*Z9OMY(Mh$fLoN!}VNM!hU5pE|bHH!Gbsu+OA0LI`@5uFW8opG>^+fi)R1(>Bk0*t3`+7wt-`ntzq z@|gu(pI6AW&->*1dc|vUef{ApxxStd^%u8ax<2}IeIjyQhYaM;`nx`J!}a`lGRt?~ z_j{>c`>$nOuERZX4(pM3gf})W`>6lEXJ>N#_dSP@>-)&#jmx+8}OTdpCmvQyHT{12?f1v(P@)ht~#wAD3=Tqa7^9}Vc z$v?v18kZbB&)$!s~~JMa58RIl%ErVgV% z2i5EQj6aj>`+C*LwY~|t)^~$zpH(xvJ_ne3d7c)y(AU0af^k`g0Ib6l^7-(&#%<10 zELpj zq=RKy#nzZM#|_t}-k zW!y-bc3L{2wRR>;GkPy?+Ih>;3C5a=m|jA=mp?lrkavDAyUiZYLrilfyS% zPdd2FM*d{nTy9=Ps9yUoV_Y7Oldz8!$VbDg8kc@vPj%xqBiH*>N8^(J9ywjfU&4DC zxAPrAuJ@@K_&(#3qxY$k#w90l z7uU~O^0@Ge#wADZQ+JF@PJ7hfCvORVVq9|cKJ^;zCEqzoo?pK6cs^0R-lu+qQ6H;p z=<})fofPDH-^op`^(Dx)z6M~CZ7WTM4qp&tN%)#4IaLnJGXkSw&j-Z zy#LOFak*a%#Cos;6^k>I}=mz)^6T%Wbbb-sS& zdY|fST*l3V{O;u0;C+nCxO!h3MXvX$sm3LL1akbz2f^nWmwdfXtuQV*S5d#3`~rNv zamms9)NbRFle@oL=l$ea;fIY&j^3xvkn8>EGTdA0yMNu@?e^t9)$9G`4Y}T5B2;ka zP|usz$0OJJjBp)y#x6H*F7nFo$|gtFVHoCHoqPzq0r?7e6Y^#7w#McD^|q<&r<-vZ z_Xg^Fk)MJOCZ9LJ?bmSf@$m8Fl?S@|$>bH`v&nnF=aYAXFDIV^UqwC(z6GxPqUT|s zsh9Oh+sv)cIpeZE2at1-d=LC)82OLF@b8rKFLJ_F3^{Ky?nii3xb}Y%*Tc-@KjZTW z#f{5-WG-Hpu5aAlM_L${4$2{?8(hzSBfPFSf?Th|Q^@r`vVdIgBdf{vKC+!$?<0rF z^|~5F{wAK=$J=mSw;;^xJ=JUfKa9)zXBy3t-jamiVP`lRFw z;HivDj^0Odk?VYmlk0t?f^ix5IP$BI2f}L_mvQwz(wtoHBb|&(ev-j%eY%mygZDNr z`FbB2Zd`IYp?)-Z8~AwRlB4&LS;i&j80zPdAA~P9E;)K1Sw*h*k&SR~sqa2g2Jdg~ zr+U3FoFUiy!aZ`W|BGDfJ(b;g({YdOb>}%cd1ZKJxI9jM`!dAsOLp=E@B-vD;YG-+ z!%G{N>*R1;Co3D5amS**I(c7s1M;7Tx;~qb7lOAT?+Ncf-W}ePd=b1a`5gE#@^|o2 zd^@JE#MFRq6X zs)Rmo%W%$<8khTs2Y+udzj1pXDPdd^Hz21nT<;_8us%)6^*Y>-8-?xnAG$kn44+B)MLfYK7r#!tnlK_(XCYcOJQpyM|orcam%U3G$I;+&*50>*F`@ zpz{}0ulxJaxIBJ`;&Jqayf6HRaoHC=Z?UR{-Y-2TY2ez=QS_75)XVk6Rp`|@9)TmRMM=dfQ}OpfpVi2XWZT-G_s7}w_s@&xc8 z^1ARV&i4uC<*6R}zEJRxTZaVX|Diq=T(0xdPaxJI zmvQOmKE};Qeg|HRJk?mYZvP`s0xx6Sj$75ZjN2LYHObq;>%qOHzUO-h0=?gOzdDk) zIplnZ$&qnAEu2p!*y{y@m5M#%0`$ zoIDx)HRUuyj;Chm>(U^sa}x6T@Z98SkyFaJJincW=eLcF+vm6K;QBoFN-VcN zy-dAy7T4olB=6S*s@LZgvyIDoHo|=8lb3`qF)q(5^!dYja($k;+qmTaF~P0#e)6&K z!^S0FpO>CDE;%J9xtvSniQ(6bOOF12gNMc?=iy|R^OXD|{FQOZ(dWbe8kd}HQ(VqB z@)huKwL-2NlB3U`V;Ps6ep6jeJo0w%#Kt8@Uw=q%Tym;Ub2*vF{|C=*TypgJc>!{L zeqJ2zE%jZm?u3)?Jf2Eaug`}Ykn8i|cE)|z&)&Zx|`Q<^6>C6 zaP4y>`kZa*W!zwlyTrI1cdc<5w=VKGlGlW9gX_2pFzzu^@4JqTbMrlK+>U$GxQsg$ z`FF`D!XLtQ+>IFbA5-recf1?-yKxy;_bXcMkn<_yoJs#BRH>Ra-^S9Sm(yZ?R?uAmwxJD+)m`x;N9Uenyl1H z^fSWL+xbp5F8SM$Go5@Zd^Y7DMgD42FY^k(yfz!R^V)A*#tlaPA@b|+41x=%fSzje}P{%F3)c(#P|Nk z`}NAWeSZ7VxU674T<0U!3%NeXb?M<`UyLU)xjw(mK(4QY4bb-stlwa-hGU&IaTxgCaoFgfzL zc#ZS(nfw(zeEpF9vh|V4wLT7cf;sMSmw-GTJSBM%cv|v8@T_oMPyDqHPXSXe=W2Tl zw-DvXb)9RI>+hHIBOf{4<#Zv}^&d#C=j1nX{W)kRx&BJ?Bvxgq#Qayd@F2KL0NghF1y0o0IGF+b-mqKZ0EAr;=;^ za&oQTOs@5Z$hH0gxz^t!&sNEupLgVX4*w(9$9s&1q1Rc@TQc%O`1g0RlWTqva?L4A zuIIKExt`nRiT=PAR zLhp;_CnVSU^yFHfk6i0Zk!yVo^6B_oN=tIx_ip5Rt_G9qd6+<+t*Se>3&}Nq4Y}s* zAlGwsgj~-_5V@X{JLGy!UXbfKc~7qABwXXr`=#p~hg{b=4Y}6mB-i>9YCF zb!$Sd`_h42*Rvma-O(<8Jh|r2CfA(hyy7mo{(D$2$@QH4ORnc6Qq$1;rRO9*xt^002u-SFg$S+RpGb32V( z&+Q^|J-2_5>$%-YuIDz8T+i)!a^3gaHYTIcZI<=cEU@p2MN!dQK*hN5l`ti^(;AE&1d8uAg1xntzO3&*3Fv=0guIH@`x$bW*a^2syVfcVBd=k0l&nMUX zKghLy7rEA-Bu|>#?e9%;Jr7UG^}PK2gXDV7&ywpozd^3&`~kVH&s%a`hyTcR9b&f(z3*C|l3eR^kaxk~cPL4& z>sFau&tU^{UC*}Ug*v!>=})ftW61S&su|>(zl2=(YaO{>_jZ%(J{~96eY{Mr`xs2F z`}mw(_wf_C?n|Urq4!JoB^kNaXC~MB!sJ?CmR#%Wl1HuS_N5)U?n`fS-S-jXx-V17 zht+ZUOUX5V1NpKY`uLIS`RqV`yS=OLNv{9S>>%<)c>InguZQ;? zCX?&=pG`g#zNY6knQ_S(J=eW2kczx7JiT$r(Q}^5xa4G?=W_Cqr-2tXE;;%*ElaMCmzu^U ze;0DKv}q_vFjr;o63N9DRXDBL4>-o4nc**MEHS3h)%6@_+!d1hx{+b<$d!k_*`hjcJ4gr`s+H!BOi{O z^u{H}4>=`_r}lbL7wf46|NoyaP2;XV^-R5#`n8Y_y#IbR)$8?tfN@!easlof4k6D2 zA8A~!w@Gkcn_^sYdM|Z3Gsp|U=NOlqg!uPcmm8OyEGt~jD)Rr9J6~s9a(*7^o33Y< zamk6c($()HfBd`iL&ha%E7tj(amiV~%GF;a?*aeQxa3^!?fQ9OTyom{;c}jkSA@Sb zE;;yhES^usC1>qgm-Cf;JlxaXO+?R$-UnkEmz?zLT~1u`l<-8xr5}Bsna;T6tVaD$ zseOpZEG1mz+;q zT~2HAWAF~fB}bnp_c1Oxd3U&+0puUHJ0EIXa`bui1mlu3W0$L+LOu@eZ(MTpdH53J zl9Ok*%UMny8NS-M*V^mYg}?N9B?@g$Wy?d8kd}u$a!yEawekw6Zt6kH{+6%897lqggovfr~X0LPfYR; z$cblMa`fk;RK_J|#1WU1j=Ui}lX1z>pQrK}mz<`@TuveKg79L-B}ae$DsNnJ`kZh% zmC38ZYZ#Xt{kg0mc{2Pw)dKD<^*!HC-deu%e!i0G_2;Z!#^w2K_d~vN&tT&+uKt`g z&baiS`IPH_5_tyrbhx+F*H0t)L*B1trr!6t#6v#ztTk@O-DzARS|NWgc~f{GT*vK- zaW9&B88^>iH||a2cHAe%C1MNmUy!eZzk%zxr!lUlW5{`yas4oEG~;&MM8+i|+-bMY z$;iKA+|+O#cNxabZR%y*VElWvMU2b1z43Z-8RHUB1LIa8uLQ4ZT=L_daO>I3xa2HC zeM|Cr@OH*+PG{qGefk@h{AM6mo9uxN(e2#6{#MAU_6A3fFPBVEwb2dKq^b#?5Ekj$6{W zjN9<6ThG$uwc+LAI_?XM+kpH=E2;4QUN`b_?VT?ozuw0A7Pvk?)a&E{BPk0Cz_pI}__(;o8;>zQiY z&TD~j$uD!kt=kgvQt%aUZ>ev;PUG>i!_>>TH8Ac$<91$WjLWzqk$-`FApDAP-?}0H zhH*Qu$Hpc95ptfB2g6^(bzV0yuSi`&&a>@50l7Y|(;JsQgVASp<2I+Tap^OCkX!#^ z$p)c?gCS9=e5eXXO^9CghFbZOBi+JCGlQcQtPN>}Op1%zoL8 zJBU03d^GuF_&D<4;FICrXx}<_z`D&Rp9J4cJ`;YN{Jk{m{klv(NG9j~`bfSA9;2H( zCsHM^bK+%1Pa@+|u@3d=$%EkejZ03TTQ<+H#wDi$o)=Yx>+8&$a9wI(-L| zPk1NtELYsX-N@6zdmES5b=)DwW!!P7A3;7EJ{B(PCiD6okBfQa`LI6AO^(o8To1Py zmvIjxe;0Wm{1Ew5_%ZUw@YBZaxR;H~xJj;^KFQE{bgKU53h>%f4`8I zhez)oa^B>-cgRTy*Yl9}l=uJX{rbtc^jQP_WF@Z#&qv+|UWmLGyqIxmMaL~;T*mz! z^%cmM!mGk{eUf&R@4UZv#JF9bPUN~i{fx`{%)xbdH2HJ*bn+kY)#SPLx= z~zH_{Td%q5tdg-TBId>keQoX+KbKkg}xBqai z9+TgOzc4P(bM$?mkH#gZ*ERRJ{zBdX{=>NB==(J>db)j-c}Y&h>nz2)+IlaGWCFfRG}zR4KllC$)-%Nb8T20q2Of?WX2^&-$(e#xa1s0 zeOB@n@La|vN8d;I*|_9nc;Mz$k~|jtSL2eS?;}(N{3&^$V$9 z-@jNv^_MES`t_#X_mpL$>t}~?S%(DGoF6tW>)Gm&ThHU<_2FmWGMb#c1?Ani!KPmF z^>y`E#wGtLa^8|ZhJT>^RmhLuJLH^8PRz%y&&1@>;VIzKo&3pl$jM>qrB8i*qlj_I z&x@SmC_&5Zl@WwWbqXWUnh*Ux(ymwp;x+Yj^z4zY_!m&mW+=Z@PZN6vpR?q7cymvPfRb?5vYc}n;f^49SG$o=3^`h}by$zKhR zLB0Z>ko+|~Dfu&aD&uxunT*T0#h$r&Wg{;P&ky&O`p)MqtXm0FFZpqCKdNS2@&_TO z7I_bNed9LA&$#5gMty7Y7w~SzC8ren8Ejl~vOIV59ZsGRJ^}76_02bBdHK%!@4ZvK zAL>_;H-m4coJ`0$PW6*ff0}$0{7=d$iJV|lFZ1n=`MxtQ^NsYv&G!R&IQW0$W#Qrb zhd!Uh;8Bd*apM}7ardDZMzU=Hw~ht&Q89F2*INH0pbhmxA|&>%1DG&++6v;Ql5@#`Q!0D~!vy?U28kybXLa z`4sqe@(J(*SRahcaN>{n{zGB1DBrzf8Z&u(0D0+Ca|xa6EeeG&3g z@L!Ef&RgWvFfKV!Ub}UuLmmO%)VSoN-6B^#kEgA1$@vBK9mz|;`xuv;8ps)HTyh4X zek6H6_(bE9GaNZHjZ4mU)Xyc~3||EImin$UjVj7_-akh^4t~(&$hey@Zjf;q_Z{-D zkiUfAA^-J_TmSpyCEzc}XTe{SPlbOX*ZQyIS|4p-$T^pJ#og*#22Wz+GOx$TPfmUx zo`F2wTQ{%F-m-X3%e$J9_fd6S+)>(5N!F3%@VBFVK-yP%rFfQX>M}CAsA^RwP1s=<| zjH@|`jZ1yPcW%FulgEW;FfKU(=qHbH$*G3=0_2t8Md993-@gBaeW^kojCJTpuIn?( z1Q0qok>0xzKHTyVcacLzXA0-$k)LS8JB)M_<8xXap~tW>d%v3gkOV8 zgzV@W^z(}9KcoIF`6u`{${B{|OOXeMoD=EO4}B&vE`6r{+nt9LZcyIEr@c!iQ;X{nu zamN~$aT~vP>pX$HK71-%=XDzMT25ZInpAjSKOw(``aqK}{RCqjE*h79=3v~bv!Z?p zd1m-(%E^SB{ZwBK^@qr-z|T@n3FJJc`d+AiPTm9lH|3N@PL!b`*F8Dsb5S3Id^S8W zT-T=-ay8IT=LxT zrR4SCzmwO2Zy+BI-$FhRzL)$A{2=)$_(}4=;b+O;!mpAi`Q+C526-a*1M=eVC*(iF z-;lR}zb9`F{|47{6$$tEM8iU#&#|aaMm`#z9O5}{7`sn|<^&dkX6+VG-av&!l4Bt*Ud6Bc5JSY4x<>W>FHLCA``dj4f z;K7um@7um7KaJN#J;Oua?>d&3o%48Nk*~tzH@$KBTuuALzH-n1jN8xER5UIl9Y9WB z^2E6Rj)v>cHPg1c{K>{Ud0W)?iRKxX>*oxt!y@uY@MXq*&o_|2%DCj~>;GGgOa49N z>?FSfKLGcZdSt%i@pIf|Q*ZmfXI%0les<^ZA$fTCGq~paBmc9hxBW*N5&H3)6*LP3B(DPhnezWYeq~c{`>$_Y@_QktF?kPoJL9&`KIFQ; zqm9dXh^yz#xXqboT>4pvaTk%#hA%TN`8D*s8MpJ@YFzT4BWEZ1WB5L}x6~s$eFd-6 zo)5zxnjAZ?H^yb$3}4(id{3SR{x9XkvD{=hU>guB0o*rg}8n@Tym&Wb&`GaxUxrw+AM;H})ACuv8fN|iuFKO}l=S)=+{aoBJzLEa~|JS(W=;z`*qut}eOTO#v1f2h9aCzP$_4+xqcwy8hH}!H~c#GfD zlEJv-=zS`;ap}Ju`pi$>0$$R%Z*u_)_C?{RzhJ z+u2~;UVnDOb=`Um_x>U8*D+HsD?aUSAA4?7yoSNkCkyFpOP!%rBOocobo&KdHH@F3%oqn{7IZCrBvqqv-4^2zYW#wABTAO6m`uDLjsG$Q|BgYzew!OqpX9x(e?ay6dq-bTeGSyVr}}~&UCuXh{k^6Ue{<(t`}_-i z#)9j8O`i`WqI#WIYE$ofJ}|_Mo7uRmkKV8I8<%zN9Mi3HVe;1S62>LpZ>Y;JXI%32 zbMLi`Oa6J})FVF$_cJaz`h24+x%NK-?k)B0Z|Z+sKNC&8^cjFY7aEs-Qp9re4Iobf zUqfCSzMi}$d@FV1_;3vp`ho3cW=XKS%%l>Fo!^Lsy)|mV|a$1uYLw$Sl!tfsCec*k_d%%a1Z-$Q~UkjgT zT;`P)KS$3sF7xulb@N(C{tY?58<(6K$k||Aa(+h67V<*y{l+C{IC4%Kmz>_HKTqBr ze$BY#Y(h@3amm?$`bXq{z@NjtrM~OW&41nX=ZC46{9xoq9UuDqKSNGT@<;GQ#w922 zaF?Ijxb&Gmo?HL)Y_$BgT@IT21 z!0(aYfIlR^41WdJ^SK4*>N9x}{2Uj4Qt0!n^>N5AASbPH-|L_8ycZDfS25$Mz5jPn z7wf5PT&Oz6tqYgOi=4Mzn|fKFAgs?}fNA31f%r^1_(Ux2qDKLhVb9w(LS zzbknZct7$n@ImB5;G@Yu!N-xmgHJYY*I~ACS%-3|U7z#GOTm}Jb)ENPo!6Us$?uMJ zK44t(=OE`Wxj+02`DOS8@(b|m1G9K1OB0C*|#KJc=}!_Jh-0!YdBXc$*&X*jb^UK9 zj|1OBUK4(RyfXX*T>CGB{x6z(>3;FUZLY*LALmbuMP=B|i}B zT*bKL*F=5|@~ZHLx~n{PkzlR{p6?M$H^1qa{Zhpj{v_+eguAv z{17}CuII`R&zJrR!#|SG$2rU}BlPvTB0LZII(QZG=lI-IC-R^1dc{QYoVfl67?;;E z;>LH^`Q66t>ljCjOUL>?_#N`9cwYB{ycPTtdAiST+(iB%*Asbvxqe0G>EOD~`uoX? zP`!Rmtc-Cvw;6J~eXl_N6#H1!xQwfx6KiN(a$e+hIZerD!dn`bobH2N|6Pqs&hUaR zrzd$cct7Kkqo2PTM;@<%%b!PHf4uWQ$UC-jzL#7-e|5sR^!dDy>+=lxV|b8p=~F*{ zb=$b)w9lH-s1X5{1Ht&B^KelDn+amh(m%=OcYJPy3Sammro1&tur&((~FdrN)q z*R;Rj&hrfNtY@6Bq8xqSVXJZJa~k^DNj?d_kMe&;{yFla@CPPG=B4AlHZJ3yM*iRA z$KjtS|0?pM&I&ota=*^g$;~&OaT!09-VwSJOTNy|8x0C$P2@Nf_tNV>(>0dTc3QU z-nTF9o&V3c^m7?GzmlJUSE2k;$ZtdSMN7FpJCGNK_oAF>$QeiV%}_syya{}cahaDN z=C#7O%xetlSCfx`Z-(o-t;V@JP4)Xxf1Z3V{4(Y2M9zKkxVSETF*&|-h5lpBapy$) z(S1x3h8KX#>kl&Dhv=sW`F(iZFmjra_rbn&GcM12gIs%_p(bDYe~ZW0Z^osc=)bu0 zFp)emd?tAr_+0W*@TG8FpW(P3t~K@2PaxKFpKjsHOU^meUm`yR zzeOIav|ERJU| ze)6E7?Z%~_PZ)PM`Fr?b^1{EmeLPN{6Mn|H9rucH8FvHfuamEY-+_Beeb@8GnAbb< zF1XG_oELiE+o3)-T=%6r)*+2?=_f@QH?IujvEW&Z%e*uvuW`uP4JTBM(gA&ea*?a;{=jaOdFyc@+3{^0M&T>rjz=IlQ%Tdmrp- zTvqBi>IacWz3ldVl5u+3>%YdhtlLHOzn=U8e2dAKex{)hSA z+!r>vW%CR-F7>NWKLM`S0Y99#1;(ZSap-di`B3<3@<>(P!0X7rqkgk-Id3}d9^*1@ z7vvlu?*KnRz8Zdpd&e zEXsLT6tby47+y1IZi0hZ&a~eLriWamn$k?Q*7)*MZM8E;;)9 z1b!#i-w&{ZTz@~n33C1Y0GEwRKTk34HS)*s+s36IeShtlamh(q$Ia^%d35+YjYw?Xs&d|E9pTy+d;VFzuPTcYC{AYlB$s-;7^h&<- zcydtvL;QY{0#u*&iK{O`^~t;WVmxK3KJ!agUybVLHh1;)sJ`b5SKplK_5HziR6i5> z-Kk#RHymJG?wi9ix%`pFWqtJT#ZNIV>zuxxTjv?%N#S$gk}B)@;i=1CXX+(i-v``f zT=M;qvyXf_{IGH9zk3#!f6ch$>_Po4@*VJC<2L89aoguR3$ zoE|`Ztxx_6-V`pWGQ;e+Z}v3xHh-vb$xqPGo#&C{@!;bqzZ~)xnR=VQ#<=7cLC$*e zLhzlGKN8O?4w-scH&15ykN5Yq8JGO#$oZ4JG5j9+a`;2?CGc0|PvLLLAHqMA=WOKG z^E-KFc=+E#&Y_)G4C6AdfvAr|-WQ$}E~_Gmf4Z4gLi{_OMUY_g87c4`U$9?L_Q8an{v(~ zXD!ulMg2zd_3*uv^CxnSnR=P;G|cx;<1*j>kaLs#8~mPeoAb=L^0QYM?JvEKXNZV20j64Y5&A8+QB4?O!$;ta% zI`&?V;qp9I);|c(Gv^zZ^-u5T)_*a1O86@BUhuW#o#2~{+i?#VmvOJ5{xJCk_!+p& zM&{KJ^SWy4CBIZwsqlE77?=EFE!@0bkQao%C!YZSL_QksSsnU3Xg|^6y3RGwPZHzO z&n@JnAioOFNS>{w>pu&5MtEMh%w9U1hV?0C>ScX4p`R+orJn)FsX^Wc-jIANyeauc zcw6!}@Q&m!;l1G8{}59z{Rg7|3C5-W?5*7TOd-zaF6UPI zDT<5e|xvTdCBv_3&Eue>G&GvRgFB?OR4a98ie6} zD8B*n2awl;k0c)gA4@(6K9zhW+@CxEzL5MKJb?TSd<}Wx4sPAnlP84lATI&mLtYeq zguEa81bH8L5cxv*74rG;J8<2{YS^!jRDTHdU&s%_BdiO3|E-Ojq;S37K0$p-@<;H@ zl+zJ8rKmneN4L&p$fLolQcgGIw50kxsBcT23*Lirh9PGx)z?M+1oGN&f65t+oYho6 z5cTWG`@=U=j=mpvlzbRo2e?R{{;7LBJ|lnf-1&Fo^7GfO6uyVAC&~Jd{k5M%NM~Fs zz9XjwT=u<_H(KA9X-2NE-*%xKo!3aJ*PJQF<$ARQ>obFV5qu8iFV^)p_0p&Iv(32V zA4SeC^26|hl)o1FS4_QKhhXE9{~S4w$e+TWQ~q}3e=+s8|HvEMe(B>bb|?3EiB299 z9uMwq#dkeFjQmWd-u9o*xb&YNIfcmc!i!P#tS^|t>8#wEW2a+;9WgSRp+_cc#; z`H%PaxEr_q_ct#2Bakzgd=PwuahpHZxb1(2amf!t&TR72@C9(`T6S&%UWeIC{urOz z*=us7pBkCuPkKCOjmx;HI=g)jB2NatLEaF4hrBlYfpI(TOXD)`YSh0WUjhFYE?vuf zKVx3;Hika84^W?o{4P8-d5SJ>zUj%6!E?ZMTt8eV>xAJwDW?>2`jVG~52KuaUdl)w z&rIX?y1LQ0y{_&yE-Nw$KkuA?>vc6kc3-^b2DyHY>j}C3`(N+L6Sj3Zo=qX^FX#Dj zW#_TT_48fH$@TMEnaTC@R|UxR^H;x+>*uekk?ZHF8k6hih}x6u=Ysl>>*st%lI!PQ zCX#0_>egWvbc_*3kQ?pQ}truGf=v&Xamy`D@Z*PP|#I__q2tv^Pt^_R)D{wcZEe<0WTXxl>X zi`FM0*ZS<_T3?i0>#LG$ePeR1??kTk1IV?0Jb8G$Z#4_9&o=^hyXOPzs9qm;yNt{8 zs9|_sv5&kJ{E%_EU+d%aoN>w7($zg6FOsi@|7l!u^m_7$Tpy=zjZ1#cZZ7{H^33q> zaBr#a`QBBmLzL|y`!3HXN*=qHtFK8O9o~q%7Q7jG8F)MLPw-CUFX6q(FZ6c(^e0~f zA3@%vud5$JUJX8lJYqjrKZE=u>KBl&K>ZT(#qibSpW*As|AKEPpW5H`vzvSr{4jaW z0j~Zyc^dc)<8rQoah{(TmveO+^)JXz!{3uH9q7jWL_P=Z*%A72lor1qFP3o`H`O4Q z6OTL|JTcr`>U*4S*(2Y1f1D=Yx7T^WFuWG!FGYSm@+I)bl=A}losG-SO{J3g+VKoB zE;E0N`Y|To_wy;%VTN&8hvOJ`Hu+Kb0?LoS&&_w8ap@;6`Z;7=`pJQHJ7e;tpW*1| zwsGm_HO37le*u4N+~&MCE;(5SyZ!x}JR|%QTxKJEo+hkrIX(*Gv(A9KjXTk}eO+aiap@;N=DU@=C;X^!n}651&3_5k*JlnUas7NU^)l}88M1=j zbGqBDr`GH9z~si|oJ1Vz&U0$=li1%3#_jXK+{Ptm^l+DxpS(Z3h;hl;g}*mc#<=8U z8{u*)kjI2qH7+^&b6-Q_lGAIX%V|p97~ayjb z*iptMXU}Mt^BegN_$1?!qd%X{H7+@6#<-k?+3MnjZ1!%DQ^8|kw<{fr~HiQbFHbDe0@D+dONR*#wC9Pa;lQAgV&<`vB>XW>TUo1$aNpb8kcpbfpwT_ z+~zDWE`44_KTF6j!dJj`9af>w?WW$Y!y)66AA71hx5vn1!cSBFF60N3m&AE{VRB@? z(;mBh|7u*uEr$FboZy!+~kNgjKa`I>J)Z~xgnT`9dhv>h6aTz!L zG`DU=$kW108~2_6CvF|88<(8QsIN_47T$z>1>BE(KD;B`8|`~syj>*UdH)^eFnl`Y zB$M(MSk*C7_@eX-W_$Tts@OTH@zH9$uajsIp<$CUW9AQ0k7?<^|gFf?+ z{|qlm-eZQFZwd0|@N(q8`n&o{dG8#<g!d#L4j)9m20n~@6?`0d5PTB(S@>+YuFnrVFA6aA@_3K?)VDmI z&BkTFQmuCL-A)d{4n`+_!;ulYh3;X@`Ui~+fD8@Ka%Z(Qc}FX}&$ zKY@D!L!a9tf4Dv)lJA7aB5$_V)yE^R15Zx=3Z9z$2|P3Tuj^cXcJhMo0_1PuMaZAP ze<5$b-sP7iZw;?Tz87ALd@Z~&d6x|?zd3m;czg1<@Xq8<;C;xuZglwr$Xmll8kcht zfb&1qxSW$msP`v-0AC3AmU`sG6rLsDdH>#tsh9j<6w{4K7}a^x}L)yZeUYm+yJHzD7* z&E@-%?}4|0>psrKJ`N%uA0QPT&lK|ebDYmL`LaIUvF~e)%lbUUxa-O9!S|Ba-tPK8 zNM0F!l6*J(EcsUWMdP;5o5rQjxI5gqcgZ8eUy+Z2za<|A|4e=Z{+;|HJo4et=fC7m z*H3ivLhuCS%i&4L7r@iPW%p#Hq)X*H@8?j+C&GU=IkIlS*x&NTW!+-za(z}Nj{>hl zUK8GcyfVB6`C@n*^7-(t3yTNzEwg0{7{|0#lc=#jkTxorH>~AW#{(RaU^UY>l=6fFF z<|01}&rkVIagqg^z-JOMUl+5_o(~HuaKU1NrlfOa3L~EG7?vuOj~!zLxwWd>eV* z!)_gRk>`dVfouP>(EmA8FZ~Zk|96c`|BaCIfV>X;CHY498}c>q@8sc*xc{ww+7|;yvxOiULhdg+p{7LWUe@(uuPZ0KfnsHg56Bu_U`62i+@{}iB|0~H8 z!#9$5g>NNq58q|n_Ib#-^m!2V$H;fWFOz3D>H54zo&p|BJ`w(id=&gI^0)AJ$= z$m^eS{rpE>6&~|==;tS!mbiUP29NIDQ(2$1FMZqV$z)vC=L&MNkq5!^lczrI`YBAF z5MGLW7Q77kba++ri}0G{XW)(CGE15HGQ8i>+SJQ@yJNn6jLUq}o^kyTAWsP&N!|!P zmb?LcD)}h5Klu>&T)6hX3;pjQFAIN6o(lWxIT3o_^XR_AW#47Kw=r%i@|*DVlv5fx z`N<#S`cRqtIO>}ix6eO28<&ow;{C)iaP2d~S+_6a$$y~FDU_2GIm=DG?E5C{`zGVE z4*x^`Hu9qI1I8sM7&&K*OU_KxUmza`zYh17`p#!@JU{=7>QkL_^LiTromUs_SlGUT))4}kYD zF7us+`3^NM>wgOMBgv1!e}n6MAEBSQS?j`Bcc`)P8O=u5qadkM;b?xa3qwASvE|XWO{cuR?tp<5J%p_0^0^{ZXt#Yx4A1 zhau!o@VeF_^1tzO@gL;R@Ojo^k1OIM(NH<92<%8JGSmq5p)Z<^S^j9P9m` ze3uKKBg$&r=9e*U^Q#$`oCU~f0++{^e2!v#Z|^tWua4yUx!Hc?-SPLZMw9F3Hm8&8 z=P(zO>*p%hlI!OrcaiJo9*>dh=NK=MCoAgab&EXwBIl3E_46(NkWcx|)rUXh_C?oC z*C!6S{ync$`=`Z>(&VF|mGu(MKay<`?$@M(6C)e}PhkQvPmp_tR&+Sz5 zjZIwrLUP^5HRQUFJIHk(kC5y63?g447c=kI4f33`oj)KiS>E|e^2hC+emGC3;Cj9&P$N%=Vq&f;f={xCv-Vo$o2dTBwvmGea_od{z zj~mE!ANP{$KAt4k$K6G8eH`5**T>Ooa{WB&H*&3yc|P=h9V_S7Eh${@o1P}}o%eYK z)$4i|GcM1&Vx4!-SN});1JAq47?=B|K7MN$mz?d$sYCudyrFT)(Z^#OdWQB3b*^ivn z`FhUp8JC<2mtD?7@>1|;#wAA|7ylTS zoWrR9mwXreyK%|U$8WR?A?I9jN?dXM#3C;Wk8fOZ^!k|`?j_&z$&+|oWT1Mzu4bqD zs7>WhdjGy5)$8@PIMokCep#y5>u}XD>g$<$`T59izi(JibK^2Ey>53mF7-jE?_*r* z^?E+SxUA~B|jk0_2X|`^7Z<^#JJ?=z3TRBIeAX_YPh%5w=dQGu%gqr>0Pj2r8Q%c(~m1Ku1i zyCf@n4C~*))cfXjP*&gL>1$l_e@4zg@;vZSkC(!#p@7H$YvhPXny7k#j zo)CVRycYa8c@6jl@`c z!jr;f$t1Bf)-%1Smp;3r&-})vp9c5bdKMhG4k1{{~!4jcm?wR z;8n;!!t0WEec<|ONZuCS60Ya!JNCCX`C2^BoJ=`akTab;2)=-F{>63d_b~i0<-~mG z`aez{9e#m4Km0OzUifYDR`6i*=J3aGU7r*!*L7j?sV8X6bUpF3KG;lts2-&~0KjwYWEpGFDBReRpeT~mR#$%kw3+_yT~8I50NK&F}c3(@i)1?j`4$BUzdpar`tzeH+{V>5xKr^lA2s!$IC&kugg^p!&{K+ z>wDeEHD?t0D{0vKH61SJSzgM|Bk28_Pxa^UI_+wz&*I8GJE>m#IYzGi+#uI}o>G2V zLRSl2@Di}sU(T>HsQuJt9zwZ0~~);A~D`d;K(KZ0EAr;}^_5^}BI zNPY*epC2OE$M1P^eckmIxxSA2j9gzA{Xnj-Plmr9dj0ir9hW>44p4e>?K3yI<`gH_ z$5Aqx^At>o5geot}nUvGm2d2JB?iXTulD4lFQ#juKD}Pi??(2r^z+{I=Rm4 zDS3?UF6TX5?_X&zJCA-N^nPhSiH*zia{}a`ZlU(zxU_ zed^ZXEO~ACMdOmA=lPCt$@vrY_sOropBR@MeSQ8l+)KWn_XBaxKT*BDKL3O2Jy+c0 zBI?c1j|+W$J}zAI7a>0x)$8l?>B6YbX6k)EpLTNN<~J_$8a&c@8RJqPx3lw##-(0g zpRa3N)-(Jww=WIJzhFI^!M&xvb=!n>=w<39UtgaeX8ixrb>HDNW?dV=kKTz+wCJ4> zT@bw!y%W6?-Ka6T(R&wV^b&@_V8rM~i86YK-ihA%&N}JNd)q{mpvsy>@w? z^PD3>@&k}Rmb@)|66K#o{vPG>y!y#3yW_BOp&3}`8|2-P^Ok%RJkbpkXy>&Mo&|27 z-|Xib1(nM>2V$K|D3^7x^))Epo`;5RysyfUbsLZM89+W3K7xEBJcxWfd@}iY_%!l! z@cGJRzJ8eR3gy!0N7Sz-e-GaZca}!G?)JFx|0pNp6LUVVk$b}Ll2?R3B(DH}MQ-cg zlH2-k`rdqpAJ+mrRi{eO;#@XG4MIbGV;>MU#DE?0djW1?R6S!q4PgF zzmAi8Ry2Nz{6`AocgV-KGX9c$M<3%~$#2&&9zWbPZ2Jks_rIkkZ`jn-XCt?-cZJFA z`&?gg`#!fOxqYA8l-$10?MQB)9|Fnk^T0@Q`}#hG+`iA9LvG*aE+x0m=NrlG^XdUN z9_GgHk=y6|*W@-o&aLSCW$ROt+xpz(w!S#It*=RL>zk3=`kv&r{ugpvKbhRtFCe$| z>&OEpm~*(7+&_WfXjh^T#+oPAHt z>wXgQP4E=TCC9%1%B);+#ym4Q*~t6Cb1Rn|`@Yggx#To@ZgNVJSAhE}mmIslHIz$E z(HADC4tYL!1Lcxq-w(D?E;+xWzCHOIco*f8W8XgxA-Cshta8cU_R{n@k^Fb~ROOOy z&*4Jll2h=N$yrLC9llbzc>|?eIU9OOCycj*#2;gQwxnQiq(pe{jzK zqk8*(Fr4aRG?xFT^WU|ndi#FxCDk`U{YR>|?+1UnsgHjr>bj8U@Sr`eVI9ep%Y5zo z!EDNX6PpHI?5v|J*>;OTK+S*habJUqw!P z^2_ipl%KYl$zPyco*V6-o2*qX{rrJ-4pI5C4qkhuONZl-a_J}5Yct=YrML)FW?!jNA~x#TZEPAT#k@QUOy-kEt-CI5)}dgQ}U z-;lgNyqR*{XMl3)^A_qmkza=QCU5%Q^x2QR9(lo5%y;+sIqO_mFRa?8oI*{sid@|5r|%5_ex`_a$ONYuw8{{@~HZu^{x zKJ$<-fLElPgUG2$egIyZa@ruL7x^)GkjjzQW&8Q$bgCbZ*Ui;#>UUASeO@}~#&4<| zS^xX!KZ5)&{0Vu2FJ`}9kjI06Ah-2j$ZdVB2hsP@*2g2a^&aGfF>WgIg78e_ZQxnS zTfy^@kA)W^9|QM++jI2=&#P6G>(B8TDA&(RZOQHDc!A{hbG*^YWd-eX>|{5-7H&Tm z-H!e@l5d0mL4FOsoBRqql-%*voRcHuKTv;$JP+#6ljne6C+`HmMIHcuM7|#WjC>9J z9o+6?H(Yn$-FU)>=G@wPd!1%bF8l6*?-MJgT=w05j#@#vB&Nr>jg{-1F3NRIpmNFC zhS$4MaQpdZx?#@$==_>VZa+6zMsDA)Z6vqvPj{2s_nSw^?fb{`S z+djXL+s`ZFJu>@Z=W9QINJVZxPsmDc-`5u+x9i|bp0&K`vmUwavlV&9N~XRWd8#hP z2a(%xe%Wk9OJLR^ z@#EjC!ZGBO4Tkl71>;1_; z7BKtO8gB2;9%bcs&VL__>g_&`RxZy)Pw~1imi#V!l5%-|v->_*x#aZ!W?lyulGlMR zQ!Y97d~PDQ=jQ<2S?YQpmkIMauIlAE*=wC^x{gcArJn*nOg~r2v3NzmvKwSF*)za)5Cv|Pl;>lV?K+1o=3qGkr#+(>XVTthNpwu zb^Z(MmQB@5|6c3mv^oF%N#)Z2j`$|OB>8-}ANivMroIaK9e7RUdfbM}W!x$WO-@sC zZ+JWM0*Oq0M{-YiFF3EmU{x>u1YjK|DwlrVA?G*pr|_A|b2n!*NBCOu zmGF(^%iw<~mvO_;f2eX9_ZsStkY9nHggZ-J*W>8&@;m3}qpDu=9UENic&1$PV#A>`4V^pdD&zp|2}zP_zUuI z_-pdR@Gs;aJxu-&@@MdPFQV>mvJN3whg8aC9mXU#IqArMfoCOu0MAJt4le|EM!U{= z?sD=whoc_VS5INaZAe}j-i&ezBd0HU75EgD?z&zu zt`FSqVodTO&!n6p z$eBxC7`}|W8GI#q6Zj^$?WZF838nfGs6RqJ3?4=~rEnj3LiH~O- z4CJ;xKl!g&T-)m?M{f747P;N8X5{vBr%vQ{AN!N%^)Ta(Be&zuBDXoq$?f{DCr=b) z@^`|WOXGSSH0p5tOZ9f#>*RJ`kI8L6@081ZqZY2aPvkY=G2TX9U-CQrSWQPFxV#ENZuEoRk_^X>{mYJk~1Img~;c^OTr~W_gPuh%XzznpA%c3>I1Ksk-Jd6 zUFZJFrJs`+cQE-r_;BSiZpEx7e=@nk{E%|VvEToEM!DonN@sG;lMjYpRxUaA{&rWn<$IY5s!;`51U=<o zp%~TM`(Y(=dp~SIIZct%#Z7&G|j9|}JLcb2-={|n}IS=Gz9ewf#7<$7Mv zl*_m~k^hQ(2mGCK$qz#QXXSccao$IrPszW5oCM@o;7Q@mQrEmTU|wFTUd9c)+S(Gf%mUI{^8M$os*UE7v)@;C8;hVcc`%3*gr%XD0f2s$BY6ig90(FNA-j{Gr(2 z7$3|zvHe*0gv;x)ALjhMx6(Fe;SOx50zB8R189W2J)Hk0?H*P6gj1oOU@q5w?6rK z^dF#Haw0vPzc{}JDA(`HM#1g-vT*^fa>q<^`#iRc+&)KbB)88|yUFcy$Pse;TydV< zJ}2BFx3Bw;$nER?dvg2w7z=-q+|Jj&uB9Zm^;yYneG&5e#mu@@Cb#S6Pj25Yv>~_a z*^@j0{+{VC(1_@ea=r!-lv7B&&IyQcwut8ZocGp-D;BC=kuoI_U|WlB)9)w zLm;`mE=H2u>tYJIy)G7z+v_5jJX>iq-wot9yBXg>Zm*+#wSLKyU&LPxSBL4$k zUAg4gbJ$3^uc2gP1d0vJTdt&xCi+_ zczW^+@J!^#;JL`Vs?uX=lnUE(9PvtVM-)7hL zIud`2ex9GB-h=!hJUw~Y!e-n|xEagFC0>I=5SJ9$HX+ zJ#W)z8}e%KF66u5J;=Af2g2>REh@_IoS&0XeVQU>+*#zQ;PWY`CvrBC*Qjdp50ejt z-z5JJIS=9Xx(mj>zf~^htsMIKNM0K5_#XY741vcc9|TWAz7(FEd@($Yayg&2Paik# zt6cg&j2u7mgYcTN4}!SkC}eFMWn#J^Lw_ei|Wv5P4nrFy%UD zta8Z-M*T$crSPe6+h=avpVz8-$@kbIr_=fOER{?CedO#WkAUx|{7T3_L;e8k^Iql1 zxB(b9)(>-jY@fd(Cms2Ecs95_w=i>H_#X0;@crb+;fIv#K5x14N6MxDNaQ>te-3{~UZjLs&rjs};W2(j zKc5${o{8Z09C~9tGb)#Uf{^1yJ`A2yxy;w*6jClZXHZ|1{3N_2+*#_nFU7!fS_4%t z`GM%Ot#ZjvUec^X2l6EFu9Tk|`9sN1VSSdX92qwh1KT3WSewI94DYFh2$Wy^@z@4qT*7+>f;T_dCMg1r8dhi$y^Mlmn{Kz^SfX5-< z1y2UI;|{JOzjHY9P<`gorvC!u8R11JXFPH$kl(`dLo@QX@c!gYunxb$?Yt^u+!^E* z;qxe`GIBO5m(NB0@ck;gmFv$%4=I-`_HWGVvU17Elg#;x^D9ER)W^cSBH_}%ysxj{ zPpX}JjURkx-F}XdjNJbGx{T!Z=hx*Ww?DtG1iAgWbCt=@)-?V2lPAh#ybbxDcE)>< z=Wk+s2)X^dVjQ{soNX4l{hVz%x&54N6S@7IZ4bHqob4$2|Nb3Y@@I2R|F_BC!=ID? zgnuSa-qYm7jTv=4%D&sr_fnGE&-c8@o0!YaQIOnzzE^_0WL7h71#nDDo|pP5n%Ee2%)D+~#a`<6&<6z8n8YZhwwJ!dTJQ*^ZmZjeEQC%5J==8}IJM zN4W7BZhVy+-$ic!JmN69o$nQLTmOLE)_*3q_3>i=|Ld8S+}7tLxB11%2jR~Ps*~IM zUSo3m_pIBK+rLlUhuq#Lhm+g;Wis&nqiLZtqJa$?g58 zD*1?CO@1SC`*X=UliPn6c&HnnNN#`r*iv$P-`M2FuagfLYx;Z$m!~9oeGiovZs*r` zs$Z7Jc!Ic5>o3n^z3_aJguDwpg>rel_+^aA$*f#*{ziQ^@;z`La*s0Rg`^~TLbxy7 z8Eu|FF|QV?UivAL#PrjXJP)qxS>)UC`n7_*xjZyEzqXS{;yLOudDG;kK2E%-^^|_D zW;LFYd_qp+ImtVkzh3MpN`AS3srMs)KHYeIa!WlVki_|f;p=BFnA>TT-F zlfTSnycT&k>{olZJ)ih?2FGMoFV{r?&hs?#*6{h1gY9wzt9sY_Wz&vhi*m_dgq-c< z3*dh$*Et83OHL^250meQpN8A{;&O4^Bo9EJA1NnBS##liCI5*0*a@QcOZpjs`uOC5 z@Z{vFd`*68^0@HKF#QCQmxljB-q_F7k0h@Lp8&V#=Q_^G3aa0P`qktc;2S6h zAGbKd$%Ev@(E0U=axNq18~IsyoP^QOp#A!qbqif@dL5RmtRMCr=D7 zKt2raO+FZ2n*2|AIr0#AHS&0sO+U5Bf1)rt{e1E(@D<7>#~(TCl}k>(DrS8)ljnl(RxUX~ z$O%<0IbBeHgggL#M!DpKBImMl$=QYa>*U+u58=*I*K?Eya$+Phzmdl($%$Fj%qtH0 z59FjKuYmgWRe}h1+?h#k{Jy@s5;p3priMufqe$(^oU= zGmtzjd=%XFQxE+tp!)KtUqbE+|DAGLBIj?a?}++;$lJqDQ%)D;+@bnOsDD5{0Uk*? z_8fX9Hi34&-grJQ4!7s(59E|4-vqBjo~gQ7=W67s;q}SK!W)r~hBt@XJ}aTmf#h}J z6UhDHD=Ggd@_#4a2j5CwzJ{6C4)QYaedMFz2g!%PPmte(pC-Qn|4+HxPwc;&a96q9 z2P)SzeLf_w0Dlg*>)8eC6DLXZ^AH60A`eX^ugVTbS-6zRxTBF@f&3SE4e|@{I^-wd zO~@P7GV^LdUK8Gd{3^T)`B`{h@_^bVe*k%7_z3cM@F4QX@X6%k>X`g#n%eLa)^FL?v_CAd9T{`h{{TdH2ptry;pzfvye zCwYC7|CT%%{2O@*xFe}KxAq(sgC`(w1y4fW0-geH`|p7MeaN%I`;rI2r%?VR*`t{@^;M>U$!*`MIh5t?N*TD4i4|yqg7@=i#k7YKK*e%lPj0=IUDt<$*03Jlb?oXBR>Jp zPae0CnO9-*nDA2MmEgYQzVNDWd!GB^&n4@tdYSJ`%(u02nePnb1dvaIcPIY`-kUrW zKA8Lwd>Huy_-MH8|2OpiC;3|VIm*e>*sSM8@=Wk+loO2W_Y=9zPk;w+=|?_0X)eEU zex*|`Z>9Xxy4c|ZxA&zw7`G&OCAc5?8F&@)L-4xf?eW2V1M(*DmgKMCZONa&yOLLG zYSyzSc`5inxZSS>Scg%n-gW=S2W>Ny%XvG1oH^vX;Y-PrH8cGLlP7?0Aa4iXLf#6# zL%HtrFx<{-E9P~byf6GU`51Vd|s$tjDR{p2O#$CXP?C~__-mz*J}ze?T@en+|F*uR(e zRJr6FLH$eeQ21N8v()uDLs@)~oghW@*GDh>xk(D;lJ96`)-4VB7vyJA?plB3hRKVyDuT=zaiE4L48y5Uhr0wvkN%`$dAFNQqCOY z%p{)$pGP_WB4;D{P55ET*@K+pY zKfQTgDgw8!cQM{xo*CYaa&jZ57kN&2Kg!9DoC)M5;VUSo4suqL z*MhI79AD%dAg=?zOga6KbDg{|{5It@K+Zez_V6UBqhF`C{2U5;#2d-{w3UaBg)Cz+03^Yc_w%Od0TiV z@|N)4?;X>72Cl zE3I-lS65J|B0PE+!J@OI=o;2p`g!h4aw zf(Md6gAan+{@0@a3CiWXt;czruUu%R{72{4cFHf+%dGz{@;vY`<+A<(_;b~8<+A>t zP=AN~Is7Ty_V2*ouZiUubxtH_R&Uc!Jn|Xv4r}D}&ibyADH9pAK$cPdj7WjO6X%Imv_JdC8Z;i^6$aUsW&r8;1R@ zt6cW?7IGSpUxqhTu5;Qcmz?T-&Hi>IuMF=+J`o;BJ_h~^`7`)P@_X=K;dUMFVEvaV zm%rbKzuxUwr(Cx1E$VlYr;z`X^XsT`q3tepIQ~;EIU&e-3b*@SE6}XZOY$11_yO{z@I&Ma;it&2!_SgmfL~EA=OF~= z^S*L94}OD8pO49X;jfiTP9$=^D3_dJsQ*De7#=Tk)cs9zyzqSj9?B(WC+bs?hrqqy z&QjO@{*Lv}=f%u#e*M#?g+y3{V|KZBzyv@XU zo1k3ITRYS*P%icM`$#t_m-;Z&AA{TT8H|2TkxzhMB)>Sstiu)Z?eGZlhQFBl`{d=} zZ^+9HGxZ{5V`YgtS8{&p!4t#nI;Zh+E{5|fjT`r&ob$*jN&YX~kKAj7 z>8A?0C%i6sAiM#2FL+Dx_3*ajYvEnV&%%3>pN0p*?fT^OaxITz9=Sh!h02lZ*B{q! zh;mu~&&c0N{u+LOyxmB%ZimR5z)z9igr6n91iz?U_jyyf^yxdwj2l5-3jS8P&iSTX zat5Q`{zVCUef5VY@QQvucfpg8Z-J*FPe0o9=}Dd(o?W^0ITQQhtz7yXg8E|QgW#p% z&QjNXbq)5t9(iasb56Qa&Qj#`Bwq{Am;0ps z`<3ysntieJ-GiLuaM?#$&rqyqHs!LOCo!*FrB7w!oL}eQ_VsiU*6kwsukbtMSK$xHFTvj`m+RLL_c2F~Sg!Hy zxE_C%;aU^B`K#ka>|nXz^k~)X+iZZQQwBVIlKeq)I&c5 z$-iU$7m(XOPYfY%iJUOFUAHk9_Y(O?csTh!_#N`y@Kn-XNlfQ;1 zhufUp$jL_D8(x@vG`uePRCr5r+h*+bgoWs@RY2cg5 z+rUG}Tfp~{&x0Qzp94Qn9t!`Dd_Vja`4{+I@(=K5aJw(F&9*u|sd~9i196?k$rXLy zi~nZUCjq$+Jf(8U2}X{Wa(TUOjrttq&EW-=OHK%K$|#qdg{Uu2J{w-0{4u;X`CYg_ z+!^h<&veB4bSEzWA3}~FKkisSz7O@AmCN}Yiu3uWayg%eQGb^F8vF+N9r!!ta>V_! zJAZM0CChCJ>^Uzx)$C(Ravyj`@}+Pu^2PAHa9KAQHwfeUsCwB)FML0wpK{s9Q^=`8 zegs~V@`I7zQn{?>9<1jO<St5F=QOhp^U2e|cd8u8e~kQpluQ1R9L`^yU#C@$ z%r^k@4OcGnZHD|i7pZozl3EbJbYkyB- zzQvX6^{K90*5^Fx1IQ!b!{N4{+|$jzj3&WwTlf<4JMcB+f6p}itSA2qzMcFF zd>8o#_}}CuXPNwe$bH}s$w$JUlJ|wbCHI_d@;{QNfIIS;eYfjB6&{;>5(aVUqV04$;067DZdT!2UC60Ic9x^ zktc?aS1$c{)Imhn2hT^XMl` zx%4w0^_R%Uz;7v+oSDdZrd)Ckqy8270r)57k`soU82O{0E04Kmo#T)vh9`tOBV6k< z7yFf#Jgq#WIKT3d+w)e;jW>YXb6x}EHX*MDZ%f`6-hsR~yer)HZ?B7?%H=-U4fn|z zDo57M3*Wc7RJpAGLgWXN&xLPLE;;_l*`Zu=E};HT^0V+m$|WZVIcJqiPU3lHA1{!{ zhu=^xIrjT??<<#_YN&rqUJ3qIx#UEk9|s*Fuv&kUSlHG~Dj{ zJj{10`A+yI^8N5VsILr9=&Y6NWjWTTI{7HLKY7f>W}O?8KV4+J4SDP(#@myBLrxF!5vcD& zJ`g@px!ebWaUYngT;}xw^$W?L!&j2`S!(+HoxBTtEBQnC4)R;@edINknf!y~mEb4f z_I#ele%+z^WvG8ZJ`4Vm+-JEN_YHY&_&2y6w|jo)!Ek=1E*$-N;~?tOlOKR*hTEJ$ z$SFWx6+c(DGi|h<<({zYG7BJjV*NJ`>0@!)K5Wg3lrE4G)3a zb+G*(rTQDFKS_QCet|q)u<7$Mc?$S#xE=Q>*6oR^m+K`G*UJ~>a=mm#&JXhT@L1ka z=RxNrRxUX^QSU(>0#6OMea6SW7bbsz{%cUq2jtWte+O?sIbV>|fqXA~5_t&vSxxyq zE6w_^BTo+xA@8)x)bAwsgC8Kjx7ySnBL5G53U1eJK|yn!-c$9mFJAH@;QWeIF8eZO zjmdvUJ{QCt;DOeV3ebs834%FFYmOS?YSeDuh0Zs(Q%}Mt)i4lAq*v(`N